From 0696acbfc26da11b66704d56049774d9bdef68df Mon Sep 17 00:00:00 2001
From: kopunovic-s-isu <srdank@iastate.edu>
Date: Thu, 8 May 2025 10:58:18 -0500
Subject: [PATCH 01/11] Create .review-log-reviewed.md

Reviewed code changes and suggested updates in essays.
---
 .review-log-reviewed.md | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 .review-log-reviewed.md

diff --git a/.review-log-reviewed.md b/.review-log-reviewed.md
new file mode 100644
index 000000000000..85552ed310aa
--- /dev/null
+++ b/.review-log-reviewed.md
@@ -0,0 +1 @@
+Reviewed code refactors, and changes suggested in teh essays.

From d1b48d225a4634f334812abb0d16917745ff6d66 Mon Sep 17 00:00:00 2001
From: Jongmin Lee <gigm2121@gmail.com>
Date: Thu, 8 May 2025 23:58:48 -0500
Subject: [PATCH 02/11] Contribution evidences

---
 .../buffered_tracker_store.py                 |  0
 team-rasa-contribution/contribution.doc       | 94 +++++++++++++++++++
 team-rasa-contribution/processor.py           | 20 ++++
 .../test_buffered_tracker_store.py            |  0
 4 files changed, 114 insertions(+)
 create mode 100644 team-rasa-contribution/buffered_tracker_store.py
 create mode 100644 team-rasa-contribution/contribution.doc
 create mode 100644 team-rasa-contribution/processor.py
 create mode 100644 team-rasa-contribution/test_buffered_tracker_store.py

diff --git a/team-rasa-contribution/buffered_tracker_store.py b/team-rasa-contribution/buffered_tracker_store.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/team-rasa-contribution/contribution.doc b/team-rasa-contribution/contribution.doc
new file mode 100644
index 000000000000..13d13aecd281
--- /dev/null
+++ b/team-rasa-contribution/contribution.doc
@@ -0,0 +1,94 @@
+1. BufferedTrackerStore Implementation
+Contributor: Alisala Mwamba
+What to Submit: buffered_tracker_store.py
+
+2. Unit Test Script for Buffered Save
+Contributor: Fadi Masannat
+What to Submit: test_buffered_tracker_store.py
+
+3. Add logging + observability to message processing flow
+Contributor: Jacob Mashol
+What to Submit: processor.py
+
+4. Contribution 4: BufferedTrackerStore
+Contributor: Jongmin Lee
+
+from rasa.core.tracker_store import TrackerStore
+
+class BufferedTrackerStore(TrackerStore):
+    """
+    A custom TrackerStore that buffers tracker events and flushes them
+    to persistent storage in batches. This reduces write frequency,
+    which helps minimize I/O bottlenecks in high-concurrency environments.
+    """
+
+    def __init__(self, flush_interval=5):
+        """
+        Initializes the buffered tracker with an empty queue.
+
+        Args:
+            flush_interval (int): Number of events to buffer before auto-flushing.
+        """
+        self._pending_events = []
+        self.flush_interval = flush_interval
+
+    def update(self, tracker, event):
+        """
+        Buffers the incoming event. Flushes to storage automatically
+        if buffer reaches threshold.
+
+        Args:
+            tracker (DialogueStateTracker): The active tracker object.
+            event (Event): A new user or system event to store.
+        """
+        self._pending_events.append(event)
+        print(f"[Buffered] Queued event: {event}")
+
+        if len(self._pending_events) >= self.flush_interval:
+            self.flush(tracker)
+
+    def flush(self, tracker):
+        """
+        Writes all pending events to persistent storage and clears buffer.
+
+        Args:
+            tracker (DialogueStateTracker): The tracker to update.
+        """
+        if self._pending_events:
+            print(f"[Flushing] {len(self._pending_events)} pending events.")
+            tracker.update_events(self._pending_events)
+            self._pending_events.clear()
+            super().save(tracker)
+            print("[Flush Complete]")
+
+5. Inline Code Comments & Documentation
+Contributor: Z Harvey
+What to Submit: Edited code with docstrings and inline comments
+
+class BufferedTrackerStore(TrackerStore):
+    """
+    A TrackerStore that buffers events and writes them in batches
+    instead of saving after every individual event.
+    Improves performance under high concurrency.
+    """
+
+    def update(self, event):
+        # Append the new event to the pending buffer
+        self._pending_events.append(event)
+        # Flush automatically if buffer reaches threshold
+        if len(self._pending_events) >= self.flush_interval:
+            self.flush()
+
+6. Slide Deck Prep / Presentation Notes — Commented Sample Code
+Contributor: Srdan Kopunovic
+# Buffered behavior: update is queued until flush threshold is met
+buffered_store = BufferedTrackerStore(flush_interval=3)
+
+# Add three events
+buffered_store.update(tracker, UserUttered("hi"))        # Queued
+buffered_store.update(tracker, SlotSet("food", "pizza")) # Queued
+buffered_store.update(tracker, UserUttered("bye"))       # Flush triggered here!
+
+# Benefit:
+# - Only ONE write happens after 3 events instead of 3 writes
+# - Reduces I/O load while maintaining conversation consistency
\ No newline at end of file
diff --git a/team-rasa-contribution/processor.py b/team-rasa-contribution/processor.py
new file mode 100644
index 000000000000..78496e5c08a1
--- /dev/null
+++ b/team-rasa-contribution/processor.py
@@ -0,0 +1,20 @@
+# Inside rasa/core/processor.py (method: handle_message)
+
+import time
+import logging
+
+logger = logging.getLogger(__name__)
+
+async def handle_message(self, message: UserMessage) -> Optional[List[Dict[Text, Any]]]:
+    start_time = time.perf_counter()
+    
+    tracker = await self._get_tracker(message.sender_id)
+
+    # existing processing steps (NLU, policy prediction, action execution)...
+    await self._run_action(tracker, ...)
+
+    end_time = time.perf_counter()
+    duration = round(end_time - start_time, 3)
+    logger.info(f"[Runtime] Message '{message.text}' processed in {duration}s")
+
+    return output_channel.messages
diff --git a/team-rasa-contribution/test_buffered_tracker_store.py b/team-rasa-contribution/test_buffered_tracker_store.py
new file mode 100644
index 000000000000..e69de29bb2d1

From c8a6eeb5f3c23b0ca9bcb897c92ae1bb88dd2ceb Mon Sep 17 00:00:00 2001
From: Jongmin Lee <gigm2121@gmail.com>
Date: Fri, 9 May 2025 00:03:48 -0500
Subject: [PATCH 03/11] Update buffered_tracker_store.py

---
 team-rasa-contribution/buffered_tracker_store.py | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/team-rasa-contribution/buffered_tracker_store.py b/team-rasa-contribution/buffered_tracker_store.py
index e69de29bb2d1..29c5a43343de 100644
--- a/team-rasa-contribution/buffered_tracker_store.py
+++ b/team-rasa-contribution/buffered_tracker_store.py
@@ -0,0 +1,15 @@
+class BufferedTrackerStore(TrackerStore):
+    def __init__(self, flush_interval=5):
+        self._pending_events = []
+        self.flush_interval = flush_interval
+
+    def update(self, event):
+        self._pending_events.append(event)
+        if len(self._pending_events) >= self.flush_interval:
+            self.flush()
+
+    def flush(self):
+        if self._pending_events:
+            tracker.update_events(self._pending_events)
+            self._pending_events.clear()
+            super().save(tracker)

From 9451fead528c2fd72a1cd69c2f0a18af75aa7dcd Mon Sep 17 00:00:00 2001
From: Jongmin Lee <gigm2121@gmail.com>
Date: Fri, 9 May 2025 00:05:12 -0500
Subject: [PATCH 04/11] Update test_buffered_tracker_store.py

---
 .../test_buffered_tracker_store.py                   | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/team-rasa-contribution/test_buffered_tracker_store.py b/team-rasa-contribution/test_buffered_tracker_store.py
index e69de29bb2d1..aac4dd116e85 100644
--- a/team-rasa-contribution/test_buffered_tracker_store.py
+++ b/team-rasa-contribution/test_buffered_tracker_store.py
@@ -0,0 +1,12 @@
+def test_buffered_tracker_save():
+    store = BufferedTrackerStore(flush_interval=2)
+    tracker = DialogueStateTracker("user123", slots=[])
+    event1 = UserUttered("hi")
+    event2 = SlotSet("pizza", "pepperoni")
+
+    store.update(event1)
+    assert len(store._pending_events) == 1
+
+    store.update(event2)
+    # flush should trigger
+    assert len(store._pending_events) == 0  # should be cleared after flush

From bc7d737221a125f96d6a98e2252981dd2bac0e80 Mon Sep 17 00:00:00 2001
From: Zachary Harvey <zdharvey@iastate.edu>
Date: Sat, 10 May 2025 00:03:03 -0500
Subject: [PATCH 05/11] Added Z's contributions for comments

---
 .../buffered_tracker_store.py                 | 22 +++++++++++--------
 team-rasa-contribution/contribution.doc       |  5 +++++
 team-rasa-contribution/processor.py           | 18 ++++++++-------
 .../test_buffered_tracker_store.py            | 10 ++++-----
 4 files changed, 33 insertions(+), 22 deletions(-)

diff --git a/team-rasa-contribution/buffered_tracker_store.py b/team-rasa-contribution/buffered_tracker_store.py
index 29c5a43343de..ec33f7943fa5 100644
--- a/team-rasa-contribution/buffered_tracker_store.py
+++ b/team-rasa-contribution/buffered_tracker_store.py
@@ -1,15 +1,19 @@
-class BufferedTrackerStore(TrackerStore):
-    def __init__(self, flush_interval=5):
-        self._pending_events = []
-        self.flush_interval = flush_interval
+class BufferedTrackerStore(TrackerStore): # example class
+    """A tracker store that buffers events and flushes them to the underlying store."""
+    def __init__(self, flush_interval=5): 
+        self._pending_events = [] # buffer for events
+        self.flush_interval = flush_interval # time interval to flush events
 
-    def update(self, event):
-        self._pending_events.append(event)
+    def update(self, event): 
+        self._pending_events.append(event) # add event to buffer
+        # Check if we need to flush
         if len(self._pending_events) >= self.flush_interval:
+            # If the buffer is full, flush the events
             self.flush()
 
-    def flush(self):
+    def flush(self): 
         if self._pending_events:
-            tracker.update_events(self._pending_events)
+            tracker.update_events(self._pending_events) # update the tracker with buffered events
+            # Clear the buffer after flushing
             self._pending_events.clear()
-            super().save(tracker)
+            super().update(tracker) # save the tracker to the underlying store
diff --git a/team-rasa-contribution/contribution.doc b/team-rasa-contribution/contribution.doc
index 13d13aecd281..d29fa4394728 100644
--- a/team-rasa-contribution/contribution.doc
+++ b/team-rasa-contribution/contribution.doc
@@ -17,6 +17,7 @@ from rasa.core.tracker_store import TrackerStore
 
 class BufferedTrackerStore(TrackerStore):
     """
+    Z
     A custom TrackerStore that buffers tracker events and flushes them
     to persistent storage in batches. This reduces write frequency,
     which helps minimize I/O bottlenecks in high-concurrency environments.
@@ -24,6 +25,7 @@ class BufferedTrackerStore(TrackerStore):
 
     def __init__(self, flush_interval=5):
         """
+        Z
         Initializes the buffered tracker with an empty queue.
 
         Args:
@@ -34,6 +36,7 @@ class BufferedTrackerStore(TrackerStore):
 
     def update(self, tracker, event):
         """
+        Z
         Buffers the incoming event. Flushes to storage automatically
         if buffer reaches threshold.
 
@@ -49,6 +52,7 @@ class BufferedTrackerStore(TrackerStore):
 
     def flush(self, tracker):
         """
+        Z
         Writes all pending events to persistent storage and clears buffer.
 
         Args:
@@ -67,6 +71,7 @@ What to Submit: Edited code with docstrings and inline comments
 
 class BufferedTrackerStore(TrackerStore):
     """
+    Z
     A TrackerStore that buffers events and writes them in batches
     instead of saving after every individual event.
     Improves performance under high concurrency.
diff --git a/team-rasa-contribution/processor.py b/team-rasa-contribution/processor.py
index 78496e5c08a1..c9b7cd26e670 100644
--- a/team-rasa-contribution/processor.py
+++ b/team-rasa-contribution/processor.py
@@ -1,20 +1,22 @@
 # Inside rasa/core/processor.py (method: handle_message)
 
-import time
+import time 
 import logging
 
-logger = logging.getLogger(__name__)
+logger = logging.getLogger(__name__) 
 
-async def handle_message(self, message: UserMessage) -> Optional[List[Dict[Text, Any]]]:
-    start_time = time.perf_counter()
+async def handle_message(self, message: UserMessage) -> Optional[List[Dict[Text, Any]]]: #handle_message method
+    """Process a message from a user and return the response messages."""
+    start_time = time.perf_counter() # Start the timer
     
-    tracker = await self._get_tracker(message.sender_id)
+    tracker = await self._get_tracker(message.sender_id) # Retrieve the tracker for the user
 
     # existing processing steps (NLU, policy prediction, action execution)...
-    await self._run_action(tracker, ...)
+    await self._run_action(tracker, ...) # Run the action based on the tracker state
 
-    end_time = time.perf_counter()
-    duration = round(end_time - start_time, 3)
+    end_time = time.perf_counter() # End the timer
+    duration = round(end_time - start_time, 3) # Calculate the duration
+    # Log the processing time
     logger.info(f"[Runtime] Message '{message.text}' processed in {duration}s")
 
     return output_channel.messages
diff --git a/team-rasa-contribution/test_buffered_tracker_store.py b/team-rasa-contribution/test_buffered_tracker_store.py
index aac4dd116e85..1ee0a79b145c 100644
--- a/team-rasa-contribution/test_buffered_tracker_store.py
+++ b/team-rasa-contribution/test_buffered_tracker_store.py
@@ -1,11 +1,11 @@
 def test_buffered_tracker_save():
-    store = BufferedTrackerStore(flush_interval=2)
-    tracker = DialogueStateTracker("user123", slots=[])
-    event1 = UserUttered("hi")
-    event2 = SlotSet("pizza", "pepperoni")
+    store = BufferedTrackerStore(flush_interval=2) # example flush interval
+    tracker = DialogueStateTracker("user123", slots=[])  # example tracker
+    event1 = UserUttered("hi") # example event
+    event2 = SlotSet("pizza", "pepperoni") # example event
 
     store.update(event1)
-    assert len(store._pending_events) == 1
+    assert len(store._pending_events) == 1 # should be 1 after first update
 
     store.update(event2)
     # flush should trigger

From a04295902eebfc623f66fe6f85229fafc98262b5 Mon Sep 17 00:00:00 2001
From: Jongmin Lee <gigm2121@gmail.com>
Date: Mon, 12 May 2025 23:04:12 -0500
Subject: [PATCH 06/11] Delete team-rasa-contribution/contribution.doc

---
 team-rasa-contribution/contribution.doc | 99 -------------------------
 1 file changed, 99 deletions(-)
 delete mode 100644 team-rasa-contribution/contribution.doc

diff --git a/team-rasa-contribution/contribution.doc b/team-rasa-contribution/contribution.doc
deleted file mode 100644
index d29fa4394728..000000000000
--- a/team-rasa-contribution/contribution.doc
+++ /dev/null
@@ -1,99 +0,0 @@
-1. BufferedTrackerStore Implementation
-Contributor: Alisala Mwamba
-What to Submit: buffered_tracker_store.py
-
-2. Unit Test Script for Buffered Save
-Contributor: Fadi Masannat
-What to Submit: test_buffered_tracker_store.py
-
-3. Add logging + observability to message processing flow
-Contributor: Jacob Mashol
-What to Submit: processor.py
-
-4. Contribution 4: BufferedTrackerStore
-Contributor: Jongmin Lee
-
-from rasa.core.tracker_store import TrackerStore
-
-class BufferedTrackerStore(TrackerStore):
-    """
-    Z
-    A custom TrackerStore that buffers tracker events and flushes them
-    to persistent storage in batches. This reduces write frequency,
-    which helps minimize I/O bottlenecks in high-concurrency environments.
-    """
-
-    def __init__(self, flush_interval=5):
-        """
-        Z
-        Initializes the buffered tracker with an empty queue.
-
-        Args:
-            flush_interval (int): Number of events to buffer before auto-flushing.
-        """
-        self._pending_events = []
-        self.flush_interval = flush_interval
-
-    def update(self, tracker, event):
-        """
-        Z
-        Buffers the incoming event. Flushes to storage automatically
-        if buffer reaches threshold.
-
-        Args:
-            tracker (DialogueStateTracker): The active tracker object.
-            event (Event): A new user or system event to store.
-        """
-        self._pending_events.append(event)
-        print(f"[Buffered] Queued event: {event}")
-
-        if len(self._pending_events) >= self.flush_interval:
-            self.flush(tracker)
-
-    def flush(self, tracker):
-        """
-        Z
-        Writes all pending events to persistent storage and clears buffer.
-
-        Args:
-            tracker (DialogueStateTracker): The tracker to update.
-        """
-        if self._pending_events:
-            print(f"[Flushing] {len(self._pending_events)} pending events.")
-            tracker.update_events(self._pending_events)
-            self._pending_events.clear()
-            super().save(tracker)
-            print("[Flush Complete]")
-
-5. Inline Code Comments & Documentation
-Contributor: Z Harvey
-What to Submit: Edited code with docstrings and inline comments
-
-class BufferedTrackerStore(TrackerStore):
-    """
-    Z
-    A TrackerStore that buffers events and writes them in batches
-    instead of saving after every individual event.
-    Improves performance under high concurrency.
-    """
-
-    def update(self, event):
-        # Append the new event to the pending buffer
-        self._pending_events.append(event)
-        # Flush automatically if buffer reaches threshold
-        if len(self._pending_events) >= self.flush_interval:
-            self.flush()
-
-6. Slide Deck Prep / Presentation Notes — Commented Sample Code
-Contributor: Srdan Kopunovic
-# Buffered behavior: update is queued until flush threshold is met
-buffered_store = BufferedTrackerStore(flush_interval=3)
-
-# Add three events
-buffered_store.update(tracker, UserUttered("hi"))        # Queued
-buffered_store.update(tracker, SlotSet("food", "pizza")) # Queued
-buffered_store.update(tracker, UserUttered("bye"))       # Flush triggered here!
-
-# Benefit:
-# - Only ONE write happens after 3 events instead of 3 writes
-# - Reduces I/O load while maintaining conversation consistency
\ No newline at end of file

From fd1db01c008146bca5708bd4dd6fbb1dd52ed69c Mon Sep 17 00:00:00 2001
From: Jongmin Lee <gigm2121@gmail.com>
Date: Wed, 14 May 2025 12:59:43 -0500
Subject: [PATCH 07/11] Update tracker_store.py

---
 rasa/core/tracker_store.py | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/rasa/core/tracker_store.py b/rasa/core/tracker_store.py
index a91f9f5c6b87..4794f0550a20 100644
--- a/rasa/core/tracker_store.py
+++ b/rasa/core/tracker_store.py
@@ -1373,6 +1373,25 @@ def _additional_events(
             tracker.events, number_of_events_since_last_session, len(tracker.events)
         )
 
+class BufferedTrackerStore(TrackerStore): 
+    """A tracker store that buffers events and flushes them to the underlying store."""
+    def __init__(self, flush_interval=5): 
+        self._pending_events = [] # buffer for events
+        self.flush_interval = flush_interval # time interval to flush events
+
+    def update(self, event): 
+        self._pending_events.append(event) # add event to buffer
+        # Check if we need to flush
+        if len(self._pending_events) >= self.flush_interval:
+            # If the buffer is full, flush the events
+            self.flush()
+
+    def flush(self): 
+        if self._pending_events:
+            tracker.update_events(self._pending_events) # update the tracker with buffered events
+            # Clear the buffer after flushing
+            self._pending_events.clear()
+            super().update(tracker) # save the tracker to the underlying store
 
 class FailSafeTrackerStore(TrackerStore):
     """Tracker store wrapper.

From 4a6453f82299ff0362f65bea78d1d32814485926 Mon Sep 17 00:00:00 2001
From: Jongmin Lee <gigm2121@gmail.com>
Date: Wed, 14 May 2025 13:12:10 -0500
Subject: [PATCH 08/11] Update processor.py

---
 rasa/core/processor.py | 41 ++++++++++++++++++++++++++++-------------
 1 file changed, 28 insertions(+), 13 deletions(-)

diff --git a/rasa/core/processor.py b/rasa/core/processor.py
index fc628c7a7247..6cba13bf222b 100644
--- a/rasa/core/processor.py
+++ b/rasa/core/processor.py
@@ -8,6 +8,8 @@
 from types import LambdaType
 from typing import Any, Dict, List, Optional, Text, Tuple, Union
 
+
+
 from rasa.core.http_interpreter import RasaNLUHttpInterpreter
 from rasa.engine import loader
 from rasa.engine.constants import PLACEHOLDER_MESSAGE, PLACEHOLDER_TRACKER
@@ -149,34 +151,47 @@ def _load_model(
             except tarfile.ReadError:
                 raise ModelNotFound(f"Model {model_path} can not be loaded.")
 
+
     async def handle_message(
         self, message: UserMessage
     ) -> Optional[List[Dict[Text, Any]]]:
         """Handle a single message with this processor."""
-        # preprocess message if necessary
+        
+        # Start timer for performance monitoring
+        start_time = time.perf_counter()
+    
+        # Preprocess and log message, but do not save tracker yet
         tracker = await self.log_message(message, should_save_tracker=False)
-
+    
+        # If the model is NLU-only, skip action prediction
         if self.model_metadata.training_type == TrainingType.NLU:
             await self.save_tracker(tracker)
             rasa.shared.utils.io.raise_warning(
                 "No core model. Skipping action prediction and execution.",
                 docs=DOCS_URL_POLICIES,
             )
+    
+            # Stop timer and log runtime duration
+            end_time = time.perf_counter()
+            duration = round(end_time - start_time, 3)
+            logger.info(f"[Runtime] NLU-only message '{message.text}' processed in {duration}s")
+    
             return None
-
-        tracker = await self.run_action_extract_slots(message.output_channel, tracker)
-
-        await self._run_prediction_loop(message.output_channel, tracker)
-
-        await self.run_anonymization_pipeline(tracker)
-
+    
+        # Predict the next action
+        await self._predict_and_execute_next_action(message.output_channel, tracker)
+    
+        # Save tracker state after processing
         await self.save_tracker(tracker)
-
-        if isinstance(message.output_channel, CollectingOutputChannel):
-            return message.output_channel.messages
-
+    
+        # Stop timer and log total processing duration
+        end_time = time.perf_counter()
+        duration = round(end_time - start_time, 3)
+        logger.info(f"[Runtime] Message '{message.text}' fully processed in {duration}s")
+    
         return None
 
+
     async def run_action_extract_slots(
         self, output_channel: OutputChannel, tracker: DialogueStateTracker
     ) -> DialogueStateTracker:

From 5c846d2e11a51f7663f356b3c877936312b75438 Mon Sep 17 00:00:00 2001
From: Jongmin Lee <gigm2121@gmail.com>
Date: Wed, 14 May 2025 13:18:51 -0500
Subject: [PATCH 09/11] Add files via upload

---
 tests/core/test_buffered_tracker_store.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 tests/core/test_buffered_tracker_store.py

diff --git a/tests/core/test_buffered_tracker_store.py b/tests/core/test_buffered_tracker_store.py
new file mode 100644
index 000000000000..19e687d5158c
--- /dev/null
+++ b/tests/core/test_buffered_tracker_store.py
@@ -0,0 +1,12 @@
+def test_buffered_tracker_save():
+    store = BufferedTrackerStore(flush_interval=2)
+    tracker = DialogueStateTracker("user123", slots=[])
+    event1 = UserUttered("hi")
+    event2 = SlotSet("pizza", "pepperoni")
+
+    store.update(event1)
+    assert len(store._pending_events) == 1
+
+    store.update(event2)
+    # flush should trigger
+    assert len(store._pending_events) == 0  # should be cleared after flush
\ No newline at end of file

From d3f75ba11377a5e3be74d63661763b74eac11a3c Mon Sep 17 00:00:00 2001
From: Jongmin Lee <gigm2121@gmail.com>
Date: Wed, 14 May 2025 13:19:41 -0500
Subject: [PATCH 10/11] Delete team-rasa-contribution directory

---
 .../buffered_tracker_store.py                 | 19 ----------------
 team-rasa-contribution/processor.py           | 22 -------------------
 .../test_buffered_tracker_store.py            | 12 ----------
 3 files changed, 53 deletions(-)
 delete mode 100644 team-rasa-contribution/buffered_tracker_store.py
 delete mode 100644 team-rasa-contribution/processor.py
 delete mode 100644 team-rasa-contribution/test_buffered_tracker_store.py

diff --git a/team-rasa-contribution/buffered_tracker_store.py b/team-rasa-contribution/buffered_tracker_store.py
deleted file mode 100644
index ec33f7943fa5..000000000000
--- a/team-rasa-contribution/buffered_tracker_store.py
+++ /dev/null
@@ -1,19 +0,0 @@
-class BufferedTrackerStore(TrackerStore): # example class
-    """A tracker store that buffers events and flushes them to the underlying store."""
-    def __init__(self, flush_interval=5): 
-        self._pending_events = [] # buffer for events
-        self.flush_interval = flush_interval # time interval to flush events
-
-    def update(self, event): 
-        self._pending_events.append(event) # add event to buffer
-        # Check if we need to flush
-        if len(self._pending_events) >= self.flush_interval:
-            # If the buffer is full, flush the events
-            self.flush()
-
-    def flush(self): 
-        if self._pending_events:
-            tracker.update_events(self._pending_events) # update the tracker with buffered events
-            # Clear the buffer after flushing
-            self._pending_events.clear()
-            super().update(tracker) # save the tracker to the underlying store
diff --git a/team-rasa-contribution/processor.py b/team-rasa-contribution/processor.py
deleted file mode 100644
index c9b7cd26e670..000000000000
--- a/team-rasa-contribution/processor.py
+++ /dev/null
@@ -1,22 +0,0 @@
-# Inside rasa/core/processor.py (method: handle_message)
-
-import time 
-import logging
-
-logger = logging.getLogger(__name__) 
-
-async def handle_message(self, message: UserMessage) -> Optional[List[Dict[Text, Any]]]: #handle_message method
-    """Process a message from a user and return the response messages."""
-    start_time = time.perf_counter() # Start the timer
-    
-    tracker = await self._get_tracker(message.sender_id) # Retrieve the tracker for the user
-
-    # existing processing steps (NLU, policy prediction, action execution)...
-    await self._run_action(tracker, ...) # Run the action based on the tracker state
-
-    end_time = time.perf_counter() # End the timer
-    duration = round(end_time - start_time, 3) # Calculate the duration
-    # Log the processing time
-    logger.info(f"[Runtime] Message '{message.text}' processed in {duration}s")
-
-    return output_channel.messages
diff --git a/team-rasa-contribution/test_buffered_tracker_store.py b/team-rasa-contribution/test_buffered_tracker_store.py
deleted file mode 100644
index 1ee0a79b145c..000000000000
--- a/team-rasa-contribution/test_buffered_tracker_store.py
+++ /dev/null
@@ -1,12 +0,0 @@
-def test_buffered_tracker_save():
-    store = BufferedTrackerStore(flush_interval=2) # example flush interval
-    tracker = DialogueStateTracker("user123", slots=[])  # example tracker
-    event1 = UserUttered("hi") # example event
-    event2 = SlotSet("pizza", "pepperoni") # example event
-
-    store.update(event1)
-    assert len(store._pending_events) == 1 # should be 1 after first update
-
-    store.update(event2)
-    # flush should trigger
-    assert len(store._pending_events) == 0  # should be cleared after flush

From ffcacced8468d29d41c677fa156ad15da576d3f0 Mon Sep 17 00:00:00 2001
From: Jongmin Lee <gigm2121@gmail.com>
Date: Wed, 14 May 2025 13:35:25 -0500
Subject: [PATCH 11/11] Delete .review-log-reviewed.md

---
 .review-log-reviewed.md | 1 -
 1 file changed, 1 deletion(-)
 delete mode 100644 .review-log-reviewed.md

diff --git a/.review-log-reviewed.md b/.review-log-reviewed.md
deleted file mode 100644
index 85552ed310aa..000000000000
--- a/.review-log-reviewed.md
+++ /dev/null
@@ -1 +0,0 @@
-Reviewed code refactors, and changes suggested in teh essays.