investing-algorithm-framework 1.5__py3-none-any.whl → 7.25.6__py3-none-any.whl

investing_algorithm_framework/domain/models/data/data_source.py

@@ -0,0 +1,222 @@
+from dataclasses import dataclass
+from datetime import datetime, timezone, timedelta
+from typing import Union
+
+from dateutil import parser
+
+from investing_algorithm_framework.domain.models.time_frame import TimeFrame
+from .data_type import DataType
+
+
+@dataclass(frozen=True)
+class DataSource:
+    """
+    Data registration model. Defines the data source for a strategy. A simple
+    data source can be defined as:
+    DataSource(
+        symbol="BTC/EUR",
+        data_type="ohlcv",
+        window_size=200,
+        market="BITVAVO",
+        identifier="BTC/EUR_ohlcv"
+    )
+    """
+    identifier: str = None
+    data_provider_identifier: str = None
+    data_type: Union[DataType, str] = None
+    symbol: str = None
+    window_size: int = None
+    time_frame: Union[TimeFrame, str] = None
+    market: str = None
+    storage_path: str = None
+    pandas: bool = False
+    date: Union[datetime, None] = None
+    start_date: Union[datetime, None] = None
+    end_date: Union[datetime, None] = None
+    save: bool = False
+
+    def __post_init__(self):
+        # Convert data_type and time_frame to their respective enums if needed
+        if isinstance(self.data_type, str):
+            object.__setattr__(self, 'data_type',
+                               DataType.from_string(self.data_type))
+
+        if isinstance(self.time_frame, str):
+            object.__setattr__(self, 'time_frame',
+                               TimeFrame.from_string(self.time_frame))
+
+        start_date = self.start_date
+        end_date = self.end_date
+
+        # Parse the start_date if it is a string and
+        # make sure its set to timezone utc
+        if start_date is None:
+
+            if isinstance(self.start_date, str):
+                start_date = parser.parse(start_date)
+
+            if start_date is not None:
+                object.__setattr__(
+                    self,
+                    'start_date',
+                    start_date.replace(tzinfo=timezone.utc)
+                )
+
+        # Parse the end_date if it is a string and
+        # make sure its set to timezone utc
+        if end_date is None:
+
+            if isinstance(self.end_date, str):
+                end_date = parser.parse(end_date)
+
+            if end_date is not None:
+                object.__setattr__(
+                    self,
+                    'end_date',
+                    end_date.replace(tzinfo=timezone.utc)
+                )
+
+        if self.market is not None:
+            object.__setattr__(self, 'market', self.market.upper())
+
+        if self.symbol is not None:
+            object.__setattr__(self, 'symbol', self.symbol.upper())
+
+    def get_identifier(self):
+        """
+        Returns the identifier or creates a unique identifier for the
+        data source based on its attributes.
+        """
+
+        if self.identifier is not None:
+            return self.identifier
+
+        if DataType.OHLCV.equals(self.data_type):
+            return (f"{self.data_type.value}_{self.market}_"
+                    f"{self.symbol}_{self.time_frame.value}")
+
+        elif DataType.CUSTOM.equals(self.data_type):
+            identifier = "CUSTOM"
+
+            if self.symbol is not None:
+                identifier += f"_{self.symbol}"
+
+            if self.time_frame is not None:
+                identifier += f"_{self.time_frame.value}"
+
+            if self.market is not None:
+                identifier += f"_{self.market}"
+
+            if self.window_size is not None:
+                identifier += f"_{self.window_size}"
+
+            return identifier
+
+    def to_dict(self):
+        """
+        Converts the DataSource instance to a dictionary.
+        """
+        non_null_attributes = {
+            key: value for key, value in self.__dict__.items()
+            if value is not None
+        }
+        # Convert DataType and TimeFrame to their string representations
+        if self.data_type is not None:
+            non_null_attributes['data_type'] = self.data_type.value
+        if self.time_frame is not None:
+            non_null_attributes['time_frame'] = self.time_frame.value
+
+        return non_null_attributes
+
+    def __repr__(self):
+        return (
+            f"DataSource(identifier={self.identifier}, "
+            f"data_provider_identifier={self.data_provider_identifier}, "
+            f"data_type={self.data_type}, symbol={self.symbol}, "
+            f"window_size={self.window_size}, time_frame={self.time_frame}, "
+            f"market={self.market}, storage_path={self.storage_path}, "
+            f"pandas={self.pandas}, date={self.date}, "
+            f"start_date={self.start_date}, end_date={self.end_date}, "
+            f"save={self.save})"
+        )
+
+    def __eq__(self, other):
+        """
+        Compares two DataSource instances for equality.
+
+        OHLCV data sources are considered equal if they have:
+        - The same data_type (OHLCV), symbol, time_frame, and market.
+        - If no market and timeframe is specified, then
+            they are considered equal for the same symbol
+            and data_type.
+        """
+        if DataType.OHLCV.equals(self.data_type):
+
+            if other.time_frame is None and other.window_size is None:
+                return (self.data_type == other.data_type and
+                        self.symbol == other.symbol)
+            elif self.time_frame is None and self.window_size is None:
+                return (self.data_type == other.data_type and
+                        self.symbol == other.symbol)
+
+            return (self.time_frame == other.time_frame and
+                    self.market == other.market and
+                    self.symbol == other.symbol and
+                    self.data_type == other.data_type)
+
+        elif DataType.CUSTOM.equals(self.data_type):
+            return (self.data_type == other.data_type and
+                    self.symbol == other.symbol and
+                    self.window_size == other.window_size and
+                    self.time_frame == other.time_frame and
+                    self.market == other.market)
+
+        elif DataType.TICKER.equals(self.data_type):
+            return (self.data_type == other.data_type and
+                    self.symbol == other.symbol and
+                    self.market == other.market)
+
+        return False
+
+    def create_start_date_data(self, index_date: datetime) -> datetime:
+
+        if self.window_size is None or self.time_frame is None:
+            return index_date
+
+        return index_date - \
+            (self.window_size * timedelta(
+                minutes=self.time_frame.amount_of_minutes
+            ))
+
+    def get_number_of_required_data_points(
+        self, start_date: datetime, end_date: datetime
+    ) -> int:
+        """
+        Returns the number of data points required based on the given
+        attributes of the data source. If the required number of data points
+        can't be determined, it returns None.
+
+        E.g., for OHLCV data source, it
+        calculates the number of data points needed between the
+        start_date and end_date based on the time frame.
+
+        Args:
+            start_date (datetime): The start date for the data points.
+            end_date (datetime): The end date for the data points.
+
+        Returns:
+            int: The number of required data points, or None if it can't
+            be determined.
+        """
+
+        if self.time_frame is None:
+            return None
+
+        delta = end_date - start_date
+        total_minutes = delta.total_seconds() / 60
+        data_points = total_minutes / self.time_frame.amount_of_minutes
+
+        if self.window_size is not None:
+            data_points += self.window_size
+
+        return int(data_points)

investing_algorithm_framework/domain/models/data/data_type.py

@@ -0,0 +1,46 @@
+from enum import Enum
+
+
+class DataType(Enum):
+    OHLCV = "OHLCV"
+    TICKER = "TICKER"
+    ORDER_BOOK = "ORDER_BOOK"
+    CUSTOM = "CUSTOM"
+
+    @staticmethod
+    def from_string(value: str):
+
+        if isinstance(value, str):
+
+            for entry in DataType:
+
+                if value.upper() == entry.value:
+                    return entry
+
+            raise ValueError(
+                f"Could not convert {value} to DataType"
+            )
+
+    @staticmethod
+    def from_value(value):
+
+        if isinstance(value, str):
+            return DataType.from_string(value)
+
+        if isinstance(value, DataType):
+
+            for entry in DataType:
+
+                if value == entry:
+                    return entry
+
+        raise ValueError(
+            f"Could not convert {value} to TimeFrame"
+        )
+
+    def equals(self, other):
+
+        if isinstance(other, Enum):
+            return self.value == other.value
+        else:
+            return DataType.from_string(other) == self

investing_algorithm_framework/domain/models/event.py

@@ -0,0 +1,35 @@
+from enum import Enum
+
+
+class Event(Enum):
+    PORTFOLIO_CREATED = "PORTFOLIO_CREATED"
+    ORDER_CREATED = "ORDER_CREATED"
+    TRADE_CLOSED = "TRADE_CLOSED"
+    STRATEGY_RUN = "STRATEGY_RUN"
+
+    @staticmethod
+    def from_string(value: str):
+
+        if isinstance(value, str):
+            for status in Event:
+
+                if value.upper() == status.value:
+                    return status
+
+        raise ValueError("Could not convert value to Event")
+
+    @staticmethod
+    def from_value(value):
+
+        if isinstance(value, Event):
+            for status in Event:
+
+                if value == status:
+                    return status
+        elif isinstance(value, str):
+            return Event.from_string(value)
+
+        raise ValueError(f"Could not convert value {value} to Event")
+
+    def equals(self, other):
+        return Event.from_value(other) == self

investing_algorithm_framework/domain/models/market/__init__.py

@@ -0,0 +1,5 @@
+from .market_credential import MarketCredential
+
+__all__ = [
+    "MarketCredential",
+]

investing_algorithm_framework/domain/models/market/market_credential.py

@@ -0,0 +1,88 @@
+import os
+import logging
+
+from investing_algorithm_framework.domain.exceptions import \
+    OperationalException
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+
+class MarketCredential:
+    """
+    Market credential model to store the api key and secret key for a market.
+    """
+    def __init__(
+        self, market: str, api_key: str = None, secret_key: str = None
+    ):
+        self._api_key = api_key
+        self._secret_key = secret_key
+        self._market = market
+
+    def initialize(self):
+        """
+        Internal helper to initialize the market credential.
+        """
+        logger.info(f"Initializing market credential for {self.market}")
+
+        if self.api_key is None:
+            logger.info(
+                "Reading api key from environment variable"
+                f" {self.market.upper()}_API_KEY"
+            )
+
+            # Check if environment variable is set
+            environment_variable = f"{self.market.upper()}_API_KEY"
+            self._api_key = os.getenv(environment_variable)
+
+            if self.api_key is None:
+                raise OperationalException(
+                    f"Market credential for market {self.market}"
+                    " requires an api key, either"
+                    " as an argument or as an environment variable"
+                    f" named as {self._market.upper()}_API_KEY"
+                )
+
+        if self.secret_key is None:
+            logger.info(
+                "Reading secret key from environment variable"
+                f" {self.market.upper()}_SECRET_KEY"
+            )
+
+            # Check if environment variable is set
+            environment_variable = f"{self.market.upper()}_SECRET_KEY"
+            self._secret_key = os.getenv(environment_variable)
+
+        if self.api_key is not None:
+            self._api_key = self.api_key.strip()
+
+        if self.secret_key is not None:
+            self._secret_key = self.secret_key.strip()
+
+    def get_api_key(self):
+        return self.api_key
+
+    def get_secret_key(self):
+        return self.secret_key
+
+    def get_market(self):
+        return self.market
+
+    @property
+    def market(self):
+        return self._market
+
+    @market.setter
+    def market(self, market):
+        self._market = market
+
+    @property
+    def api_key(self):
+        return self._api_key
+
+    @property
+    def secret_key(self):
+        return self._secret_key
+
+    def __repr__(self):
+        return f"MarketCredential(" \
+               f"{self.market}, {self.api_key}, {self.secret_key}"

investing_algorithm_framework/domain/models/order/__init__.py

@@ -1,7 +1,6 @@
-from .order_type import OrderType
+from .order import Order
 from .order_side import OrderSide
 from .order_status import OrderStatus
-from .order import Order
-from .order_fee import OrderFee
+from .order_type import OrderType
 
-__all__ = ["OrderType", "OrderStatus", "OrderSide", "Order", "OrderFee"]
+__all__ = ["OrderType", "OrderStatus", "OrderSide", "Order"]