signalflow-trading 0.2.1__py3-none-any.whl

signalflow/strategy/broker/executor/binance_spot.py

@@ -0,0 +1,12 @@
+from signalflow.strategy.broker.executor.base import OrderExecutor
+from signalflow.core.decorators import sf_component
+from dataclasses import dataclass
+
+@dataclass
+@sf_component(name="binance/spot")
+
+class BinanceSpotExecutor(OrderExecutor):
+    """
+    Binance executor for live trading.
+    """
+    pass

signalflow/strategy/broker/executor/virtual_spot.py

@@ -0,0 +1,81 @@
+"""Virtual executor for backtesting - simulates order fills at current prices."""
+from __future__ import annotations
+from dataclasses import dataclass
+from datetime import datetime
+from typing import ClassVar
+import uuid
+
+from signalflow.core.enums import SfComponentType
+from signalflow.core.decorators import sf_component
+
+
+@dataclass
+@sf_component(name='virtual/spot', override=True)
+class VirtualSpotExecutor:
+    """
+    Simulates order execution for backtesting.
+    
+    Fills orders instantly at the provided price with configurable slippage.
+    """
+    component_type: ClassVar[SfComponentType] = SfComponentType.STRATEGY_EXECUTOR
+    
+    fee_rate: float = 0.001  
+    slippage_pct: float = 0.0  
+    
+    def execute(
+        self,
+        orders: list,  
+        prices: dict[str, float],
+        ts: datetime
+    ) -> list:  
+        """
+        Execute orders at current prices.
+        
+        Args:
+            orders: List of Order objects to execute
+            prices: Dict mapping pair -> current price
+            ts: Current timestamp
+            
+        Returns:
+            List of OrderFill objects
+        """
+        from signalflow.core.containers.order import Order, OrderFill
+        
+        fills: list[OrderFill] = []
+        
+        for order in orders:
+            if not isinstance(order, Order):
+                continue
+                
+            price = prices.get(order.pair)
+            if price is None or price <= 0:
+                continue
+            
+            if order.side == 'BUY':
+                fill_price = price * (1 + self.slippage_pct)
+            else:
+                fill_price = price * (1 - self.slippage_pct)
+            
+            notional = fill_price * order.qty
+            fee = notional * self.fee_rate
+            
+            fill = OrderFill(
+                id=str(uuid.uuid4()),
+                order_id=order.id,
+                pair=order.pair,
+                side=order.side,
+                ts=ts,
+                price=fill_price,
+                qty=order.qty,
+                fee=fee,
+                position_id=order.position_id,
+                meta={
+                    'order_meta': order.meta,
+                    'signal_strength': order.signal_strength,
+                }
+            )
+            fills.append(fill)
+            
+            order.status = 'FILLED'
+        
+        return fills

signalflow/strategy/broker/realtime_spot.py

@@ -0,0 +1,12 @@
+#TODO: Implement
+from signalflow.strategy.broker.base import Broker
+from signalflow.core.decorators import sf_component
+from dataclasses import dataclass
+
+@dataclass
+@sf_component(name="live/spot")
+class RealtimeSpotBroker(Broker):
+    """
+    Live broker for spot trading.
+    """
+    pass

signalflow/strategy/component/__init__.py

@@ -0,0 +1,9 @@
+from signalflow.strategy.component.base import StrategyMetric, ExitRule, EntryRule
+from signalflow.strategy.component.exit import TakeProfitStopLossExit
+
+__all__ = [
+    "StrategyMetric",
+    "ExitRule",
+    "EntryRule",
+    "TakeProfitStopLossExit",
+]

signalflow/strategy/component/base.py

@@ -0,0 +1,65 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import ClassVar
+from signalflow.core import SfComponentType, StrategyState, Position, Order, RawData, Signals
+
+
+@dataclass
+class StrategyMetric(ABC):
+    """Base class for strategy metrics."""
+    component_type: ClassVar[SfComponentType] = SfComponentType.STRATEGY_METRIC
+    
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Metric name for storage."""
+        ...
+    
+    @abstractmethod
+    def compute(
+        self,
+        state: StrategyState,
+        prices: dict[str, float]
+    ) -> dict[str, float]:
+        """Compute metric values."""
+        ...
+
+
+@dataclass
+class ExitRule(ABC):
+    """Base class for exit rules."""
+    component_type: ClassVar[SfComponentType] = SfComponentType.STRATEGY_EXIT_RULE
+    
+    @abstractmethod
+    def check_exits(
+        self,
+        positions: list[Position],
+        prices: dict[str, float],
+        state: StrategyState
+    ) -> list[Order]:
+        """
+        Check if any positions should be closed.
+        
+        Returns list of close orders.
+        """
+        ...
+
+
+@dataclass
+class EntryRule(ABC):
+    """Base class for entry rules."""
+    component_type: ClassVar[SfComponentType] = SfComponentType.STRATEGY_ENTRY_RULE
+    
+    @abstractmethod
+    def check_entries(
+        self,
+        signals: Signals,
+        prices: dict[str, float],
+        state: StrategyState
+    ) -> list[Order]:
+        """
+        Check signals and generate entry orders.
+        
+        Returns list of entry orders.
+        """
+        ...

signalflow/strategy/component/entry/__init__.py

@@ -0,0 +1,7 @@
+from signalflow.strategy.component.entry.signal import SignalEntryRule
+from signalflow.strategy.component.entry.fixed_size import FixedSizeEntryRule
+
+__all__ = [
+    "SignalEntryRule",
+    "FixedSizeEntryRule",
+]

signalflow/strategy/component/entry/fixed_size.py

@@ -0,0 +1,57 @@
+from dataclasses import dataclass, field
+from signalflow.core import Signals, Order, StrategyState, SignalType, sf_component
+from signalflow.strategy.component.base import EntryRule
+import polars as pl
+
+@dataclass
+@sf_component(name='fixed_size_entry')
+class FixedSizeEntryRule(EntryRule):
+    """Simple entry rule with fixed position size."""
+    
+    position_size: float = 0.01  
+    signal_types: list[str] = field(default_factory=lambda: [SignalType.RISE.value])
+    max_positions: int = 10  
+    
+    pair_col: str = 'pair'
+    
+    def check_entries(
+        self,
+        signals: Signals,
+        prices: dict[str, float],
+        state: StrategyState
+    ) -> list[Order]:
+        orders: list[Order] = []
+        
+        if signals is None or signals.value.height == 0:
+            return orders
+        
+        open_count = len(state.portfolio.open_positions())
+        if open_count >= self.max_positions:
+            return orders
+        
+        df = signals.value.filter(pl.col('signal_type').is_in(self.signal_types))
+        
+        for row in df.iter_rows(named=True):
+            if open_count >= self.max_positions:
+                break
+                
+            pair = row[self.pair_col]
+            signal_type = row['signal_type']
+            
+            price = prices.get(pair)
+            if price is None or price <= 0:
+                continue
+            
+            side = 'BUY' if signal_type == SignalType.RISE.value else 'SELL'
+            
+            order = Order(
+                pair=pair,
+                side=side,
+                order_type='MARKET',
+                qty=self.position_size,
+                meta={'signal_type': signal_type}
+            )
+            orders.append(order)
+            open_count += 1
+        
+        return orders

signalflow/strategy/component/entry/signal.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from signalflow.core import Signals, Order, StrategyState, SignalType, sf_component, Position
+from signalflow.strategy.component.base import EntryRule
+import polars as pl
+
+
+@dataclass
+@sf_component(name='signal', override=True)
+class SignalEntryRule(EntryRule):
+
+    base_position_size: float = 100.0
+    use_probability_sizing: bool = True
+    min_probability: float = 0.5
+    max_positions_per_pair: int = 1
+    max_total_positions: int = 20
+    allow_shorts: bool = False
+    max_capital_usage: float = 0.95 
+    min_order_notional: float = 10.0 
+    pair_col: str = 'pair'
+    ts_col: str = 'timestamp'
+
+    def check_entries(
+        self, 
+        signals: Signals, 
+        prices: dict[str, float], 
+        state: StrategyState
+    ) -> list[Order]:
+        orders: list[Order] = []
+        
+        if signals is None or signals.value.height == 0:
+            return orders
+        
+        positions_by_pair: dict[str, list[Position]] = {}
+        for pos in state.portfolio.open_positions():
+            positions_by_pair.setdefault(pos.pair, []).append(pos)
+        
+        total_open = len(state.portfolio.open_positions())
+        if total_open >= self.max_total_positions:
+            return orders
+        
+        available_cash = state.portfolio.cash
+        
+        used_capital = sum(
+            pos.entry_price * pos.qty 
+            for pos in state.portfolio.open_positions()
+        )
+        
+        total_equity = available_cash + used_capital
+        max_allowed_in_positions = total_equity * self.max_capital_usage
+        remaining_allocation = max_allowed_in_positions - used_capital
+        
+        df = signals.value
+        actionable_types = [SignalType.RISE.value]
+        if self.allow_shorts:
+            actionable_types.append(SignalType.FALL.value)
+        
+        df = df.filter(pl.col('signal_type').is_in(actionable_types))
+        
+        if 'probability' in df.columns:
+            df = df.filter(pl.col('probability') >= self.min_probability)
+            df = df.sort('probability', descending=True)
+        
+        for row in df.iter_rows(named=True):
+            if total_open >= self.max_total_positions:
+                break
+            
+            if remaining_allocation <= self.min_order_notional:
+                break
+            
+            if available_cash <= self.min_order_notional:
+                break
+            
+            pair = row[self.pair_col]
+            signal_type = row['signal_type']
+            probability = row.get('probability', 1.0) or 1.0
+            
+            existing_positions = positions_by_pair.get(pair, [])
+            if len(existing_positions) >= self.max_positions_per_pair:
+                continue
+            
+            price = prices.get(pair)
+            if price is None or price <= 0:
+                continue
+            
+            if signal_type == SignalType.RISE.value:
+                side = 'BUY'
+            elif signal_type == SignalType.FALL.value and self.allow_shorts:
+                side = 'SELL'
+            else:
+                continue
+            
+            notional = self.base_position_size
+            if self.use_probability_sizing:
+                notional *= probability
+            
+            notional = min(notional, available_cash * 0.99) 
+            notional = min(notional, remaining_allocation)
+            
+            if notional < self.min_order_notional:
+                continue
+            
+            qty = notional / price
+            
+            order = Order(
+                pair=pair,
+                side=side,
+                order_type='MARKET',
+                qty=qty,
+                signal_strength=probability,
+                meta={
+                    'signal_type': signal_type,
+                    'signal_probability': probability,
+                    'signal_ts': row.get(self.ts_col),
+                    'requested_notional': notional,
+                }
+            )
+            orders.append(order)
+            
+            total_open += 1
+            available_cash -= notional * 1.002  
+            remaining_allocation -= notional
+            positions_by_pair.setdefault(pair, []).append(None)  
+        
+        return orders
+

signalflow/strategy/component/exit/__init__.py

@@ -0,0 +1,5 @@
+from signalflow.strategy.component.exit.tp_sl import TakeProfitStopLossExit
+
+__all__ = [
+    "TakeProfitStopLossExit",
+]

signalflow/strategy/component/exit/time_based.py

@@ -0,0 +1,47 @@
+from dataclasses import dataclass
+from signalflow.core import Position, Order, StrategyState, PositionType, sf_component
+from signalflow.strategy.component.base import ExitRule
+
+@dataclass
+@sf_component(name='time_exit')
+class TimeBasedExit(ExitRule):
+    """Exit positions after a fixed holding period."""
+    
+    max_bars: int = 60  
+    bar_col: str = 'bar_count' 
+    
+    def check_exits(
+        self,
+        positions: list[Position],
+        prices: dict[str, float],
+        state: StrategyState
+    ) -> list[Order]:
+        orders: list[Order] = []
+        
+        for pos in positions:
+            if pos.is_closed:
+                continue
+                
+            price = prices.get(pos.pair)
+            if price is None:
+                continue
+            
+            bar_count = pos.meta.get(self.bar_col, 0) + 1
+            pos.meta[self.bar_col] = bar_count
+            
+            if bar_count >= self.max_bars:
+                side = 'SELL' if pos.position_type == PositionType.LONG else 'BUY'
+                order = Order(
+                    pair=pos.pair,
+                    side=side,
+                    order_type='MARKET',
+                    qty=pos.qty,
+                    position_id=pos.id,
+                    meta={
+                        'exit_reason': 'time_exit',
+                        'bars_held': bar_count,
+                    }
+                )
+                orders.append(order)
+        
+        return orders

signalflow/strategy/component/exit/tp_sl.py

@@ -0,0 +1,80 @@
+from dataclasses import dataclass
+from signalflow.core import Position, Order, StrategyState, PositionType, sf_component
+from signalflow.strategy.component.base import ExitRule
+
+
+@dataclass
+@sf_component(name='tp_sl', override=True)
+class TakeProfitStopLossExit(ExitRule):
+    """
+    Exit rule based on take-profit and stop-loss levels.
+    
+    Can use fixed percentages or dynamic levels from position meta.
+    """
+    
+    take_profit_pct: float = 0.02  
+    stop_loss_pct: float = 0.01  
+    use_position_levels: bool = False  
+    
+    def check_exits(
+        self,
+        positions: list[Position],
+        prices: dict[str, float],
+        state: StrategyState
+    ) -> list[Order]:
+        orders: list[Order] = []
+        
+        for pos in positions:
+            if pos.is_closed:
+                continue
+                
+            price = prices.get(pos.pair)
+            if price is None or price <= 0:
+                continue
+            
+            if self.use_position_levels:
+                tp_price = pos.meta.get('take_profit_price')
+                sl_price = pos.meta.get('stop_loss_price')
+            else:
+                if pos.position_type == PositionType.LONG:
+                    tp_price = pos.entry_price * (1 + self.take_profit_pct)
+                    sl_price = pos.entry_price * (1 - self.stop_loss_pct)
+                else: 
+                    tp_price = pos.entry_price * (1 - self.take_profit_pct)
+                    sl_price = pos.entry_price * (1 + self.stop_loss_pct)
+            
+            should_exit = False
+            exit_reason = ''
+            
+            if pos.position_type == PositionType.LONG:
+                if tp_price and price >= tp_price:
+                    should_exit = True
+                    exit_reason = 'take_profit'
+                elif sl_price and price <= sl_price:
+                    should_exit = True
+                    exit_reason = 'stop_loss'
+            else: 
+                if tp_price and price <= tp_price:
+                    should_exit = True
+                    exit_reason = 'take_profit'
+                elif sl_price and price >= sl_price:
+                    should_exit = True
+                    exit_reason = 'stop_loss'
+            
+            if should_exit:
+                side = 'SELL' if pos.position_type == PositionType.LONG else 'BUY'
+                order = Order(
+                    pair=pos.pair,
+                    side=side,
+                    order_type='MARKET',
+                    qty=pos.qty,
+                    position_id=pos.id,
+                    meta={
+                        'exit_reason': exit_reason,
+                        'entry_price': pos.entry_price,
+                        'exit_price': price,
+                    }
+                )
+                orders.append(order)
+        
+        return orders

signalflow/strategy/component/metric/__init__.py

@@ -0,0 +1,8 @@
+from signalflow.strategy.component.metric.main_metrics import TotalReturnMetric, BalanceAllocationMetric, DrawdownMetric, WinRateMetric, SharpeRatioMetric   
+__all__ = [
+    "TotalReturnMetric",
+    "BalanceAllocationMetric",
+    "DrawdownMetric",
+    "WinRateMetric",
+    "SharpeRatioMetric",
+]