onesecondtrader 0.14.1__tar.gz → 0.15.0__tar.gz

{onesecondtrader-0.14.1 → onesecondtrader-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onesecondtrader
-Version: 0.14.1
+Version: 0.15.0
 Summary: The Trading Infrastructure Toolkit for Python. Research, simulate, and deploy algorithmic trading strategies — all in one place.
 License-File: LICENSE
 Author: Nils P. Kujath

{onesecondtrader-0.14.1 → onesecondtrader-0.15.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "onesecondtrader"
-version = "0.14.1"
+version = "0.15.0"
 description = "The Trading Infrastructure Toolkit for Python. Research, simulate, and deploy algorithmic trading strategies — all in one place."
 authors = [
     {name = "Nils P. Kujath",email = "63961429+NilsKujath@users.noreply.github.com"}

{onesecondtrader-0.14.1 → onesecondtrader-0.15.0}/src/onesecondtrader/core/models.py

@@ -186,3 +186,19 @@ class StrategyShutdownMode(enum.Enum):
 
     SOFT = enum.auto()
     HARD = enum.auto()
+
+
+class SymbolShutdownMode(enum.Enum):
+    """
+    Enum for symbol shutdown modes.
+
+    **Attributes:**
+
+    | Enum | Value | Description |
+    |------|-------|-------------|
+    | `SOFT` | `enum.auto()` | Do not open new positions; wait until current positions close naturally |
+    | `HARD` | `enum.auto()` | Close all positions immediately with market orders |
+    """
+
+    SOFT = enum.auto()
+    HARD = enum.auto()

onesecondtrader-0.15.0/src/onesecondtrader/core/portfolio.py

@@ -0,0 +1,177 @@
+import threading
+
+from onesecondtrader import messaging
+from onesecondtrader.messaging import events
+from onesecondtrader.strategies import base_strategy
+from onesecondtrader.monitoring import console
+from onesecondtrader.core import models
+
+
+class Portfolio:
+    def __init__(self, event_bus: messaging.EventBus | None = None):
+        """
+        Initialize the Portfolio class and subscribe to events.
+        Most importantly, the `symbol_to_strategy` registry is initialized,
+         which keeps track of which symbols are currently assigned to which strategy
+         in order to enforce exclusive symbol ownership.
+
+        Args:
+            event_bus (messaging.EventBus | None): Event bus to use; defaults to
+                 messaging.system_event_bus when None.
+
+        Attributes:
+            self._lock (threading.Lock): Lock for thread-safe operations.
+            self.event_bus (messaging.EventBus): Event bus used for communication
+                 between the trading infrastructure's components.
+            self.symbols_to_strategy (dict[str, base_strategy.Strategy]): Registry of
+                 symbols to strategies.
+        """
+        # ------------------------------------------------------------------------------
+        # INITIALIZE LOCK FOR THREAD-SAFE OPERATIONS
+        self._lock: threading.Lock = threading.Lock()
+
+        # ------------------------------------------------------------------------------
+        # INITIALIZE EVENT BUS AND SUBSCRIBE TO EVENTS
+        self.event_bus: messaging.EventBus = (
+            event_bus if event_bus else messaging.system_event_bus
+        )
+        self.event_bus.subscribe(events.Strategy.SymbolRelease, self.on_symbol_release)
+
+        # ------------------------------------------------------------------------------
+        # INITIALIZE SYMBOLS TO STRATEGY REGISTRY
+        self.symbols_to_strategy: dict[str, base_strategy.Strategy] = {}
+
+    def on_symbol_release(self, event: messaging.events.Base.Event) -> None:
+        """
+        Event handler for symbol release events (`events.Strategy.SymbolRelease`).
+        The symbol is removed from the `symbols_to_strategy` registry.
+
+        Args:
+            event (messaging.events.Base.Event): Symbol release event.
+        """
+        # ------------------------------------------------------------------------------
+        # IGNORE UNRELATED EVENT TYPES
+        if not isinstance(event, events.Strategy.SymbolRelease):
+            return
+
+        # ------------------------------------------------------------------------------
+        # RELEASE SYMBOL FROM STRATEGY
+        symbol = event.symbol
+        with self._lock:
+            if symbol in self.symbols_to_strategy:
+                del self.symbols_to_strategy[symbol]
+                console.logger.info(
+                    f"on_symbol_release: symbol {symbol} released from "
+                    f"{getattr(event.strategy, 'name', type(event.strategy).__name__)}"
+                )
+            else:
+                console.logger.warning(
+                    f"on_symbol_release: symbol {symbol} not owned by "
+                    f"{getattr(event.strategy, 'name', type(event.strategy).__name__)}"
+                )
+
+    def assign_symbols(
+        self, strategy_instance: base_strategy.Strategy, symbols: list[str]
+    ) -> bool:
+        """
+        Assign a list of symbols to a strategy if no conflicts exist and notify the
+         strategy of the assignment.
+
+        Args:
+            strategy_instance (base_strategy.Strategy): Strategy instance to assign
+                symbols to.
+            symbols (list[str]): List of symbols to assign.
+        """
+        # ------------------------------------------------------------------------------
+        # VALIDATE THAT INSTANCE IS A SUBCLASS OF base_strategy.Strategy
+        if not isinstance(strategy_instance, base_strategy.Strategy):
+            console.logger.error("assign_symbols: strategy must inherit from Strategy")
+            return False
+
+        # ------------------------------------------------------------------------------
+        # CHECK FOR CONFLICTS
+        non_conflicting: list[str] = []
+        conflicting: list[str] = []
+        with self._lock:
+            for symbol in symbols:
+                owner = self.symbols_to_strategy.get(symbol)
+                if owner is None:
+                    non_conflicting.append(symbol)
+                else:
+                    conflicting.append(symbol)
+        if conflicting:
+            console.logger.warning(
+                "assign_symbols: symbols not assigned due to conflicts; "
+                "use Portfolio.assign_symbols(...) after resolving. "
+                f"non_conflicting={non_conflicting}, conflicts={conflicting}"
+            )
+            return False
+        else:
+            # --------------------------------------------------------------------------
+            # ASSIGN SYMBOLS TO REGISTRY
+            for symbol in symbols:
+                self.symbols_to_strategy[symbol] = strategy_instance
+
+            # --------------------------------------------------------------------------
+            # PUBLISH SYMBOL ASSIGNMENT EVENT
+            # noinspection PyArgumentList
+            self.event_bus.publish(
+                events.Strategy.SymbolAssignment(
+                    strategy=strategy_instance,
+                    symbol_list=symbols,
+                )
+            )
+            return True
+
+    def unassign_symbols(
+        self,
+        symbols: list[str],
+        shutdown_mode: models.SymbolShutdownMode = models.SymbolShutdownMode.SOFT,
+    ) -> bool:
+        """
+        Unassign a list of symbols from their owning strategy if all of them have
+         previously been assigned to a strategy.
+        Calling this methods will request the owning strategy to stop trading the symbol
+         in the manner dictated via the `shutdown_mode` argument (default to soft
+         shutdown, i.e. wait for open positions to close naturally and release symbols
+         once they are flat).
+        After the owning strategy has released the symbol, the symbol is unassigned from
+         the portfolio via the `on_symbol_release` event handler.
+
+        Args:
+            symbols (list[str]): List of symbols to unassign.
+            shutdown_mode (models.SymbolShutdownMode): Shutdown mode to use. Defaults
+                to `models.SymbolShutdownMode.SOFT`.
+        """
+        # ------------------------------------------------------------------------------
+        # CHECK THAT SYMBOLS ARE REGISTERED
+        conflicting: list[str] = []
+        with self._lock:
+            for symbol in symbols:
+                if symbol not in self.symbols_to_strategy:
+                    conflicting.append(symbol)
+            if conflicting:
+                console.logger.warning(
+                    "unassign_symbols: symbols not unassigned due to conflicts; "
+                    f"conflicts={conflicting}. "
+                    f"Use Portfolio.unassign_symbols(...) after resolving."
+                )
+                return False
+            else:
+                # ----------------------------------------------------------------------
+                # PUBLISH STOP TRADING SYMBOL EVENT FOR EACH SYMBOL
+                for symbol in symbols:
+                    # noinspection PyArgumentList
+                    self.event_bus.publish(
+                        events.Strategy.StopTradingSymbol(
+                            strategy=self.symbols_to_strategy[symbol],
+                            symbol=symbol,
+                            shutdown_mode=shutdown_mode,
+                        )
+                    )
+                    console.logger.info(
+                        f"unassign_symbols: trading stop for {symbol} trading strategy "
+                        f"{self.symbols_to_strategy[symbol]} requested with shutdown"
+                        f"mode {shutdown_mode.name}"
+                    )
+                return True

{onesecondtrader-0.14.1 → onesecondtrader-0.15.0}/src/onesecondtrader/messaging/events.py

@@ -86,13 +86,19 @@ Dataclass field validation logic is grouped under the `_Validate` namespace.
     style D1 fill:#6F42C1,fill-opacity:0.3
 
     E1[events.Strategy.SymbolRelease]
-    E2[events.Strategy.StopTrading]
+    E2[events.Strategy.SymbolAssignment]
+    E3[events.Strategy.StopTrading]
+    E4[events.Strategy.StopTradingSymbol]
 
     R5 --> E1
     R5 --> E2
+    R5 --> E3
+    R5 --> E4
 
     style E1 fill:#6F42C1,fill-opacity:0.3
     style E2 fill:#6F42C1,fill-opacity:0.3
+    style E3 fill:#6F42C1,fill-opacity:0.3
+    style E4 fill:#6F42C1,fill-opacity:0.3
 
     subgraph Market ["Market Update Event Messages"]
         R1
@@ -159,10 +165,14 @@ Dataclass field validation logic is grouped under the `_Validate` namespace.
         R5
         E1
         E2
+        E3
+        E4
 
         subgraph StrategyNamespace ["events.Strategy Namespace"]
             E1
             E2
+            E3
+            E4
         end
 
     end
@@ -237,7 +247,6 @@ class Base:
 
         def __post_init__(self) -> None:
             super().__post_init__()
-            _Validate.symbol(self.symbol, "Market event")
 
     @dataclasses.dataclass(kw_only=True, frozen=True)
     class Request(Event):
@@ -296,7 +305,6 @@ class Base:
 
         def __post_init__(self) -> None:
             super().__post_init__()
-            _Validate.symbol(self.symbol, f"Order {self.order_id}")
 
             _Validate.timezone_aware(
                 self.order_expiration, "order_expiration", f"Order {self.order_id}"
@@ -578,7 +586,6 @@ class Request:
 
         def __post_init__(self) -> None:
             super().__post_init__()
-            _Validate.symbol(self.symbol, "Flush request")
 
     @dataclasses.dataclass(kw_only=True, frozen=True)
     class FlushAll(Base.Request):
@@ -776,7 +783,27 @@ class Strategy:
 
         def __post_init__(self) -> None:
             super().__post_init__()
-            _Validate.symbol(self.symbol, "Strategy.SymbolRelease")
+
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class SymbolAssignment(Base.Strategy):
+        """
+        Event message to indicate that a symbol should be assigned to a strategy.
+
+        Attributes:
+            symbol_list (list[str]): List of symbols to be assigned.
+
+        Examples:
+            >>> from onesecondtrader.messaging import events
+            >>> event = events.Strategy.SymbolAssignment(
+            ...     strategy=my_strategy,
+            ...     symbol=["AAPL"],
+            ... )
+        """
+
+        symbol_list: list[str]
+
+        def __post_init__(self) -> None:
+            super().__post_init__()
 
     @dataclasses.dataclass(kw_only=True, frozen=True)
     class StopTrading(Base.Strategy):
@@ -785,6 +812,7 @@ class Strategy:
 
         Attributes:
             shutdown_mode (models.StrategyShutdownMode): Shutdown mode to use.
+                Defaults to `SOFT`.
 
         Examples:
             >>> from onesecondtrader.messaging import events
@@ -796,6 +824,32 @@ class Strategy:
 
         shutdown_mode: models.StrategyShutdownMode
 
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class StopTradingSymbol(Base.Strategy):
+        """
+        Event to indicate a strategy should stop trading a symbol.
+
+        Attributes:
+            symbol (str): Symbol to stop trading.
+            shutdown_mode (models.SymbolShutdownMode): Shutdown mode to use.
+                Defaults to `SOFT`.
+
+        Examples:
+            >>> from onesecondtrader.messaging import events
+            >>> event = events.Strategy.StopTradingSymbol(
+            ...     strategy=my_strategy,
+            ...     symbol="AAPL",
+            ...     shutdown_mode=models.SymbolShutdownMode.HARD,
+            ... )
+        """
+
+        symbol: str
+        shutdown_mode: models.SymbolShutdownMode = models.SymbolShutdownMode.SOFT
+
+        def __post_init__(self) -> None:
+            super().__post_init__()
+            _Validate.symbol(self.symbol, f"StopTradingSymbol {self.symbol}")
+
 
 class _Validate:
     """Internal validation utilities for events."""

onesecondtrader-0.14.1/src/onesecondtrader/core/portfolio.py

@@ -1,348 +0,0 @@
-"""
-This module provides the Portfolio class.
-"""
-
-import threading
-from collections.abc import Iterable
-from onesecondtrader import messaging
-from onesecondtrader.messaging import events
-from onesecondtrader.monitoring import console
-from onesecondtrader.brokers import base_broker
-from onesecondtrader.strategies import base_strategy
-from onesecondtrader.core.models import StrategyShutdownMode
-
-
-class Portfolio:
-    """
-    The Portfolio class orchestrates the trading infrastructure's components.
-    It manages the broker connection, market data reception, and strategy execution.
-
-    Multiple instances of the same Strategy class can be registered concurrently.
-    Symbol ownership is exclusive and enforced by the portfolio: each symbol may be
-    owned by at most one strategy instance at a time. Use `add_strategy()` with a list
-    of symbols or `assign_symbols(...)` with a specific strategy and a list of symbols
-    to claim symbols; `owner_of(symbol)` returns the current owner.
-    """
-
-    def __init__(
-        self,
-        event_bus: messaging.EventBus | None = None,
-        broker_class: type[base_broker.BaseBroker] | None = None,
-    ):
-        """
-        Initialize the Portfolio class, subscribe to events, and connect to the broker.
-
-        Args:
-            event_bus (EventBus | None): Event bus to use; defaults to
-                system_event_bus when None.
-            broker_class (type[base_broker.BaseBroker] | None): Broker class to
-                instantiate and connect. Must be a subclass of BaseBroker.
-
-        Attributes:
-            self.event_bus (eventbus.EventBus): Event bus used for communication between
-                the trading infrastructure's components.
-            self._lock (threading.Lock): Lock for thread-safe operations.
-            self._strategies (set[base_strategy.Strategy]): Registered strategy
-                instances.
-            self._symbol_owner (dict[str, base_strategy.Strategy]): Exclusive symbol
-                ownership map; each symbol is owned by at most one strategy instance at
-                a time.
-            self._removal_pending (set[base_strategy.Strategy]): Set of strategies that
-                are still active but marked for removal once all symbols are released.
-            self.broker (base_broker.BaseBroker | None): Instantiated broker; may be
-                disconnected if connect failed.
-        """
-        # INITIALIZE EVENT BUS
-        # ------------------------------------------------------------------------------
-        self.event_bus: messaging.EventBus = (
-            event_bus if event_bus else messaging.system_event_bus
-        )
-
-        # SUBSCRIBE HANDLER METHODS TO EVENTS VIA event_bus.subscribe
-        # ------------------------------------------------------------------------------
-        self.event_bus.subscribe(events.Strategy.SymbolRelease, self.on_symbol_release)
-
-        # INITIALIZE LOCK FOR THREAD-SAFE OPERATIONS WITHIN THE PORTFOLIO
-        # ------------------------------------------------------------------------------
-        self._lock = threading.Lock()
-
-        # KEEP TRACK OF STRATEGIES AND SYMBOL OWNERSHIP
-        # ------------------------------------------------------------------------------
-        self._strategies: set[base_strategy.Strategy] = set()
-        self._symbol_owner: dict[str, base_strategy.Strategy] = {}
-        self._removal_pending: set[base_strategy.Strategy] = set()
-
-        # INITIALIZE BROKER
-        # ------------------------------------------------------------------------------
-        self.broker: base_broker.BaseBroker | None = None
-        if broker_class is None or not issubclass(broker_class, base_broker.BaseBroker):
-            broker_name = (
-                getattr(broker_class, "__name__", str(broker_class))
-                if broker_class
-                else None
-            )
-            console.logger.error(
-                "Portfolio requires a valid broker_class (subclass of BaseBroker), "
-                f"got {broker_name}"
-            )
-            return
-        try:
-            self.broker = broker_class(self.event_bus)
-        except Exception as e:
-            console.logger.error(
-                f"Failed to instantiate broker "
-                f"{getattr(broker_class, '__name__', str(broker_class))}: {e}"
-            )
-            return
-
-        # CONNECT TO BROKER
-        # ------------------------------------------------------------------------------
-        try:
-            connected = self.broker.connect()
-            if not connected:
-                console.logger.error(
-                    f"Failed to connect broker {type(self.broker).__name__}"
-                )
-        except Exception as e:
-            console.logger.error(f"Broker connect failed: {e}")
-
-    def add_strategy(
-        self,
-        strategy_instance: base_strategy.Strategy,
-        symbols: Iterable[str] | None = None,
-    ) -> bool:
-        """
-        Register a Strategy instance and optionally assign a list of symbols to it.
-
-        If symbols are provided, potential conflicts are checked first under a lock.
-        If any conflicts exist, no symbols are assigned; a warning is logged listing
-        both non_conflicting and conflicting symbols and instructions to use
-        assign_symbols(...) are provided.
-        If no conflicts exist, all provided symbols are claimed by the strategy.
-
-        Args:
-            strategy_instance (base_strategy.Strategy): Strategy instance to register.
-            symbols (Iterable[str] | None): Optional list of symbols to assign to the
-                strategy.
-
-        Returns:
-            bool: True if the strategy was registered, False otherwise.
-        """
-        # VALIDATE THAT INSTANCE IS A SUBCLASS OF base_strategy.Strategy
-        # ------------------------------------------------------------------------------
-        if not isinstance(strategy_instance, base_strategy.Strategy):
-            console.logger.error("add_strategy: strategy must inherit from Strategy")
-            return False
-
-        # ADD STRATEGY INSTANCE TO REGISTRY IF NOT ALREADY REGISTERED
-        # ------------------------------------------------------------------------------
-        with self._lock:
-            if strategy_instance in self._strategies:
-                console.logger.warning("add_strategy: strategy already registered")
-                return False
-            self._strategies.add(strategy_instance)
-
-        # ASSIGN SYMBOLS IF PROVIDED AND NO CONFLICTS EXIST, ELSE LOG WARNING
-        # ------------------------------------------------------------------------------
-        if symbols is not None:
-            # Create an ordered list of unique, non-empty, trimmed symbols
-            symbols_list = list(
-                dict.fromkeys(s.strip() for s in symbols if s and s.strip())
-            )
-
-            # Check for conflicts, claim symbols for strategy if no conflicts arise
-            if symbols_list:
-                non_conflicting: list[str] = []
-                conflicting: list[str] = []
-                with self._lock:
-                    for sym in symbols_list:
-                        owner = self._symbol_owner.get(sym)
-                        if owner is None or owner is strategy_instance:
-                            non_conflicting.append(sym)
-                        else:
-                            conflicting.append(sym)
-                if conflicting:
-                    console.logger.warning(
-                        "add_strategy: symbols not assigned due to conflicts; "
-                        "use Portfolio.assign_symbols(...) after resolving. "
-                        f"non_conflicting={non_conflicting}, conflicts={conflicting}"
-                    )
-                else:
-                    self.assign_symbols(strategy_instance, symbols_list)
-        return True
-
-    def remove_strategy(
-        self,
-        strategy: base_strategy.Strategy,
-        shutdown_mode: StrategyShutdownMode = StrategyShutdownMode.SOFT,
-    ) -> bool:
-        """
-        Mark a strategy for removal and request it to close its positions in the manner
-        dictated via the `shutdown_mode` argument (default to soft shutdown, i.e. wait
-        for open positions to close naturally and release symbols once they are flat).
-
-        Args:
-            strategy (base_strategy.Strategy): Strategy instance to remove.
-            shutdown_mode (StrategyShutdownMode): Shutdown mode to use. Defaults to
-                StrategyShutdownMode.SOFT.
-        """
-
-        # IF STRATEGY IS REGISTERED, MARK IT FOR REMOVAL
-        # ------------------------------------------------------------------------------
-        with self._lock:
-            if strategy not in self._strategies:
-                console.logger.warning("remove_strategy: strategy not registered")
-                return False
-            self._removal_pending.add(strategy)
-
-        try:
-            strategy.request_close(shutdown_mode)
-        except Exception:
-            console.logger.warning(
-                "remove_strategy: strategy does not support request_close; proceeding to flatness check"
-            )
-
-        try:
-            if bool(strategy.is_flat()):
-                # If the strategy is already flat and owns no symbols, deregister now
-                with self._lock:
-                    has_owned_left = any(
-                        owner is strategy for owner in self._symbol_owner.values()
-                    )
-                    if not has_owned_left:
-                        if strategy in self._strategies:
-                            self._strategies.remove(strategy)
-                        self._removal_pending.discard(strategy)
-                        console.logger.info(
-                            f"Strategy {getattr(strategy, 'name', type(strategy).__name__)} removed: flat and no symbols owned"
-                        )
-                        return True
-        except Exception:
-            console.logger.warning(
-                "remove_strategy: strategy does not implement is_flat; will wait for symbol releases"
-            )
-        return False
-
-    def assign_symbols(
-        self,
-        strategy: base_strategy.Strategy,
-        symbols: Iterable[str],
-    ) -> tuple[list[str], list[str]]:
-        """
-        Assign symbols to a strategy with exclusivity enforcement.
-
-        Returns:
-            tuple[list[str], list[str]]: (accepted, conflicts)
-        """
-        if not isinstance(strategy, base_strategy.Strategy):
-            console.logger.error("assign_symbols: strategy must inherit from Strategy")
-            return [], list(symbols)
-        symbols_list = list(
-            dict.fromkeys(s.strip() for s in symbols if s and s.strip())
-        )
-        if not symbols_list:
-            return [], []
-        accepted: list[str] = []
-        conflicts: list[str] = []
-        with self._lock:
-            for sym in symbols_list:
-                current = self._symbol_owner.get(sym)
-                if current is None or current is strategy:
-                    self._symbol_owner[sym] = strategy
-                    accepted.append(sym)
-                else:
-                    conflicts.append(sym)
-        if accepted:
-            strategy.add_symbols(accepted)
-        if conflicts:
-            console.logger.warning(
-                f"assign_symbols: conflicts for {len(conflicts)} symbol(s): {conflicts}"
-            )
-        return accepted, conflicts
-
-    def unassign_symbols(
-        self, strategy: base_strategy.Strategy, symbols: Iterable[str]
-    ) -> list[str]:
-        """
-        Release symbol ownership from a strategy.
-
-        Returns:
-            list[str]: Symbols actually unassigned.
-        """
-        if not isinstance(strategy, base_strategy.Strategy):
-            console.logger.error(
-                "unassign_symbols: strategy must inherit from Strategy"
-            )
-            return []
-        symbols_list = list(
-            dict.fromkeys(s.strip() for s in symbols if s and s.strip())
-        )
-        if not symbols_list:
-            return []
-        removed: list[str] = []
-        with self._lock:
-            for sym in symbols_list:
-                if self._symbol_owner.get(sym) is strategy:
-                    del self._symbol_owner[sym]
-                    removed.append(sym)
-        if removed:
-            strategy.remove_symbols(removed)
-        return removed
-
-    def owner_of(self, symbol: str) -> base_strategy.Strategy | None:
-        """
-        Return the owning strategy for a symbol or None if unowned.
-        """
-        with self._lock:
-            return self._symbol_owner.get(symbol)
-
-    def release_symbols_from_strategy(
-        self, strategy: base_strategy.Strategy, symbols: Iterable[str]
-    ) -> list[str]:
-        """
-        Release symbols from the given strategy.
-
-        If the strategy was previously marked for removal and ends up with no owned
-        symbols after this call, and the strategy is flat, it will be automatically
-        deregistered.
-        """
-        removed = self.unassign_symbols(strategy, symbols)
-        if not removed:
-            return removed
-        # Auto-deregister if pending removal and no more owned symbols
-        pending = False
-        with self._lock:
-            pending = strategy in self._removal_pending
-            has_owned_left = any(
-                owner is strategy for owner in self._symbol_owner.values()
-            )
-        if pending and not has_owned_left:
-            try:
-                if bool(strategy.is_flat()):
-                    with self._lock:
-                        if strategy in self._strategies:
-                            self._strategies.remove(strategy)
-                        self._removal_pending.discard(strategy)
-                    console.logger.info(
-                        f"Strategy {getattr(strategy, 'name', type(strategy).__name__)} removed: all symbols released and flat"
-                    )
-            except Exception:
-                pass
-        return removed
-
-    def on_symbol_release(self, event: events.Base.Event) -> None:
-        """
-        Handle symbol release events. Ignores unrelated event types.
-        """
-        if not isinstance(event, events.Strategy.SymbolRelease):
-            return
-        strategy = event.strategy
-        with self._lock:
-            if strategy not in self._strategies:
-                console.logger.warning("on_symbol_release: strategy not registered")
-                return
-        removed = self.release_symbols_from_strategy(strategy, [event.symbol])
-        if not removed:
-            console.logger.warning(
-                f"on_symbol_release: symbol {event.symbol} not owned by {getattr(event.strategy, 'name', type(event.strategy).__name__)}"
-            )