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

investing_algorithm_framework/domain/models/time_interval.py

@@ -0,0 +1,124 @@
+from enum import Enum
+
+from .time_frame import TimeFrame
+
+
+class TimeInterval(Enum):
+    CURRENT = "CURRENT"
+    MINUTES_ONE = "MINUTES_ONE"
+    MINUTES_FIFTEEN = "MINUTES_FIFTEEN"
+    HOURS_ONE = "HOURS_ONE"
+    HOURS_FOUR = "HOURS_FOUR"
+    DAYS_ONE = "DAYS_ONE"
+
+    @staticmethod
+    def from_string(value: str):
+
+        if isinstance(value, str):
+
+            for entry in TimeInterval:
+
+                if value.upper() == entry.value:
+                    return entry
+
+            raise ValueError(
+                f"Could not convert {value} to TimeInterval"
+            )
+
+    @staticmethod
+    def from_ohlcv_data_file(file_path: str):
+        """
+        Extracts the time interval from the file name of an OHLCV data file.
+        The file name should contain the time interval in the format
+        'symbol_timeinterval.csv'.
+
+        Args:
+            file_path (str): The file path of the OHLCV data file.
+
+        Returns:
+            TimeInterval: The extracted time interval.
+        """
+        if not isinstance(file_path, str):
+            raise ValueError("File path must be a string.")
+
+        parts = file_path.split('_')
+        if len(parts) < 2:
+            raise ValueError(
+                "File name does not contain a valid time interval."
+            )
+
+        time_interval_str = parts[-1].split('.')[0].upper()
+        try:
+            return TimeInterval.from_string(time_interval_str)
+        except ValueError:
+            raise ValueError(
+                "Could not extract time interval from "
+                f"file name: {file_path}. "
+                "Expected format 'symbol_timeinterval.csv', "
+                f"got '{time_interval_str}'."
+            )
+
+    def equals(self, other):
+
+        if isinstance(other, Enum):
+            return self.value == other.value
+
+        else:
+            return TimeInterval.from_string(other) == self
+
+    @staticmethod
+    def from_time_frame(time_frame):
+
+        if TimeFrame.CURRENT.equals(time_frame):
+            return TimeInterval.CURRENT
+        elif TimeFrame.ONE_HOUR.equals(time_frame):
+            return TimeInterval.MINUTES_ONE
+        elif TimeFrame.ONE_DAY.equals(time_frame):
+            return TimeInterval.MINUTES_FIFTEEN
+        elif TimeFrame.ONE_WEEK.equals(time_frame):
+            return TimeInterval.HOURS_ONE
+        elif TimeFrame.ONE_MONTH.equals(time_frame):
+            return TimeInterval.HOURS_FOUR
+        elif TimeFrame.ONE_YEAR.equals(time_frame):
+            return TimeInterval.DAYS_ONE
+        else:
+            raise NotImplementedError(
+                f"Timeframe {time_frame} not implemented"
+            )
+
+    def amount_of_data_points(self):
+
+        if TimeInterval.CURRENT.equals(self):
+            return 1
+        elif TimeInterval.MINUTES_ONE.equals(self):
+            return 60
+        elif TimeInterval.MINUTES_FIFTEEN.equals(self):
+            return 96
+        elif TimeInterval.HOURS_ONE.equals(self):
+            return 168
+        elif TimeInterval.HOURS_FOUR.equals(self):
+            return 168
+        elif TimeInterval.DAYS_ONE.equals(self):
+            return 365
+        else:
+            raise NotImplementedError(f"Timeframe {self} not implemented")
+
+    @property
+    def time_frame(self):
+        from investing_algorithm_framework.domain.models.time_frame import \
+            TimeFrame
+
+        if TimeInterval.MINUTES_ONE.equals(self):
+            return TimeFrame.ONE_HOUR
+        elif TimeInterval.MINUTES_FIFTEEN.equals(self):
+            return TimeFrame.ONE_DAY
+        elif TimeInterval.HOURS_ONE.equals(self):
+            return TimeFrame.ONE_WEEK
+        elif TimeInterval.HOURS_FOUR.equals(self):
+            return TimeFrame.ONE_MONTH
+        elif TimeInterval.DAYS_ONE.equals(self):
+            return TimeFrame.ONE_YEAR
+        else:
+            raise NotImplementedError(
+                f"TimeInterval {self.value} not implemented"
+            )

investing_algorithm_framework/domain/models/time_unit.py

@@ -0,0 +1,149 @@
+from datetime import timedelta
+from enum import Enum
+from investing_algorithm_framework.domain.exceptions import \
+    OperationalException
+
+
+class TimeUnit(Enum):
+    """
+    Enum class the represents a time unit such as
+    second, minute, hour or day. This can class
+    can be used to specify time specification within
+    the framework.
+    """
+    SECOND = "SECOND"
+    MINUTE = "MINUTE"
+    HOUR = "HOUR"
+    DAY = "DAY"
+
+    @staticmethod
+    def from_string(value: str):
+
+        if isinstance(value, str):
+
+            for entry in TimeUnit:
+
+                if value.upper() == entry.value:
+                    return entry
+
+            raise OperationalException(
+                f"Could not convert string {value} to time unit"
+            )
+
+        raise OperationalException(
+            f"Could not convert value {value} to time unit," +
+            " please make sure that the value is either of type string or" +
+            f"TimeUnit. Its current type is {type(value)}"
+        )
+
+    @staticmethod
+    def from_ohlcv_data_file(file_path: str):
+        """
+        Extracts the time unit from the file name of an OHLCV data file.
+        The file name should contain the time unit in the
+        format 'symbol_timeunit.csv'.
+
+        Args:
+            file_path (str): The file path of the OHLCV data file.
+
+        Returns:
+            TimeUnit: The extracted time unit.
+        """
+        if not isinstance(file_path, str):
+            raise OperationalException(
+                "File path must be a string."
+            )
+
+        parts = file_path.split('_')
+        if len(parts) < 2:
+            raise OperationalException(
+                "File name does not contain a valid time unit."
+            )
+
+        time_unit_str = parts[-1].split('.')[0].upper()
+        try:
+            return TimeUnit.from_string(time_unit_str)
+        except ValueError:
+            raise OperationalException(
+                f"Could not extract time unit from file name: {file_path}. "
+                "Expected format 'symbol_timeunit.csv', "
+                f"got '{time_unit_str}'."
+            )
+
+    def equals(self, other):
+
+        if isinstance(other, Enum):
+            return self.value == other.value
+        else:
+            return TimeUnit.from_string(other) == self
+
+    @staticmethod
+    def from_value(value):
+
+        if isinstance(value, TimeUnit):
+
+            for entry in TimeUnit:
+
+                if entry == value:
+                    return entry
+
+        return TimeUnit.from_string(value)
+
+    def create_date(self, start_date, interval):
+
+        if TimeUnit.SECOND.equals(self):
+            return timedelta(minutes=interval)
+        elif TimeUnit.MINUTE.equals(self):
+            return timedelta(minutes=interval)
+        elif TimeUnit.HOUR.equals(self):
+            return timedelta(hours=interval)
+        elif TimeUnit.DAY.equals(self):
+            return timedelta(days=interval)
+
+        raise ValueError(f"Unsupported time unit: {self}")
+
+    @property
+    def single_name(self):
+
+        if TimeUnit.SECOND.equals(self.value):
+            return "second"
+
+        if TimeUnit.MINUTE.equals(self.value):
+            return "minute"
+
+        if TimeUnit.HOUR.equals(self.value):
+            return "hour"
+
+        if TimeUnit.DAY.equals(self.value):
+            return "day"
+
+    @property
+    def plural_name(self):
+
+        if TimeUnit.SECOND.equals(self.value):
+            return "seconds"
+
+        if TimeUnit.MINUTE.equals(self.value):
+            return "minutes"
+
+        if TimeUnit.HOUR.equals(self.value):
+            return "hours"
+
+        if TimeUnit.DAY.equals(self.value):
+            return "days"
+
+    @property
+    def amount_of_minutes(self):
+        if TimeUnit.SECOND.equals(self):
+            return 1 / 60
+
+        if TimeUnit.MINUTE.equals(self):
+            return 1
+
+        if TimeUnit.HOUR.equals(self):
+            return 60
+
+        if TimeUnit.DAY.equals(self):
+            return 60 * 24
+
+        raise ValueError(f"Unsupported time unit: {self}")

investing_algorithm_framework/domain/models/tracing/trace.py

@@ -0,0 +1,23 @@
+class Trace:
+    """
+    Represents a trace of a trading strategy. A trace contains
+    data that has been generated by a trading strategy during its
+    execution.
+
+    The data can be used to analyze the performance of the trading after
+    it has been executed. Usually, the data contains metrics that
+    have been generated by the trading strategy during its execution,
+    and the signals that have been generated.
+    """
+
+    def __init__(
+        self,
+        strategy_id: str,
+        symbol: str,
+        data,
+        drop_duplicates=True
+    ):
+        self.strategy_id = strategy_id
+        self.symbol = symbol
+        self.data = data
+        self.drop_duplicates = drop_duplicates

investing_algorithm_framework/domain/models/trade/__init__.py

@@ -0,0 +1,13 @@
+from .trade import Trade
+from .trade_status import TradeStatus
+from .trade_stop_loss import TradeStopLoss
+from .trade_take_profit import TradeTakeProfit
+from .trade_risk_type import TradeRiskType
+
+__all__ = [
+    "Trade",
+    "TradeStatus",
+    "TradeStopLoss",
+    "TradeTakeProfit",
+    "TradeRiskType",
+]

investing_algorithm_framework/domain/models/trade/trade.py

@@ -0,0 +1,388 @@
+from dateutil.parser import parse
+from datetime import timezone
+
+from investing_algorithm_framework.domain.models.base_model import BaseModel
+from investing_algorithm_framework.domain.models.order import OrderSide, Order
+from investing_algorithm_framework.domain.models.trade.trade_status import \
+    TradeStatus
+from investing_algorithm_framework.domain.models.trade.trade_stop_loss import \
+    TradeStopLoss
+from investing_algorithm_framework.domain.models.trade\
+    .trade_take_profit import TradeTakeProfit
+
+
+class Trade(BaseModel):
+    """
+    Trade model
+
+    A trade is a combination of a buy and sell order that has been opened or
+    closed.
+
+    A trade is considered opened when a buy order is executed and there is
+    no corresponding sell order. A trade is considered closed when a sell
+    order is executed and the amount of the sell order is equal or larger
+    to the amount of the buy order.
+
+    A single sell order can close multiple buy orders. Also, a single
+    buy order can be closed by multiple sell orders.
+
+    Attributes:
+        orders: str, the id of the buy order
+        target_symbol: str, the target symbol of the trade
+        trading_symbol: str, the trading symbol of the trade
+        closed_at: datetime, the datetime when the trade was closed
+        amount: float, the amount of the trade
+        available_amount: float, the available amount of the trade
+        remaining: float, the remaining amount that is not filled by the
+            buy order that opened the trade.
+        filled_amount: float, the filled amount of the trade by the buy
+            order that opened the trade.
+        net_gain: float, the net gain of the trade
+        last_reported_price: float, the last reported price of the trade
+        last_reported_price_datetime: datetime, the datetime when the last
+            reported price was reported
+        updated_at: datetime, the datetime when the trade was last updated
+        status: str, the status of the trade
+        metadata: dict, the metadata of the trade, this can be used to store
+            additional information about the trade.
+    """
+
+    def __init__(
+        self,
+        id,
+        orders,
+        target_symbol,
+        trading_symbol,
+        closed_at,
+        opened_at,
+        open_price,
+        amount,
+        available_amount,
+        cost,
+        remaining,
+        filled_amount,
+        status,
+        net_gain=0,
+        last_reported_price=None,
+        last_reported_price_datetime=None,
+        high_water_mark=None,
+        high_water_mark_datetime=None,
+        updated_at=None,
+        stop_losses=None,
+        take_profits=None,
+        metadata=None,
+    ):
+        self.id = id
+        self.orders = orders
+        self.target_symbol = target_symbol
+        self.trading_symbol = trading_symbol
+        self.closed_at = closed_at
+        self.opened_at = opened_at
+        self.open_price = open_price
+        self.amount = amount
+        self.available_amount = available_amount
+        self.cost = cost
+        self.remaining = remaining
+        self.filled_amount = filled_amount
+        self.net_gain = net_gain
+        self.last_reported_price = last_reported_price
+        self.last_reported_price_datetime = last_reported_price_datetime
+        self.high_water_mark = high_water_mark
+        self.high_water_mark_datetime = high_water_mark_datetime
+        self.status = TradeStatus.from_value(status).value
+        self.updated_at = updated_at
+        self.stop_losses = stop_losses
+        self.take_profits = take_profits
+        self.metadata = metadata if metadata is not None else {}
+
+    def update(self, data):
+
+        if "status" in data:
+            self.status = TradeStatus.from_value(data["status"]).value
+
+            if TradeStatus.CLOSED.equals(self.status):
+
+                # Set all stop losses to inactive
+                if self.stop_losses is not None:
+                    for stop_loss in self.stop_losses:
+                        stop_loss.active = False
+
+                # set all take profits to inactive
+                if self.take_profits is not None:
+                    for take_profit in self.take_profits:
+                        take_profit.active = False
+
+        if "last_reported_price" in data:
+            self.last_reported_price = data["last_reported_price"]
+
+            if self.high_water_mark is None:
+                self.high_water_mark = data["last_reported_price"]
+                self.high_water_mark_datetime = \
+                    data["last_reported_price_datetime"]
+            else:
+
+                if data["last_reported_price"] > self.high_water_mark:
+                    self.high_water_mark = data["last_reported_price"]
+                    self.high_water_mark_datetime = \
+                        data["last_reported_price_datetime"]
+
+        return super().update(data)
+
+    @property
+    def closed_prices(self):
+        return [
+            order.price for order in self.orders
+            if order.order_side == OrderSide.SELL.value
+        ]
+
+    @property
+    def buy_order(self):
+
+        if self.orders is None:
+            return
+
+        return [
+            order for order in self.orders
+            if order.order_side == OrderSide.BUY.value
+        ][0]
+
+    @property
+    def symbol(self):
+        return f"{self.target_symbol.upper()}/{self.trading_symbol.upper()}"
+
+    @property
+    def duration(self):
+        """
+        Calculate the duration of the trade in hours.
+
+        Returns:
+            float: The duration of the trade in hours.
+        """
+        if TradeStatus.CLOSED.equals(self.status):
+            # Get the total hours between the closed and opened datetime
+            diff = self.closed_at - self.opened_at
+            return diff.total_seconds() / 3600
+
+        if self.opened_at is None:
+            return None
+
+        if self.updated_at is None:
+            return None
+
+        diff = self.updated_at - self.opened_at
+        return diff.total_seconds() / 3600
+
+    @property
+    def size(self):
+        return self.amount * self.open_price
+
+    @property
+    def change(self):
+        """
+        Property to calculate the change in value of the trade.
+
+        This is the difference between the current value of the trade
+        and the cost of the trade.
+        """
+        if TradeStatus.CLOSED.equals(self.status):
+            return self.net_gain
+
+        if self.last_reported_price is None:
+            return 0
+
+        if self.remaining is None or self.remaining == 0:
+            amount = self.amount
+        else:
+            amount = self.amount - self.remaining
+
+        cost = amount * self.open_price
+        gain = (amount * self.last_reported_price) - cost
+        return gain
+
+    @property
+    def net_gain_absolute(self):
+
+        if TradeStatus.CLOSED.equals(self.status):
+            return self.net_gain
+        else:
+            gain = 0
+
+            if self.last_reported_price is not None:
+                gain = (
+                    self.available_amount *
+                    (self.last_reported_price - self.open_price)
+                )
+
+            gain += self.net_gain
+            return gain
+
+    @property
+    def net_gain_percentage(self):
+
+        if TradeStatus.CLOSED.equals(self.status):
+
+            if self.cost != 0:
+                return (self.net_gain / self.cost) * 100
+
+        else:
+            gain = 0
+
+            if self.last_reported_price is not None:
+                gain = (
+                    self.available_amount *
+                    (self.last_reported_price - self.open_price)
+                )
+
+            gain += self.net_gain
+
+            if self.cost != 0:
+                return (gain / self.cost) * 100
+
+        return 0
+
+    @property
+    def percentage_change(self):
+
+        if TradeStatus.CLOSED.equals(self.status):
+
+            if self.cost != 0:
+                return (self.net_gain / self.cost) * 100
+
+        if self.last_reported_price is None:
+            return 0
+
+        cost = self.available_amount * self.open_price
+        gain = (self.available_amount * self.last_reported_price) - cost
+        gain += self.net_gain
+
+        if cost != 0:
+            return (gain / cost) * 100
+
+        return 0
+
+    def to_dict(self, datetime_format=None):
+        def ensure_iso(value):
+            if hasattr(value, "isoformat"):
+                if value.tzinfo is None:
+                    value = value.replace(tzinfo=timezone.utc)
+                return value.isoformat()
+            return value
+
+        opened_at = ensure_iso(self.opened_at) if self.opened_at else None
+        closed_at = ensure_iso(self.closed_at) if self.closed_at else None
+        updated_at = ensure_iso(self.updated_at) if self.updated_at else None
+
+        # Ensure status is a string
+        self.status = TradeStatus.from_value(self.status).value
+
+        return {
+            "id": self.id,
+            "orders": [
+                order.to_dict(datetime_format=datetime_format)
+                for order in self.orders
+            ],
+            "target_symbol": self.target_symbol,
+            "trading_symbol": self.trading_symbol,
+            "status": self.status,
+            "amount": self.amount,
+            "remaining": self.remaining if self.remaining is not None else 0,
+            "open_price": self.open_price,
+            "last_reported_price": self.last_reported_price,
+            "opened_at": opened_at,
+            "closed_at": closed_at,
+            "updated_at": updated_at,
+            "net_gain": self.net_gain if self.net_gain is not None else 0,
+            "cost": self.cost if self.cost is not None else 0,
+            "stop_losses": [
+                stop_loss.to_dict(datetime_format=datetime_format)
+                for stop_loss in self.stop_losses
+            ] if self.stop_losses else None,
+            "take_profits": [
+                take_profit.to_dict(datetime_format=datetime_format)
+                for take_profit in self.take_profits
+            ] if self.take_profits else None,
+            "filled_amount": self.filled_amount,
+            "available_amount": self.available_amount,
+            "metadata": self.metadata if self.metadata else {},
+        }
+
+    @staticmethod
+    def from_dict(data):
+        opened_at = None
+        closed_at = None
+        updated_at = None
+        stop_losses = None
+        take_profits = None
+        orders = None
+
+        if "opened_at" in data and data["opened_at"] is not None:
+            opened_at = parse(data["opened_at"])
+
+        if "closed_at" in data and data["closed_at"] is not None:
+            closed_at = parse(data["closed_at"])
+
+        if "updated_at" in data and data["updated_at"] is not None:
+            updated_at = parse(data["updated_at"])
+
+        if "stop_losses" in data and data["stop_losses"] is not None:
+            stop_losses = [
+                TradeStopLoss.from_dict(stop_loss)
+                for stop_loss in data["stop_losses"]
+            ]
+
+        if "take_profits" in data and data["take_profits"] is not None:
+            take_profits = [
+                TradeTakeProfit.from_dict(take_profit)
+                for take_profit in data["take_profits"]
+            ]
+
+        if "orders" in data and data["orders"] is not None:
+            orders = [
+                Order.from_dict(order)
+                for order in data["orders"]
+            ]
+        return Trade(
+            id=data.get("id", None),
+            orders=orders,
+            target_symbol=data["target_symbol"],
+            trading_symbol=data["trading_symbol"],
+            amount=data["amount"],
+            open_price=data["open_price"],
+            opened_at=opened_at,
+            closed_at=closed_at,
+            filled_amount=data.get("filled_amount", 0),
+            available_amount=data.get("available_amount", 0),
+            remaining=data.get("remaining", 0),
+            net_gain=data.get("net_gain", 0),
+            last_reported_price=data.get("last_reported_price"),
+            status=TradeStatus.from_value(data["status"]).value,
+            cost=data.get("cost", 0),
+            updated_at=updated_at,
+            stop_losses=stop_losses,
+            take_profits=take_profits,
+            metadata=data.get("metadata", {}),
+        )
+
+    def __repr__(self):
+        return self.repr(
+            id=self.id,
+            symbol=self.symbol,
+            target_symbol=self.target_symbol,
+            trading_symbol=self.trading_symbol,
+            status=self.status,
+            amount=self.amount,
+            available_amount=self.available_amount,
+            filled_amount=self.filled_amount,
+            remaining=self.remaining,
+            open_price=self.open_price,
+            opened_at=self.opened_at,
+            closed_at=self.closed_at,
+            net_gain=self.net_gain,
+            last_reported_price=self.last_reported_price,
+            updated_at=self.updated_at,
+            metadata=self.metadata,
+        )
+
+    def __lt__(self, other):
+        # Define the less-than comparison based on created_at attribute
+        return self.opened_at < other.opened_at