investing-algorithm-framework 7.19.14__py3-none-any.whl

investing_algorithm_framework/domain/models/portfolio/portfolio_configuration.py

@@ -0,0 +1,93 @@
+from dateutil.parser import parse
+
+from investing_algorithm_framework.domain.exceptions import \
+    ImproperlyConfigured
+from investing_algorithm_framework.domain.models.base_model import BaseModel
+
+
+class PortfolioConfiguration(BaseModel):
+    """
+    This class represents a portfolio configuration. It is used to
+    configure the portfolio that the user wants to create.
+
+    The portfolio configuration will have the following attributes:
+    - market: The market where the portfolio will be created
+    - trading_symbol: The trading symbol of the portfolio
+    - track_from: The date from which the portfolio will be tracked
+    - identifier: The identifier of the portfolio
+    - initial_balance: The initial balance of the portfolio
+
+    For backtesting, a portfolio configuration is used to create a
+    portfolio that will be used to simulate the trading of the algorithm. if
+    the user does not provide an initial balance, the portfolio will be created
+    with a balance of according to the initial balanace of
+        the PortfolioConfiguration class.
+    """
+
+    def __init__(
+        self,
+        market,
+        trading_symbol,
+        track_from=None,
+        identifier=None,
+        initial_balance=None,
+    ):
+        self._market = market
+
+        if self._market is not None:
+            self._market = self._market.upper()
+
+        self._track_from = None
+        self._trading_symbol = trading_symbol.upper()
+        self._identifier = identifier
+        self._initial_balance = initial_balance
+
+        if self.identifier is None:
+            self._identifier = market.upper()
+        else:
+            self._identifier = identifier.upper()
+
+        if track_from:
+            self._track_from = parse(track_from)
+
+        if self.trading_symbol is None:
+            raise ImproperlyConfigured(
+                "Portfolio configuration requires a trading symbol"
+            )
+
+    @property
+    def market(self):
+
+        if hasattr(self._market, "upper"):
+            return self._market.upper()
+
+        return self._market
+
+    @property
+    def track_from(self):
+        return self._track_from
+
+    @property
+    def identifier(self):
+        return self._identifier
+
+    @property
+    def trading_symbol(self):
+        return self._trading_symbol
+
+    @property
+    def initial_balance(self):
+        return self._initial_balance
+
+    @property
+    def has_initial_balance(self):
+        return self._initial_balance is not None
+
+    def __repr__(self):
+        return self.repr(
+            market=self.market,
+            trading_symbol=self.trading_symbol,
+            identifier=self.identifier,
+            track_from=self.track_from,
+            initial_balance=self.initial_balance
+        )

investing_algorithm_framework/domain/models/portfolio/portfolio_snapshot.py

@@ -0,0 +1,208 @@
+from datetime import timezone
+
+from dateutil import parser
+
+from investing_algorithm_framework.domain.models.base_model import BaseModel
+
+
+class PortfolioSnapshot(BaseModel):
+
+    def __init__(
+        self,
+        portfolio_id=None,
+        trading_symbol=None,
+        pending_value=None,
+        unallocated=None,
+        net_size=None,
+        total_net_gain=None,
+        total_revenue=None,
+        total_cost=None,
+        total_value=None,
+        cash_flow=None,
+        created_at=None,
+        position_snapshots=None,
+        metadata=None,
+    ):
+        self.portfolio_id = portfolio_id
+        self.trading_symbol = trading_symbol
+        self.pending_value = pending_value
+        self.unallocated = unallocated
+        self.total_net_gain = total_net_gain
+        self.total_revenue = total_revenue
+        self.total_value = total_value if total_value is not None else 0.0
+        self.net_size = net_size
+        self.total_cost = total_cost
+        self.cash_flow = cash_flow
+        self.metadata = metadata if metadata is not None else {}
+
+        if created_at is not None and isinstance(created_at, str):
+            self.created_at = parser.parse(created_at)
+        else:
+            self.created_at = created_at
+
+        # Make sure that created_at is a timezone aware datetime object
+        self.created_at = self.created_at.replace(tzinfo=timezone.utc)
+
+        if position_snapshots is None:
+            position_snapshots = []
+
+        self.position_snapshots = position_snapshots
+
+    def get_portfolio_id(self):
+        return self.portfolio_id
+
+    def set_portfolio_id(self, portfolio_id):
+        self.portfolio_id = portfolio_id
+
+    def get_trading_symbol(self):
+        return self.trading_symbol
+
+    def set_trading_symbol(self, trading_symbol):
+        self.trading_symbol = trading_symbol.upper()
+
+    def get_pending_value(self):
+        return self.pending_value
+
+    def set_pending_value(self, pending_value):
+        self.pending_value = pending_value
+
+    def get_unallocated(self):
+        return self.unallocated
+
+    def set_unallocated(self, unallocated):
+        self.unallocated = unallocated
+
+    def get_total_net_gain(self):
+        return self.total_net_gain
+
+    def set_total_net_gain(self, total_net_gain):
+        self.total_net_gain = total_net_gain
+
+    def get_total_revenue(self):
+        return self.total_revenue
+
+    def set_total_revenue(self, total_revenue):
+        self.total_revenue = total_revenue
+
+    def get_total_value(self):
+        return self.total_value
+
+    def set_total_value(self, total_value):
+        self.total_value = total_value
+
+    def get_total_cost(self):
+        return self.total_cost
+
+    def set_total_cost(self, total_cost):
+        self.total_cost = total_cost
+
+    def get_cash_flow(self):
+        return self.cash_flow
+
+    def set_cash_flow(self, cash_flow):
+        self.cash_flow = cash_flow
+
+    def get_created_at(self):
+        return self.created_at
+
+    def set_created_at(self, created_at):
+        self.created_at = created_at
+
+    def get_portfolio_snapshot_id(self):
+        return self.portfolio_snapshot_id
+
+    def set_position_snapshots(self, position_snapshots):
+        self.position_snapshots = position_snapshots
+
+    def get_position_snapshots(self):
+        return self.position_snapshots
+
+    def set_portfolio_snapshot_id(self, portfolio_snapshot_id):
+        self.portfolio_snapshot_id = portfolio_snapshot_id
+
+    def __repr__(self):
+        return self.repr(
+            portfolio_id=self.portfolio_id,
+            created_at=self.created_at.strftime("%Y-%m-%d %H:%M:%S"),
+            trading_symbol=self.trading_symbol,
+            net_size=self.net_size,
+            unallocated=self.unallocated,
+            pending_value=self.pending_value,
+            total_net_gain=self.total_net_gain,
+            total_revenue=self.total_revenue,
+            total_cost=self.total_cost,
+            cash_flow=self.cash_flow,
+            metadata=self.metadata,
+        )
+
+    def to_dict(self, datetime_format=None):
+        """
+        Convert the portfolio snapshot object to a dictionary
+
+        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 portfolio snapshot 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
+
+        return {
+            "metadata": self.metadata if self.metadata else {},
+            "portfolio_id": self.portfolio_id if self.portfolio_id else "",
+            "trading_symbol": self.trading_symbol
+            if self.trading_symbol else "",
+            "pending_value": self.pending_value if self.pending_value else 0.0,
+            "unallocated": self.unallocated if self.unallocated else 0.0,
+            "total_net_gain": self.total_net_gain
+            if self.total_net_gain else 0.0,
+            "total_revenue": self.total_revenue if self.total_revenue else 0.0,
+            "total_cost": self.total_cost if self.total_cost else 0.0,
+            "cash_flow": self.cash_flow if self.cash_flow else 0.0,
+            "net_size": self.net_size if self.net_size else 0.0,
+            "created_at": created_at if created_at else "",
+            "total_value": self.total_value if self.total_value else 0.0,
+        }
+
+    @staticmethod
+    def from_dict(data):
+        """
+        Create a PortfolioSnapshot object from a dictionary.
+
+        Args:
+            data (dict): A dictionary containing the portfolio snapshot data.
+
+        Returns:
+            PortfolioSnapshot: An instance of PortfolioSnapshot.
+        """
+        created_at_str = data.get("created_at")
+        created_at = parser.parse(created_at_str)
+
+        # Ensure created_at is timezone aware
+        created_at = created_at.replace(tzinfo=timezone.utc)
+
+        return PortfolioSnapshot(
+            net_size=data.get("net_size", 0.0),
+            created_at=created_at,
+            total_value=data.get("total_value", 0.0),
+            trading_symbol=data.get(
+                "trading_symbol", None
+            ),
+            portfolio_id=data.get("portfolio_id", None),
+            pending_value=data.get("pending_value", 0.0),
+            unallocated=data.get("unallocated", 0.0),
+            total_net_gain=data.get("total_net_gain", 0.0),
+            total_revenue=data.get("total_revenue", 0.0),
+            total_cost=data.get("total_cost", 0.0),
+            cash_flow=data.get("cash_flow", 0.0),
+            metadata=data.get("metadata", {})
+        )

investing_algorithm_framework/domain/models/position/__init__.py

@@ -0,0 +1,4 @@
+from .position import Position
+from .position_snapshot import PositionSnapshot
+
+__all__ = ["Position", "PositionSnapshot"]

investing_algorithm_framework/domain/models/position/position.py

@@ -0,0 +1,68 @@
+from investing_algorithm_framework.domain.models.base_model import BaseModel
+
+
+class Position(BaseModel):
+    """
+    This class represents a position in a portfolio.
+    """
+
+    def __init__(
+        self,
+        symbol=None,
+        amount=0,
+        cost=0,
+        portfolio_id=None
+    ):
+        self.symbol = symbol
+        self.amount = amount
+        self.cost = cost
+        self.portfolio_id = portfolio_id
+
+    def get_symbol(self):
+        return self.symbol
+
+    def set_symbol(self, symbol):
+        self.symbol = symbol.upper()
+
+    def get_amount(self):
+        return self.amount
+
+    def get_cost(self):
+        return self.cost
+
+    def set_cost(self, cost):
+        self.cost = cost
+
+    def set_amount(self, amount):
+        self.amount = amount
+
+    def get_portfolio_id(self):
+        return self.portfolio_id
+
+    def set_portfolio_id(self, portfolio_id):
+        self.portfolio_id = portfolio_id
+
+    def to_dict(self):
+        return {
+            "symbol": self.symbol,
+            "amount": self.amount,
+            "cost": self.cost,
+            "portfolio_id": self.portfolio_id,
+        }
+
+    @staticmethod
+    def from_dict(data: dict):
+        return Position(
+            symbol=data.get("symbol"),
+            amount=data.get("amount", 0),
+            cost=data.get("cost", 0),
+            portfolio_id=data.get("portfolio_id"),
+        )
+
+    def __repr__(self):
+        return self.repr(
+            symbol=self.symbol,
+            amount=self.amount,
+            cost=self.cost,
+            portfolio_id=self.portfolio_id,
+        )

investing_algorithm_framework/domain/models/position/position_snapshot.py

@@ -0,0 +1,47 @@
+from investing_algorithm_framework.domain.models.base_model import BaseModel
+
+
+class PositionSnapshot(BaseModel):
+
+    def __init__(
+        self,
+        symbol=None,
+        amount=0,
+        cost=0,
+        portfolio_snapshot_id=None
+    ):
+        self.symbol = symbol
+        self.amount = amount
+        self.cost = cost
+        self.portfolio_snapshot_id = portfolio_snapshot_id
+
+    def get_symbol(self):
+        return self.symbol
+
+    def set_symbol(self, symbol):
+        self.symbol = symbol.upper()
+
+    def get_amount(self):
+        return self.amount
+
+    def get_cost(self):
+        return self.cost
+
+    def set_cost(self, cost):
+        self.cost = cost
+
+    def set_amount(self, amount):
+        self.amount = amount
+
+    def get_portfolio_snapshot_id(self):
+        return self.portfolio_snapshot_id
+
+    def set_portfolio_snapshot_id(self, portfolio_snapshot_id):
+        self.portfolio_snapshot_id = portfolio_snapshot_id
+
+    def __repr__(self):
+        return self.repr(
+            symbol=self.symbol,
+            amount=self.amount,
+            portfolio_snapshot_id=self.portfolio_snapshot_id,
+        )

investing_algorithm_framework/domain/models/snapshot_interval.py

@@ -0,0 +1,45 @@
+from enum import Enum
+
+
+class SnapshotInterval(Enum):
+    STRATEGY_ITERATION = "STRATEGY_ITERATION"
+    DAILY = "DAILY"
+
+    @staticmethod
+    def from_string(value: str):
+
+        if isinstance(value, str):
+
+            for entry in SnapshotInterval:
+
+                if value.upper() == entry.value:
+                    return entry
+
+            raise ValueError(
+                f"Could not convert {value} to SnapshotInterval"
+            )
+        return None
+
+    @staticmethod
+    def from_value(value):
+
+        if isinstance(value, str):
+            return SnapshotInterval.from_string(value)
+
+        if isinstance(value, SnapshotInterval):
+
+            for entry in SnapshotInterval:
+
+                if value == entry:
+                    return entry
+
+        raise ValueError(
+            f"Could not convert {value} to SnapshotInterval"
+        )
+
+    def equals(self, other):
+
+        if isinstance(other, Enum):
+            return self.value == other.value
+        else:
+            return SnapshotInterval.from_string(other) == self

investing_algorithm_framework/domain/models/strategy_profile.py

@@ -0,0 +1,33 @@
+from dataclasses import dataclass
+
+from .time_unit import TimeUnit
+
+
+@dataclass(frozen=True)
+class StrategyProfile:
+    """
+    StrategyProfile class that represents the profile of a trading strategy.
+    """
+    strategy_id: str = None
+    interval: int = None
+    time_unit: TimeUnit = None
+    trading_time_frame: str = None
+    trading_time_frame_start_date: str = None
+    backtest_start_date_data: str = None
+    backtest_data_index_date: str = None
+    symbols: list = None
+    market: str = None
+    trading_data_type: str = None
+    trading_data_types: list = None
+    data_sources: list = None
+
+    def get_runs_per_day(self):
+
+        if self.time_unit is None:
+            return 0
+        elif TimeUnit.SECOND.equals(self.time_unit):
+            return 86400 / self.interval
+        elif TimeUnit.MINUTE.equals(self.time_unit):
+            return 1440 / self.interval
+        else:
+            return 24 / self.interval

investing_algorithm_framework/domain/models/time_frame.py

@@ -0,0 +1,153 @@
+from enum import Enum
+
+
+class TimeFrame(Enum):
+    CURRENT = "CURRENT"
+    ONE_MINUTE = "1m"
+    TWO_MINUTE = "2m"
+    THREE_MINUTE = "3m"
+    FOUR_MINUTE = "4m"
+    FIVE_MINUTE = "5m"
+    TEN_MINUTE = "10m"
+    FIFTEEN_MINUTE = "15m"
+    THIRTY_MINUTE = "30m"
+    ONE_HOUR = "1h"
+    TWO_HOUR = "2h"
+    FOUR_HOUR = "4h"
+    TWELVE_HOUR = "12h"
+    ONE_DAY = "1d"
+    ONE_WEEK = "1W"
+    ONE_MONTH = "1M"
+    ONE_YEAR = "1Y"
+
+    @staticmethod
+    def from_string(value: str):
+
+        if isinstance(value, str):
+
+            for entry in TimeFrame:
+
+                # For hour timeframes compare with and without H
+                if "H" in entry.value:
+
+                    if value == entry.value:
+                        return entry
+
+                    if value == entry.value.replace("H", "h"):
+                        return entry
+
+                # For hour timeframes compare with and without H
+                if "d" in entry.value:
+
+                    if value == entry.value:
+                        return entry
+
+                    if value == entry.value.replace("d", "D"):
+                        return entry
+
+                if value == entry.value:
+                    return entry
+
+            raise ValueError(
+                f"Could not convert {value} to TimeFrame"
+            )
+
+    @staticmethod
+    def from_value(value):
+
+        if isinstance(value, str):
+            return TimeFrame.from_string(value)
+
+        if isinstance(value, TimeFrame):
+
+            for entry in TimeFrame:
+
+                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 TimeFrame.from_string(other) == self
+
+    @property
+    def amount_of_minutes(self):
+
+        if self.equals(TimeFrame.ONE_MINUTE):
+            return 1
+
+        if self.equals(TimeFrame.TWO_MINUTE):
+            return 2
+
+        if self.equals(TimeFrame.THREE_MINUTE):
+            return 3
+
+        if self.equals(TimeFrame.FOUR_MINUTE):
+            return 4
+
+        if self.equals(TimeFrame.FIVE_MINUTE):
+            return 5
+
+        if self.equals(TimeFrame.TEN_MINUTE):
+            return 10
+
+        if self.equals(TimeFrame.FIFTEEN_MINUTE):
+            return 15
+
+        if self.equals(TimeFrame.THIRTY_MINUTE):
+            return 30
+
+        if self.equals(TimeFrame.ONE_HOUR):
+            return 60
+
+        if self.equals(TimeFrame.TWO_HOUR):
+            return 120
+
+        if self.equals(TimeFrame.FOUR_HOUR):
+            return 240
+
+        if self.equals(TimeFrame.TWELVE_HOUR):
+            return 720
+
+        if self.equals(TimeFrame.ONE_DAY):
+            return 1440
+
+        if self.equals(TimeFrame.ONE_WEEK):
+            return 10080
+
+        if self.equals(TimeFrame.ONE_MONTH):
+            return 40320
+
+        if self.equals(TimeFrame.ONE_YEAR):
+            return 525600
+
+        raise ValueError(
+            f"Could not determine amount of minutes for {self.value}"
+        )
+
+    # Add comparison methods for ordering
+    def __lt__(self, other):
+        if isinstance(other, TimeFrame):
+            return self.amount_of_minutes < other.amount_of_minutes
+        raise TypeError(f"Cannot compare TimeFrame with {type(other)}")
+
+    def __le__(self, other):
+        if isinstance(other, TimeFrame):
+            return self.amount_of_minutes <= other.amount_of_minutes
+        raise TypeError(f"Cannot compare TimeFrame with {type(other)}")
+
+    def __gt__(self, other):
+        if isinstance(other, TimeFrame):
+            return self.amount_of_minutes > other.amount_of_minutes
+        raise TypeError(f"Cannot compare TimeFrame with {type(other)}")
+
+    def __ge__(self, other):
+        if isinstance(other, TimeFrame):
+            return self.amount_of_minutes >= other.amount_of_minutes
+        raise TypeError(f"Cannot compare TimeFrame with {type(other)}")