investing-algorithm-framework 3.7.0__py3-none-any.whl → 7.19.15__py3-none-any.whl

investing_algorithm_framework/domain/models/data/data_source.py

@@ -0,0 +1,214 @@
+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:
+    """
+    Base class for data sources.
+    """
+    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/market_credential.py

@@ -1,9 +1,63 @@
+import os
+import logging
+
+from investing_algorithm_framework.domain.exceptions import \
+    OperationalException
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+
 class MarketCredential:
-    def __init__(self, api_key: str, secret_key: str, market: str):
+    """
+    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
 

investing_algorithm_framework/domain/models/order/order.py

@@ -1,4 +1,5 @@
 import logging
+from datetime import datetime, timezone
 
 from dateutil.parser import parse
 
@@ -23,26 +24,24 @@ class Order(BaseModel):
         self,
         order_type,
         order_side,
-        status,
         amount,
+        status: OrderStatus | None | str = OrderStatus.CREATED.value,
         target_symbol=None,
         trading_symbol=None,
         price=None,
-        net_gain=0,
         created_at=None,
         updated_at=None,
-        trade_closed_at=None,
-        trade_closed_price=None,
-        trade_closed_amount=None,
         external_id=None,
+        cost=None,
         filled=None,
         remaining=None,
-        cost=None,
         fee=None,
         position_id=None,
         order_fee=None,
         order_fee_currency=None,
-        order_fee_rate=None
+        order_fee_rate=None,
+        id=None,
+        metadata=None,
     ):
         if target_symbol is None:
             raise OperationalException("Target symbol is not specified")
@@ -62,6 +61,15 @@ class Order(BaseModel):
         if status is None:
             raise OperationalException("Status is not set")
 
+        self.created_at = created_at
+        self.updated_at = updated_at
+
+        if self.created_at is None:
+            self.created_at = datetime.now(tz=timezone.utc)
+
+        if self.updated_at is None:
+            self.updated_at = datetime.now(tz=timezone.utc)
+
         self.external_id = external_id
         self.price = price
         self.order_side = OrderSide.from_value(order_side).value
@@ -69,20 +77,16 @@ class Order(BaseModel):
         self.status = OrderStatus.from_value(status).value
         self.position_id = position_id
         self.amount = amount
-        self.net_gain = net_gain
-        self.trade_closed_at = trade_closed_at
-        self.trade_closed_price = trade_closed_price
-        self.trade_closed_amount = trade_closed_amount
-        self.created_at = created_at
-        self.updated_at = updated_at
         self.filled = filled
         self.remaining = remaining
-        self.cost = cost
         self.fee = fee
         self._available_amount = self.filled
         self.order_fee = order_fee
         self.order_fee_currency = order_fee_currency
         self.order_fee_rate = order_fee_rate
+        self.id = id
+        self.cost = cost
+        self.metadata = metadata if metadata is not None else {}
 
     def get_id(self):
         return self.id
@@ -147,38 +151,6 @@ class Order(BaseModel):
     def set_external_id(self, external_id):
         self.external_id = external_id
 
-    def get_net_gain(self):
-
-        if self.net_gain is None:
-            return 0
-
-        return self.net_gain
-
-    def set_net_gain(self, net_gain):
-        self.net_gain = net_gain
-
-    def get_trade_closed_at(self):
-        return self.trade_closed_at
-
-    def set_trade_closed_at(self, trade_closed_at):
-        self.trade_closed_at = trade_closed_at
-
-    def get_trade_closed_price(self):
-        return self.trade_closed_price
-
-    def set_trade_closed_price(self, trade_closed_price):
-        self.trade_closed_price = trade_closed_price
-
-    def get_trade_closed_amount(self):
-
-        if self.trade_closed_amount is not None:
-            return self.trade_closed_amount
-
-        return 0
-
-    def set_trade_closed_amount(self, trade_closed_amount):
-        self.trade_closed_amount = trade_closed_amount
-
     def get_created_at(self):
         return self.created_at
 
@@ -204,23 +176,13 @@ class Order(BaseModel):
     def get_remaining(self):
 
         if self.remaining is None:
-            return self.amount
+            return self.get_amount() - self.get_filled()
 
         return self.remaining
 
     def set_remaining(self, remaining):
         self.remaining = remaining
 
-    def get_cost(self):
-
-        if self.cost is None:
-            return 0
-
-        return self.cost
-
-    def set_cost(self, cost):
-        self.cost = cost
-
     def get_fee(self):
         return self.fee
 
@@ -228,7 +190,13 @@ class Order(BaseModel):
         self.fee = order_fee
 
     def get_symbol(self):
-        return self.get_target_symbol() + "/" + self.get_trading_symbol()
+        return (self.get_target_symbol().upper() + "/"
+                + self.get_trading_symbol().upper())
+
+    @property
+    def symbol(self):
+        return (self.get_target_symbol().upper() + "/"
+                + self.get_trading_symbol().upper())
 
     def get_available_amount(self):
 
@@ -249,20 +217,33 @@ class Order(BaseModel):
         self.set_available_amount(available_amount)
 
     def to_dict(self, datetime_format=None):
+        """
+        Convert the Order object to a dictionary
 
-        if datetime_format is not None:
-            created_at = self.created_at.strftime(datetime_format) \
-                if self.created_at else None
-            updated_at = self.updated_at.strftime(datetime_format) \
-                if self.updated_at else None
-            trade_closed_at = self.trade_closed_at.strftime(datetime_format) \
-                if self.trade_closed_at else None
-        else:
-            created_at = self.created_at
-            updated_at = self.updated_at
-            trade_closed_at = self.trade_closed_at
+        Args:
+            datetime_format (str): The format to use for the datetime fields.
+                If None, the datetime fields will be returned as is.
+                Defaults to None.
+
+        Returns:
+            dict: A dictionary representation of the Order object.
+        """
+
+        def ensure_iso(value):
+            if hasattr(value, "isoformat"):
+                if value.tzinfo is None:
+                    value = value.replace(tzinfo=timezone.utc)
+                return value.isoformat()
+            return value
+
+        created_at = ensure_iso(self.created_at) if self.created_at else None
+        updated_at = ensure_iso(self.updated_at) if self.updated_at else None
+
+        # Ensure status is a string
+        self.status = OrderStatus.from_value(self.status).value
 
         return {
+            "id": self.id,
             "external_id": self.external_id,
             "target_symbol": self.target_symbol,
             "trading_symbol": self.trading_symbol,
@@ -271,17 +252,15 @@ class Order(BaseModel):
             "status": self.status,
             "price": self.price,
             "amount": self.amount,
-            "net_gain": self.net_gain,
-            "trade_closed_at": trade_closed_at,
-            "trade_closed_price": self.trade_closed_price,
             "created_at": created_at,
             "updated_at": updated_at,
+            "cost": self.cost,
             "filled": self.filled,
             "remaining": self.remaining,
-            "cost": self.cost,
             "order_fee_currency": self.order_fee_currency,
             "order_fee_rate": self.order_fee_rate,
             "order_fee": self.order_fee,
+            "metadata": self.metadata if hasattr(self, 'metadata') else {},
         }
 
     @staticmethod
@@ -303,8 +282,9 @@ class Order(BaseModel):
         if updated_at is not None:
             updated_at = parse(updated_at)
 
-        return Order(
-            external_id=data.get("id", None),
+        order = Order(
+            id=data.get("id", None),
+            external_id=data.get("external_id", None),
             target_symbol=target_symbol,
             trading_symbol=trading_symbol,
             price=data.get("price", None),
@@ -314,14 +294,16 @@ class Order(BaseModel):
             order_side=data.get("order_side", None),
             filled=data.get("filled", None),
             remaining=data.get("remaining", None),
-            cost=data.get("cost", None),
             fee=data.get("fee", None),
+            cost=data.get("cost", None),
             created_at=created_at,
             updated_at=updated_at,
             order_fee=data.get("order_fee", None),
             order_fee_currency=data.get("order_fee_currency", None),
             order_fee_rate=data.get("order_fee_rate", None),
+            metadata=data.get("metadata", {}),
         )
+        return order
 
     @staticmethod
     def from_ccxt_order(ccxt_order):
@@ -343,6 +325,13 @@ class Order(BaseModel):
             order_fee_currency = ccxt_fee.get("currency", None)
             order_fee_rate = ccxt_fee.get("rate", None)
 
+        created_at = ccxt_order.get("datetime", None)
+        created_at = parse(created_at) if created_at else None
+
+        # Make sure that the created_at is a utc datetime object
+        if created_at and created_at.tzinfo is None:
+            created_at = created_at.replace(tzinfo=timezone.utc)
+
         return Order(
             external_id=ccxt_order.get("id", None),
             target_symbol=target_symbol,
@@ -350,15 +339,15 @@ class Order(BaseModel):
             price=ccxt_order.get("price", None),
             amount=ccxt_order.get("amount", None),
             status=status,
+            cost=ccxt_order.get("cost", None),
             order_type=ccxt_order.get("type", None),
             order_side=ccxt_order.get("side", None),
             filled=ccxt_order.get("filled", None),
             remaining=ccxt_order.get("remaining", None),
-            cost=ccxt_order.get("cost", None),
             order_fee=order_fee,
             order_fee_currency=order_fee_currency,
             order_fee_rate=order_fee_rate,
-            created_at=parse(ccxt_order.get("datetime", None))
+            created_at=created_at
         )
 
     def __repr__(self):
@@ -372,7 +361,6 @@ class Order(BaseModel):
             id=id_value,
             price=self.get_price(),
             amount=self.get_amount(),
-            net_gain=self.get_net_gain(),
             external_id=self.external_id,
             status=self.status,
             target_symbol=self.target_symbol,
@@ -381,10 +369,16 @@ class Order(BaseModel):
             order_type=self.order_type,
             filled=self.get_filled(),
             remaining=self.get_remaining(),
-            cost=self.get_cost(),
-            trade_closed_at=self.get_trade_closed_at(),
-            trade_closed_price=self.get_trade_closed_price(),
-            trade_closed_amount=self.get_trade_closed_amount(),
             created_at=self.get_created_at(),
             updated_at=self.get_updated_at(),
         )
+
+    def get_size(self):
+        """
+        Get the size of the order
+
+        Returns:
+            float: The size of the order
+        """
+        return self.get_amount() * self.get_price() \
+            if self.get_price() is not None else 0

investing_algorithm_framework/domain/models/order/order_status.py

@@ -18,7 +18,7 @@ class OrderStatus(Enum):
                 if value.upper() == order_type.value:
                     return order_type
 
-        raise ValueError("Could not convert value to OrderStatus")
+        raise ValueError(f"Could not convert value {value} to OrderStatus")
 
     @staticmethod
     def from_value(value):
@@ -31,7 +31,7 @@ class OrderStatus(Enum):
         elif isinstance(value, str):
             return OrderStatus.from_string(value)
 
-        raise ValueError("Could not convert value to OrderStatus")
+        raise ValueError(f"Could not convert value: {value} to OrderStatus")
 
     def equals(self, other):
         return OrderStatus.from_value(other) == self