cleanup

Author: hyeongsam.kim

CHANGELOG.md

@@ -4,7 +4,41 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.2.0] - 2024-03-19
+## [0.3.0] - 2024-12-19
+
+### Changed
+- Removed `initialize` and `finalize` methods from the worker thread.
+
+### Added
+- Added the following examples:
+  - `signal_function_slots.py` for demonstrating signal/slot connection with a regular function
+  - `signal_lambda_slots.py` for demonstrating signal/slot connection with a lambda function
+  - `stock_core.py` for demonstrating how to configure and communicate with a threaded backend using signal/slot and event queue
+  - `stock_monitor_console.py` for demonstrating how to configure and communicate with a threaded backend in a command line interface
+  - `stock_monitor_ui.py` for demonstrating how to configure and communicate with a threaded backend in a GUI.
+
+### Fixed
+- Fixed issues with regular function and lambda function connections.
+- Fixed issues with the worker thread's event queue and graceful shutdown.
+
+### Note
+Next steps before 1.0.0:
+- Strengthening Stability
+  - Resource Cleanup Mechanism/Weak Reference Support:
+    - Consider supporting weak references (weakref) that automatically release signal/slot connections when the object is GC'd.
+  - Handling Slot Return Values in Async/Await Flow:
+    - A mechanism may be needed to handle the values or exceptions returned by async slots.
+      Example: If a slot call fails, the emit side can detect and return a callback or future.
+  - Strengthening Type Hint-Based Verification:
+    - The functionality of comparing the slot signature and the type of the passed argument when emitting can be further extended.
+      - Read the type hint for the slot function, and if the number or type of the arguments does not match when emitting, raise a warning or exception.
+- Consider Additional Features
+  - One-shot or Limited Connection Functionality:
+      A "one-shot" slot feature that listens to a specific event only once and then disconnects can be provided.
+        Example: Add the connect_one_shot method.
+        Once the event is received, it will automatically disconnect.
+
+## [0.2.0] - 2024-12-6
 
 ### Changed
 - Updated minimum Python version requirement to 3.10

docs/example.md renamed to docs/examples.md

@@ -23,6 +23,8 @@
 
 @t_with_signals
 class Counter:
+    """A simple counter class that emits a signal when its count changes."""
+
     def __init__(self):
         self.count = 0
 
@@ -31,24 +33,31 @@ def count_changed(self):
         """Emitted when the count changes."""
 
     def increment(self):
+        """Increment the counter and emit the signal."""
+
         self.count += 1
         print(f"Counter incremented to: {self.count}")
         self.count_changed.emit(self.count)
 
 
 def print_value(value):
     """A standalone function acting as a slot."""
+
     print(f"Function Slot received value: {value}")
 
 
 async def main():
+    """Main function to run the signal-function slots example."""
+
     counter = Counter()
     # Connect the signal to the standalone function slot
     counter.count_changed.connect(print_value)
 
     print("Press Enter to increment counter, or 'q' to quit.")
+
     while True:
         line = input("> ")
+
         if line.lower() == "q":
             break
         counter.increment()

examples/signal_function_slots.py

@@ -22,6 +22,8 @@
 
 @t_with_signals
 class Counter:
+    """A simple counter class that emits a signal when its count changes."""
+
     def __init__(self):
         self.count = 0
 
@@ -30,19 +32,25 @@ def count_changed(self):
         """Emitted when the count changes."""
 
     def increment(self):
+        """Increment the counter and emit the signal."""
+
         self.count += 1
         print(f"Counter incremented to: {self.count}")
         self.count_changed.emit(self.count)
 
 
 async def main():
+    """Main function to run the signal-lambda slots example."""
+
     counter = Counter()
     # Connect the signal to a lambda slot
     counter.count_changed.connect(lambda v: print(f"Lambda Slot received: {v}"))
 
     print("Press Enter to increment counter, or 'q' to quit.")
+
     while True:
         line = input("> ")
+
         if line.lower() == "q":
             break
         counter.increment()

examples/signal_lamba_slots.py

@@ -41,18 +41,18 @@ def __init__(self):
 
         self.prices: Dict[str, float] = {
             "AAPL": 180.0,  # Apple Inc.
-            # "GOOGL": 140.0,  # Alphabet Inc.
-            # "MSFT": 370.0,  # Microsoft Corporation
-            # "AMZN": 145.0,  # Amazon.com Inc.
-            # "TSLA": 240.0,  # Tesla Inc.
+            "GOOGL": 140.0,  # Alphabet Inc.
+            "MSFT": 370.0,  # Microsoft Corporation
+            "AMZN": 145.0,  # Amazon.com Inc.
+            "TSLA": 240.0,  # Tesla Inc.
         }
         self._desc_lock = threading.RLock()
         self._descriptions = {
             "AAPL": "Apple Inc.",
-            # "GOOGL": "Alphabet Inc.",
-            # "MSFT": "Microsoft Corporation",
-            # "AMZN": "Amazon.com Inc.",
-            # "TSLA": "Tesla Inc.",
+            "GOOGL": "Alphabet Inc.",
+            "MSFT": "Microsoft Corporation",
+            "AMZN": "Amazon.com Inc.",
+            "TSLA": "Tesla Inc.",
         }
         self.last_prices = self.prices.copy()
         self._running = False
@@ -83,8 +83,10 @@ async def on_stopped(self):
 
         logger.info("[StockService][on_stopped] stopped")
         self._running = False
+
         if hasattr(self, "_update_task"):
             self._update_task.cancel()
+
             try:
                 await self._update_task
             except asyncio.CancelledError:
@@ -104,6 +106,7 @@ async def update_prices(self):
                     change=((self.prices[code] / self.last_prices[code]) - 1) * 100,
                     timestamp=time.time(),
                 )
+
                 logger.debug(
                     "[StockService][update_prices] price_data: %s",
                     price_data,
@@ -148,13 +151,15 @@ def remove_alert(self):
     @t_slot
     def on_price_processed(self, price_data: StockPrice):
         """Receive processed stock price data from StockProcessor"""
+
         logger.debug("[StockViewModel][on_price_processed] price_data: %s", price_data)
         self.current_prices[price_data.code] = price_data
         self.prices_updated.emit(dict(self.current_prices))
 
     @t_slot
     def on_alert_triggered(self, code: str, alert_type: str, price: float):
         """Receive alert trigger from StockProcessor"""
+
         self.alerts.append((code, alert_type, price))
         self.alert_added.emit(code, alert_type, price)
 
@@ -163,6 +168,7 @@ def on_alert_settings_changed(
         self, code: str, lower: Optional[float], upper: Optional[float]
     ):
         """Receive alert settings change notification from StockProcessor"""
+
         if lower is None and upper is None:
             self.alert_settings.pop(code, None)
         else:
@@ -209,19 +215,22 @@ async def on_set_price_alert(
         self, code: str, lower: Optional[float], upper: Optional[float]
     ):
         """Receive price alert setting request from main thread"""
+
         self.price_alerts[code] = (lower, upper)
         self.alert_settings_changed.emit(code, lower, upper)
 
     @t_slot
     async def on_remove_price_alert(self, code: str):
         """Receive price alert removal request from main thread"""
+
         if code in self.price_alerts:
             del self.price_alerts[code]
             self.alert_settings_changed.emit(code, None, None)
 
     @t_slot
     async def on_price_updated(self, price_data: StockPrice):
         """Receive stock price update from StockService"""
+
         logger.debug("[StockProcessor][on_price_updated] price_data: %s", price_data)
 
         try:
@@ -232,17 +241,22 @@ async def on_price_updated(self, price_data: StockPrice):
 
     async def process_price(self, price_data: StockPrice):
         """Process stock price data"""
+
         logger.debug("[StockProcessor][process_price] price_data: %s", price_data)
+
         try:
             if price_data.code in self.price_alerts:
                 logger.debug(
                     "[process_price] Process price event loop: %s",
                     asyncio.get_running_loop(),
                 )
+
             if price_data.code in self.price_alerts:
                 lower, upper = self.price_alerts[price_data.code]
+
                 if lower and price_data.price <= lower:
                     self.alert_triggered.emit(price_data.code, "LOW", price_data.price)
+
                 if upper and price_data.price >= upper:
                     self.alert_triggered.emit(price_data.code, "HIGH", price_data.price)
 

examples/stock_core.py

@@ -68,25 +68,30 @@ def on_prices_updated(self, prices: Dict[str, StockPrice]):
             print("\n(Press Enter to return to menu)")
 
             alerts = []
+
             for code, data in prices.items():
                 if code in self.view_model.alert_settings:
                     lower, upper = self.view_model.alert_settings[code]
+
                     if lower and data.price <= lower:
                         alerts.append(
                             f"{code} price (${data.price:.2f}) below ${lower:.2f}"
                         )
+
                     if upper and data.price >= upper:
                         alerts.append(
                             f"{code} price (${data.price:.2f}) above ${upper:.2f}"
                         )
 
             if alerts:
                 print("\nAlerts:")
+
                 for alert in alerts:
                     print(alert)
 
     async def process_command(self, command: str):
         """Process command"""
+
         parts = command.strip().split()
 
         if not parts:
@@ -123,6 +128,7 @@ async def process_command(self, command: str):
 
         elif parts[0] == "remove" and len(parts) == 2:
             code = parts[1].upper()
+
             if code in self.view_model.alert_settings:
                 self.view_model.remove_alert.emit(code)
                 print(f"Alert removed for {code}")
@@ -140,6 +146,7 @@ async def process_command(self, command: str):
 
     async def run(self):
         """CLI execution"""
+
         logger.debug(
             "[StockMonitorCLI][run] started current loop: %s %s",
             id(asyncio.get_running_loop()),
@@ -152,11 +159,15 @@ async def run(self):
 
         # Connect service.start to processor's started signal
         def on_processor_started():
+            """Processor started"""
+
             logger.debug("[StockMonitorCLI][run] processor started, starting service")
             self.service.start()
 
             # Set processor_started future to True in the main loop
             def set_processor_started_true():
+                """Set processor started"""
+
                 logger.debug(
                     "[StockMonitorCLI][run] set_processor_started_true current loop: %s %s",
                     id(asyncio.get_running_loop()),

examples/stock_monitor_console.py

@@ -41,8 +41,10 @@ async def run(self, *args, **kwargs):
         await self._tsignal_stopping.wait()
         # Clean up
         self._running = False
+
         if self._update_task:
             self._update_task.cancel()
+
             try:
                 await self._update_task
             except asyncio.CancelledError:
@@ -52,10 +54,13 @@ async def update_loop(self):
         """Update loop"""
 
         count = 0
+
         while self._running:
             logger.debug("[Worker] Processing data %d", count)
             self.data_processed.emit(count)
+
             count += 1
+
             await asyncio.sleep(1)
 
 

examples/stock_monitor_simple.py

@@ -106,6 +106,7 @@ def update_prices(self, prices: Dict[str, StockPrice]):
     @t_slot
     def on_alert_added(self, code: str, alert_type: str, price: float):
         """Update UI when alert is triggered"""
+
         self.alert_label.text = f"ALERT: {code} {alert_type} {price:.2f}"
 
 
@@ -201,6 +202,7 @@ def _remove_alert(self, instance):
         """Alert removal button handler"""
 
         code = self.view.stock_spinner.text
+
         if not code:
             self.view.alert_label.text = "No stock selected"
             return
@@ -230,6 +232,7 @@ async def cleanup(self):
         for task in self.tasks:
             if not task.done():
                 task.cancel()
+
                 try:
                     await task
                 except asyncio.CancelledError:
@@ -240,6 +243,7 @@ async def async_run(self, async_lib=None):
         """Async run"""
 
         self._async_lib = async_lib or asyncio
+
         return await self._async_lib.gather(
             self._async_lib.create_task(super().async_run(async_lib=async_lib))
         )
@@ -262,6 +266,7 @@ async def main():
         for task in app.tasks:
             if not task.done():
                 task.cancel()
+
                 try:
                     await task
                 except asyncio.CancelledError:

examples/stock_monitor_ui.py

@@ -33,19 +33,14 @@ def t_with_worker(cls):
     class WorkerClass(cls):
         """
         Worker class for the worker pattern.
-
-        _worker_lock:
-            A re-entrant lock that protects access to both the event loop (`_tsignal_loop`)
-            and the worker thread (`_tsignal_thread`). All operations that set or get
-            `_tsignal_loop` or `_tsignal_thread` must be done within `with self._worker_lock:`.
         """
 
         def __init__(self):
             self._tsignal_loop = None
             self._tsignal_thread = None
 
             """
-            _lifecycle_lock:
+            _tsignal_lifecycle_lock:
                 A re-entrant lock that protects worker's lifecycle state (event loop and thread).
                 All operations that access or modify worker's lifecycle state must be
                 performed while holding this lock.