trdr 0.0.1__py2.py3-none-any.whl

trdr/conftest.py

@@ -0,0 +1,148 @@
+import asyncio
+import pytest
+import yfinance as yf
+import random
+import datetime
+
+from .core.security_provider.security_provider import SecurityProvider
+from .core.bar_provider.yf_bar_provider.yf_bar_provider import YFBarProvider
+from .test_utils.fake_yf_download import fake_yf_download
+from .test_utils.security_generator import SecurityGenerator, SecurityCriteria
+from .test_utils.position_generator import PositionGenerator, PositionCriteria
+from .test_utils.order_generator import OrderGenerator, OrderCriteria
+from .core.broker.mock_broker.mock_broker import MockBroker
+from .core.broker.pdt.nun_strategy import NunStrategy
+from .core.broker.pdt.wiggle_strategy import WiggleStrategy
+from .core.broker.pdt.yolo_strategy import YoloStrategy
+from .core.trading_context.trading_context import TradingContext
+from .core.shared.models import TradingDateTime
+
+
+@pytest.fixture(scope="function")
+def weekday_trading_datetime():
+    trading_now = TradingDateTime.now()
+    while trading_now.is_weekend:
+        trading_now = trading_now + datetime.timedelta(days=1)
+    return trading_now
+
+
+@pytest.fixture(scope="function")
+def weekend_trading_datetime():
+    trading_now = TradingDateTime.now()
+    while not trading_now.is_weekend:
+        trading_now = trading_now + datetime.timedelta(days=1)
+    return trading_now
+
+
+@pytest.fixture(scope="function")
+def yf_bar_provider_with_fake_data(monkeypatch):
+    monkeypatch.setattr(yf, "download", fake_yf_download)
+    monkeypatch.setattr(yf.shared, "_ERRORS", {"ABCDEFG": "YFTzMissingError()", "AMZN": "JSONDecodeError()"})
+    return asyncio.run(YFBarProvider.create(["AAPL", "MSFT", "ABCDEFG", "AMZN"]))
+
+
+@pytest.fixture(scope="function")
+def security_provider_with_fake_data(yf_bar_provider_with_fake_data):
+    return asyncio.run(SecurityProvider.create(yf_bar_provider_with_fake_data))
+
+
+@pytest.fixture(scope="function")
+def random_security(symbol="AAPL", bar_count=200):
+    """Create a random security with the given symbol and bar count.
+
+    Args:
+        symbol: The ticker symbol to use
+        count: The number of bars to generate
+
+    Returns:
+        A Security instance with randomly generated price and volume data
+    """
+    generator = SecurityGenerator(SecurityCriteria(bar_count=bar_count))
+    security = generator.find_suitable_security()
+    # Override the symbol if requested
+    if symbol != security.symbol:
+        security.symbol = symbol
+    return security
+
+
+@pytest.fixture(scope="function")
+def get_random_security():
+    """Legacy fixture name for backward compatibility."""
+    generator = SecurityGenerator(SecurityCriteria(bar_count=200))
+    return generator.find_suitable_security()
+
+
+@pytest.fixture(scope="module")
+def security_generator():
+    """Return a configured SecurityGenerator instance."""
+    return SecurityGenerator(SecurityCriteria(bar_count=200))
+
+
+@pytest.fixture(scope="function")
+def short_dummy_position():
+    """Create a test position with default values."""
+    position = PositionGenerator(criteria=PositionCriteria(bar_count=1, net_position_bias=0)).generate_positions()[0]
+    return position
+
+
+@pytest.fixture(scope="function")
+def long_dummy_position():
+    """Create a test position with default values."""
+    position = PositionGenerator(criteria=PositionCriteria(bar_count=1, net_position_bias=1)).generate_positions()[0]
+    return position
+
+
+@pytest.fixture(scope="function")
+def dummy_positions():
+    """Create a dictionary of test positions."""
+    num_positions = random.randint(1, 9)
+    positions = PositionGenerator(
+        criteria=PositionCriteria(bar_count=num_positions, net_position_bias=0.5)
+    ).generate_positions()
+    return positions
+
+
+@pytest.fixture(scope="function")
+def mock_broker_with_nun_strategy():
+    nun_strategy = NunStrategy.create()
+    broker = asyncio.run(MockBroker.create(pdt_strategy=nun_strategy))
+    yield broker
+    asyncio.run(broker._session.close())
+
+
+@pytest.fixture(scope="function")
+def mock_broker_with_wiggle_strategy():
+    pdt_strategy = WiggleStrategy.create()
+    pdt_strategy.wiggle_room = 2
+    broker = asyncio.run(MockBroker.create(pdt_strategy=pdt_strategy))
+    yield broker
+    asyncio.run(broker._session.close())
+
+
+@pytest.fixture(scope="function")
+def mock_broker_with_yolo_strategy():
+    pdt_strategy = YoloStrategy.create()
+    broker = asyncio.run(MockBroker.create(pdt_strategy=pdt_strategy))
+    yield broker
+    asyncio.run(broker._session.close())
+
+
+@pytest.fixture(scope="function")
+def mock_trading_context(security_provider_with_fake_data, mock_broker_with_nun_strategy):
+    return asyncio.run(TradingContext.create(security_provider_with_fake_data, mock_broker_with_nun_strategy))
+
+
+@pytest.fixture(scope="function")
+def create_order():
+
+    def _create_order(symbol: str, side=None):
+        return OrderGenerator(criteria=OrderCriteria(count=1, symbol=symbol, side=side)).generate_orders()[0]
+
+    return _create_order
+
+
+@pytest.fixture(scope="function")
+def prepared_trading_context(mock_trading_context: TradingContext):
+    """Prepare trading context with a valid symbol and security."""
+    asyncio.run(mock_trading_context.next_symbol())
+    return mock_trading_context

trdr/core/bar_provider/base_bar_provider.py

@@ -0,0 +1,115 @@
+from typing import List, Type, Optional, TypeVar
+from abc import ABC, abstractmethod
+from opentelemetry import trace
+
+from .models import Bar
+
+T = TypeVar("T", bound="BaseBarProvider")
+
+
+class BaseBarProvider(ABC):
+    """
+    Abstract base class for retrieving and managing OHLCV bar data for securities.
+
+    This class defines the interface that all bar providers must implement, setting
+    a standardized way to retrieve historical and current price data. Bar providers
+    serve as the data foundation for trading strategies.
+
+    All implementations should maintain a data cache for efficient data retrieval
+    and support OpenTelemetry instrumentation for monitoring and tracing.
+
+    Attributes:
+        _data_cache: Internal cache for storing retrieved bar data
+        _tracer: OpenTelemetry tracer for instrumenting operations
+    """
+
+    def __init__(
+        self,
+        tracer: trace.Tracer,
+    ):
+        self._data_cache = {}
+        self._tracer = tracer
+
+    @classmethod
+    async def create(cls: Type[T], symbols: List[str], tracer: Optional[trace.Tracer] = trace.NoOpTracer()) -> T:
+        """
+        Factory method to create and initialize a bar provider instance.
+
+        This async factory method pattern ensures proper initialization of resources
+        and error handling during the creation process. It invokes the implementation-specific
+        _initialize method which must be defined by concrete subclasses.
+
+        Args:
+            symbols: List of ticker symbols to initialize the provider with
+            tracer: OpenTelemetry tracer for instrumenting operations
+
+        Returns:
+            An initialized instance of the concrete bar provider
+
+        Raises:
+            Various exceptions depending on the implementation, typically related to
+            data availability or connectivity issues
+        """
+        self = cls.__new__(cls)
+        BaseBarProvider.__init__(self, tracer)
+        with self._tracer.start_as_current_span("BaseBarProvider.create") as span:
+            try:
+                await self._initialize(symbols)
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(trace.StatusCode.ERROR)
+                raise
+            else:
+                span.set_status(trace.StatusCode.OK)
+        return self
+
+    @abstractmethod
+    async def _initialize(self, symbols: List[str]) -> None:
+        """
+        This abstract method MUST be implemented by user defined data providers.
+        - This method SHOULD use the symbols argument to initialize the data cache.
+        - After the method has completed, the self._data_cache dictionary MUST be a dictionary where the keys are the symbols and the values are lists of Bars.
+        - The self._data_cache dictionary must only contain key,value pairs for symbols that have data available.
+        """
+        raise NotImplementedError("This method must be implemented by user defined data providers")
+
+    @abstractmethod
+    async def get_symbols(self) -> List[str]:
+        """
+        Get the list of symbols with data available.
+
+        Returns:
+            List[str]: List of symbols.
+        """
+        pass
+
+    @abstractmethod
+    async def get_bars(self, symbol: str, lookback: Optional[int] = None) -> List[Bar]:
+        """Get bars for a specific symbol.
+
+        Args:
+            symbol: The ticker symbol to get bars for
+            lookback: The number of bars to return
+
+        Raises:
+            NoBarsForSymbolException: If the symbol is not found in the data cache
+            InsufficientBarsException: If the number of bars requested is greater than the number of bars available
+        """
+        raise NotImplementedError("This method must be implemented by user defined data providers")
+
+    @abstractmethod
+    async def get_current_bar(self, symbol: str) -> Bar:
+        """
+        Get the current bar for a symbol.
+
+        Args:
+            symbol (str): The symbol to get the current bar for.
+
+        Returns:
+            Bar: The current bar for the symbol.
+
+        Raises:
+            BarProviderException: If we receive an error not associated with the symbol of interest or if we receive an error not related to a no data error.
+            NoBarsForSymbolException: If we didn't receive any data for the symbol of interest.
+        """
+        pass

trdr/core/bar_provider/exceptions.py

@@ -0,0 +1,40 @@
+class BarValidationException(Exception):
+    pass
+
+
+class BarProviderException(Exception):
+    pass
+
+
+class BarConversionException(BarProviderException):
+    pass
+
+
+class DataSourceException(BarProviderException):
+    """
+    This exception represents the case where the data source returns an error other than a NoBarsForSymbolException.
+    """
+
+    pass
+
+
+class NoBarsForSymbolException(DataSourceException):
+    """
+    This exception represents the case wehre Yahoo Fincance cannot return any data for a symbol.
+    """
+
+    symbol: str
+
+    def __init__(self, symbol: str):
+        self.symbol = symbol
+
+    def __str__(self):
+        return f"No bars found for symbol: {self.symbol}"
+
+
+class TimeframeNotSupportedException(BarProviderException):
+    pass
+
+
+class InsufficientBarsException(BarProviderException):
+    pass

trdr/core/bar_provider/models.py

@@ -0,0 +1,38 @@
+from pydantic import BaseModel, model_validator
+
+from ..shared.models import TradingDateTime, Money
+from .exceptions import BarValidationException
+
+
+class Bar(BaseModel):
+    trading_datetime: TradingDateTime
+    open: Money
+    high: Money
+    low: Money
+    close: Money
+    volume: int
+
+    @model_validator(mode="after")
+    def check_values(self) -> "Bar":
+        # Validate that the low price is less than or equal to high price.
+        if self.low.amount > self.high.amount:
+            raise BarValidationException("Low price must be less than or equal to high price")
+        # Validate that open price is between low and high.
+        if not (self.low.amount <= self.open.amount <= self.high.amount):
+            raise BarValidationException("Open price must be between low and high prices")
+        # Validate that close price is between low and high.
+        if not (self.low.amount <= self.close.amount <= self.high.amount):
+            raise BarValidationException("Close price must be between low and high prices")
+        # Validate that the volume is non-negative.
+        if self.volume < 0:
+            raise BarValidationException("Volume cannot be negative")
+        return self
+
+    def to_json(self) -> str:
+        return self.model_dump_json(indent=2)
+
+    def __str__(self) -> str:
+        return (
+            f"Bar(timestamp={self.trading_datetime}, open={self.open}, "
+            f"high={self.high}, low={self.low}, close={self.close}, volume={self.volume})"
+        )

trdr/core/bar_provider/yf_bar_provider/test_yf_bar_provider.py

@@ -0,0 +1,73 @@
+import pytest
+import asyncio
+import yfinance as yf
+
+from .yf_bar_provider import YFBarProvider
+from ..exceptions import NoBarsForSymbolException, BarProviderException, InsufficientBarsException
+from ....test_utils.fake_yf_download import fake_yf_download
+
+
+def test_that_only_symbols_with_data_are_in_the_data_cache(yf_bar_provider_with_fake_data):
+    data_cache_symbols = set(yf_bar_provider_with_fake_data._data_cache.keys())
+    assert data_cache_symbols == {"AAPL", "MSFT"}
+
+
+def test_get_symbols_returns_a_list_of_symbols(yf_bar_provider_with_fake_data):
+    expected_symbols = {"AAPL", "MSFT"}
+    actual_symbols = yf_bar_provider_with_fake_data.get_symbols()
+    assert isinstance(actual_symbols, list)
+    # convert to set so order doesn't matter when we compare
+    actual_symbols = set(actual_symbols)
+    assert actual_symbols == expected_symbols
+
+
+def test_get_symbols_returns_only_symbols_that_have_bars(yf_bar_provider_with_fake_data):
+    expected_symbols = {"AAPL", "MSFT"}
+    actual_symbols = set(yf_bar_provider_with_fake_data.get_symbols())
+    assert actual_symbols == expected_symbols
+
+
+def test_gets_bars_throws_exception_when_no_bars_are_available_for_a_symbol(yf_bar_provider_with_fake_data):
+    with pytest.raises(NoBarsForSymbolException):
+        bars = asyncio.run(yf_bar_provider_with_fake_data.get_bars("ABCDEFG"))
+
+
+def test_get_bars_throws_exception_when_symbol_is_not_in_data_cache(yf_bar_provider_with_fake_data):
+    with pytest.raises(NoBarsForSymbolException):
+        bars = asyncio.run(yf_bar_provider_with_fake_data.get_bars("ABCDEFG"))
+
+
+def test_provider_throws_exception_when_data_source_returns_error(monkeypatch):
+    # ensure we raise an exception when the data source returns an error that is not a missing symbol error
+    with pytest.raises(BarProviderException):
+        monkeypatch.setattr(yf, "download", fake_yf_download)
+        monkeypatch.setattr(yf.shared, "_ERRORS", {"ABCDEFG": "RandomYFError()"})
+        bars = asyncio.run(YFBarProvider.create(["ABCDEFG"]))
+
+
+def test_get_bars_throws_exception_when_lookback_is_greater_than_the_number_of_bars_available(
+    yf_bar_provider_with_fake_data,
+):
+    with pytest.raises(InsufficientBarsException):
+        bars = asyncio.run(yf_bar_provider_with_fake_data.get_bars("AAPL", 7))
+
+
+def test_get_current_bar_throws_exception_when_no_bars_are_available_for_a_symbol(monkeypatch):
+    with pytest.raises(NoBarsForSymbolException):
+        """
+        Any time yf.download() is called, we clear the yf.shared._ERRORS dictionary after we are done inspecting it. Therefore, when we call yf.download() in the get_current_bar() method, we need to set the yf.shared._ERRORS dictionary again to the expected value of the test.
+        """
+        monkeypatch.setattr(yf, "download", fake_yf_download)
+        monkeypatch.setattr(yf.shared, "_ERRORS", {"ABCDEFG": "YFTzMissingError()"})
+        yf_bar_provider = asyncio.run(YFBarProvider.create(["ABCDEFG"]))
+        # yf.shared._ERRORS is currently {} as we reset it after the yf.download() call that occurs during initialization of the bar provider.
+        monkeypatch.setattr(yf.shared, "_ERRORS", {"ABCDEFG": "YFTzMissingError()"})
+        bar = asyncio.run(yf_bar_provider.get_current_bar("ABCDEFG"))
+
+
+def test_get_current_bar_throws_exception_when_data_source_returns_error(monkeypatch):
+    with pytest.raises(BarProviderException):
+        monkeypatch.setattr(yf, "download", fake_yf_download)
+        yf_bar_provider = asyncio.run(YFBarProvider.create(["ABCDEFG"]))
+        monkeypatch.setattr(yf.shared, "_ERRORS", {"ABCDEFG": "RandomYFError()"})
+        bar = asyncio.run(yf_bar_provider.get_current_bar("ABCDEFG"))