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

investing_algorithm_framework/domain/models/market_data/ticker.py

@@ -1,92 +0,0 @@
-from datetime import datetime
-
-
-class Ticker:
-
-    def __init__(
-            self,
-            symbol,
-            price,
-            ask_price=None,
-            ask_volume=None,
-            bid_price=None,
-            bid_volume=None,
-            high_price=None,
-            low_price=None,
-            creation_date=None
-    ):
-        self.symbol = symbol
-        self.price = price
-        self.ask_price = ask_price
-        self.ask_volume = ask_volume
-        self.bid_price = bid_price
-        self.bid_volume = bid_volume
-        self.high_price = high_price
-        self.low_price = low_price
-
-        if creation_date is None:
-            self.creation_date = datetime.now()
-
-    def get_price(self):
-        return self.price
-
-    def get_creation_date(self):
-        return self.creation_date
-
-    def get_symbol(self):
-        return self.symbol
-
-    def to_dict(self):
-        return {
-            "symbol": self.symbol,
-            "price": self.price,
-            "ask_price": self.ask_price,
-            "ask_volume": self.ask_volume,
-            "bid_price": self.bid_price,
-            "bid_volume": self.bid_volume,
-            "high_price": self.high_price,
-            "low_price": self.low_price
-        }
-
-    @staticmethod
-    def from_dict(data):
-        return Ticker(
-            symbol=data.get("symbol"),
-            price=data.get("price"),
-            ask_price=data.get("ask_price"),
-            ask_volume=data.get("ask_volume"),
-            bid_price=data.get("bid_price"),
-            bid_volume=data.get("bid_volume"),
-            high_price=data.get("high_price"),
-            low_price=data.get("low_price"),
-            creation_date=data.get("creation_date")
-        )
-
-    def repr(self, **fields) -> str:
-        """
-        Helper for __repr__
-        """
-
-        field_strings = []
-        at_least_one_attached_attribute = False
-
-        for key, field in fields.items():
-            field_strings.append(f'{key}={field!r}')
-            at_least_one_attached_attribute = True
-
-        if at_least_one_attached_attribute:
-            return f"<{self.__class__.__name__}({','.join(field_strings)})>"
-
-        return f"<{self.__class__.__name__} {id(self)}>"
-
-    def __repr__(self):
-        return self.repr(
-            symbol=self.symbol,
-            price=self.price,
-            ask_price=self.ask_price,
-            ask_volume=self.ask_volume,
-            bid_price=self.bid_price,
-            bid_volume=self.bid_volume,
-            high_price=self.high_price,
-            low_price=self.low_price
-        )

investing_algorithm_framework/domain/models/order/order_fee.py

@@ -1,45 +0,0 @@
-from investing_algorithm_framework.domain.models.base_model import BaseModel
-
-
-class OrderFee(BaseModel):
-    def __init__(self, currency, cost, rate):
-        self.currency = currency
-        self.cost = cost
-        self.rate = rate
-
-    def get_currency(self):
-        return self.currency
-
-    def set_currency(self, currency):
-        self.currency = currency
-
-    def get_cost(self):
-        return self.cost
-
-    def set_cost(self, cost):
-        self.cost = cost
-
-    def get_rate(self):
-        return self.rate
-
-    @staticmethod
-    def from_ccxt_fee(ccxt_fee):
-        return OrderFee(
-            currency=ccxt_fee.get('currency'),
-            cost=ccxt_fee.get('cost'),
-            rate=ccxt_fee.get('rate'),
-        )
-
-    def to_dict(self):
-        return {
-            "currency": self.currency,
-            "cost": self.cost,
-            "rate": self.rate
-        }
-
-    def __repr__(self):
-        return self.repr(
-            currency=self.get_currency(),
-            cost=self.get_cost(),
-            rate=self.get_rate(),
-        )

investing_algorithm_framework/domain/models/trade.py

@@ -1,78 +0,0 @@
-from investing_algorithm_framework.domain.models.base_model import BaseModel
-
-
-class Trade(BaseModel):
-
-    def __init__(
-        self,
-        target_symbol,
-        trading_symbol,
-        amount,
-        open_price,
-        closed_price,
-        closed_at,
-        opened_at
-    ):
-        self._target_symbol = target_symbol
-        self._trading_symbol = trading_symbol
-        self._amount = amount
-        self._open_price = open_price
-        self._closed_price = closed_price
-        self._closed_at = closed_at
-        self._opened_at = opened_at
-        self._trading_symbol = trading_symbol
-
-    @property
-    def target_symbol(self):
-        return self._target_symbol
-
-    @property
-    def trading_symbol(self):
-        return self._trading_symbol
-
-    @property
-    def amount(self):
-        return self._amount
-
-    @property
-    def open_price(self):
-        return self._open_price
-
-    @property
-    def closed_price(self):
-        return self._closed_price
-
-    @property
-    def closed_at(self):
-        return self._closed_at
-
-    @property
-    def opened_at(self):
-        return self._opened_at
-
-    @property
-    def size(self):
-        return self.amount * self.open_price
-
-    @property
-    def net_gain(self):
-        return self.amount * (self.closed_price - self.open_price)
-
-    @property
-    def net_gain_percentage(self):
-        return self.net_gain / self.size * 100
-
-    @property
-    def duration(self):
-        return (self.closed_at - self.opened_at).total_seconds() / 3600
-
-    def __repr__(self):
-        return self.repr(
-            target_symbol=self.target_symbol,
-            trading_symbol=self.trading_symbol,
-            amount=self.amount,
-            open_price=self.open_price,
-            closed_price=self.closed_price,
-            opened_at=self.opened_at,
-            closed_at=self.closed_at,
-        )

investing_algorithm_framework/domain/models/trading_data_types.py

@@ -1,47 +0,0 @@
-from enum import Enum
-
-
-class TradingDataType(Enum):
-    TICKER = 'TICKER'
-    ORDER_BOOK = 'ORDER_BOOK'
-    OHLCV = "OHLCV"
-
-    @staticmethod
-    def from_value(value):
-
-        if isinstance(value, TradingDataType):
-            for trading_data_type in TradingDataType:
-
-                if value == trading_data_type:
-                    return trading_data_type
-
-        elif isinstance(value, str):
-            return TradingDataType.from_string(value)
-
-        raise ValueError(
-            "Could not convert value to trading data type"
-        )
-
-    @staticmethod
-    def from_string(value: str):
-
-        if isinstance(value, str):
-            for order_type in TradingDataType:
-
-                if value.upper() == order_type.value:
-                    return order_type
-
-        raise ValueError(
-            "Could not convert value to trading data type"
-        )
-
-    def equals(self, other):
-
-        if other is None:
-            return False
-
-        if isinstance(other, Enum):
-            return self.value == other.value
-
-        else:
-            return TradingDataType.from_string(other) == self

investing_algorithm_framework/domain/models/trading_time_frame.py

@@ -1,223 +0,0 @@
-from enum import Enum
-from datetime import timedelta, datetime
-
-from investing_algorithm_framework.domain.exceptions import \
-    OperationalException
-
-
-class TradingTimeFrame(Enum):
-    ONE_MINUTE = "ONE_MINUTE"
-    FIFTEEN_MINUTE = "FIFTEEN_MINUTE"
-    ONE_HOUR = "ONE_HOUR"
-    TWO_HOUR = "TWO_HOUR"
-    ONE_DAY = 'ONE_DAY'
-    ONE_MONTH = "ONE_MONTH"
-    ONE_YEAR = "ONE_YEAR"
-
-    def create_time_frame_from_limit(self, limit: int = 50):
-
-        if TradingTimeFrame.ONE_MINUTE.equals(self):
-            hold = 1
-            start_date = datetime.now() - timedelta(minutes=limit)
-        elif TradingTimeFrame.FIFTEEN_MINUTE.equals(self):
-            hold = 15
-            start_date = datetime.now() - timedelta(minutes=(limit * 15))
-        elif TradingTimeFrame.ONE_HOUR.equals(self):
-            hold = 60
-            start_date = datetime.now() - timedelta(hours=limit)
-        elif TradingTimeFrame.TWO_HOUR.equals(self):
-            hold = 60 * 2
-            start_date = datetime.now() - timedelta(hours=limit)
-        elif TradingTimeFrame.ONE_DAY.equals(self):
-            hold = 60 * 24
-            start_date = datetime.now() - timedelta(days=limit)
-        elif TradingTimeFrame.ONE_MONTH.equals(self):
-            hold = 60 * 24 * 30
-            start_date = datetime.now() - timedelta(weeks=(4 * limit))
-        else:
-            hold = 60 * 24 * 365
-            start_date = datetime.now() - timedelta(days=(limit * 365))
-
-        iteration = 1
-        dates = []
-        while iteration < limit or \
-                start_date + timedelta(minutes=hold) < datetime.now():
-            dates.append(start_date + timedelta(minutes=hold))
-            start_date += timedelta(minutes=hold)
-            iteration += 1
-
-        dates.append(datetime.now())
-        return dates
-
-    def create_time_frame_from_start_date(self, start_date: datetime):
-
-        if start_date > datetime.now():
-            raise OperationalException("Start date cannot be in the future")
-
-        if TradingTimeFrame.ONE_MINUTE.equals(self):
-            hold = 1
-        elif TradingTimeFrame.FIFTEEN_MINUTE.equals(self):
-            hold = 15
-        elif TradingTimeFrame.ONE_HOUR.equals(self):
-            hold = 60
-        elif TradingTimeFrame.TWO_HOUR.equals(self):
-            hold = 60 * 2
-        elif TradingTimeFrame.ONE_DAY.equals(self):
-            hold = 60 * 24
-        elif TradingTimeFrame.ONE_MONTH.equals(self):
-            hold = 60 * 24 * 30
-        else:
-            hold = 60 * 24 * 365
-
-        iteration = 1
-        dates = []
-
-        while start_date < datetime.now():
-            dates.append(start_date + timedelta(minutes=hold))
-            start_date += timedelta(minutes=hold)
-            iteration += 1
-
-        dates.append(datetime.now())
-        return dates
-
-    def to_ccxt_string(self):
-
-        if TradingTimeFrame.ONE_MINUTE.equals(self):
-            return "1m"
-
-        if TradingTimeFrame.FIFTEEN_MINUTE.equals(self):
-            return "15m"
-
-        if TradingTimeFrame.ONE_HOUR.equals(self):
-            return "1h"
-
-        if TradingTimeFrame.TWO_HOUR.equals(self):
-            return "2h"
-
-        if TradingTimeFrame.ONE_DAY.equals(self):
-            return "1d"
-
-        if TradingTimeFrame.ONE_MONTH.equals(self):
-            return "1m"
-
-        if TradingTimeFrame.ONE_YEAR.equals(self):
-            return "1y"
-
-        raise OperationalException("Data time unit value is not supported")
-
-    @staticmethod
-    def from_value(value):
-
-        if isinstance(value, TradingTimeFrame):
-            for data_time_unit in TradingTimeFrame:
-
-                if value == data_time_unit:
-                    return data_time_unit
-
-        elif isinstance(value, str):
-            return TradingTimeFrame.from_string(value)
-
-        raise ValueError(
-            "Could not convert value to data time unit"
-        )
-
-    @staticmethod
-    def from_string(value: str):
-
-        if isinstance(value, str):
-            for data_time_unit in TradingTimeFrame:
-
-                if value.upper() == data_time_unit.value:
-                    return data_time_unit
-
-        raise ValueError(
-            "Could not convert value to data time unit"
-        )
-
-    def equals(self, other):
-
-        if other is None:
-            return False
-
-        if isinstance(other, Enum):
-            return self.value == other.value
-
-        else:
-            return TradingTimeFrame.from_string(other) == self
-
-    def create_start_date(self, limit=50):
-
-        if TradingTimeFrame.ONE_MINUTE.equals(self):
-            return datetime.now() - timedelta(minutes=limit)
-
-        if TradingTimeFrame.FIFTEEN_MINUTE.equals(self):
-            return datetime.now() - timedelta(minutes=(limit * 15))
-
-        if TradingTimeFrame.ONE_HOUR.equals(self):
-            return datetime.now() - timedelta(hours=limit)
-
-        if TradingTimeFrame.TWO_HOUR.equals(self):
-            return datetime.now() - timedelta(hours=limit * 2)
-
-        if TradingTimeFrame.ONE_DAY.equals(self):
-            return datetime.now() - timedelta(days=limit)
-
-        if TradingTimeFrame.ONE_MONTH.equals(self):
-            return datetime.now() - timedelta(weeks=(4 * limit))
-
-        if TradingTimeFrame.ONE_YEAR.equals(self):
-            return datetime.now() - timedelta(days=(limit * 365))
-
-        raise OperationalException("Data time unit value is not supported")
-
-    @property
-    def minutes(self):
-
-        if TradingTimeFrame.ONE_MINUTE.equals(self):
-            return 1
-
-        if TradingTimeFrame.FIFTEEN_MINUTE.equals(self):
-            return 15
-
-        if TradingTimeFrame.ONE_HOUR.equals(self):
-            return 60
-
-        if TradingTimeFrame.TWO_HOUR.equals(self):
-            return 120
-
-        if TradingTimeFrame.ONE_DAY.equals(self):
-            return 60 * 24
-
-        if TradingTimeFrame.ONE_MONTH.equals(self):
-            return 60 * 24 * 30
-
-        if TradingTimeFrame.ONE_YEAR.equals(self):
-            return 60 * 24 * 365
-
-        raise OperationalException("Data time frame value is not supported")
-
-    @property
-    def milliseconds(self):
-
-        if TradingTimeFrame.ONE_MINUTE.equals(self):
-            return 60 * 1000
-
-        if TradingTimeFrame.FIFTEEN_MINUTE.equals(self):
-            return 15 * 60 * 1000
-
-        if TradingTimeFrame.ONE_HOUR.equals(self):
-            return 60 * 60 * 1000
-
-        if TradingTimeFrame.TWO_HOUR.equals(self):
-            return 2* 60 * 60 * 1000
-
-        if TradingTimeFrame.ONE_DAY.equals(self):
-            return 60 * 60 * 24 * 1000
-
-        if TradingTimeFrame.ONE_MONTH.equals(self):
-            return 60 * 60 * 24 * 30 * 1000
-
-        if TradingTimeFrame.ONE_YEAR.equals(self):
-            return 60 * 60 * 24 * 365 * 1000
-
-        raise OperationalException("Data time frame value is not supported")

investing_algorithm_framework/domain/singleton.py

@@ -1,9 +0,0 @@
-class Singleton(type):
-    _instances = {}
-
-    def __call__(cls, *args, **kwargs):
-        if cls not in cls._instances:
-            cls._instances[cls] = \
-                super(Singleton, cls).__call__(*args, **kwargs)
-
-        return cls._instances[cls]

investing_algorithm_framework/domain/utils/backtesting.py

@@ -1,82 +0,0 @@
-
-
-def print_number_of_runs(report):
-
-    if report.number_of_runs == 1:
-
-        if report.inteval > 1:
-            print(f"Strategy ran every {report.interval} {report.time_unit} for a total of {report.number_of_runs} time")
-
-
-def pretty_print_backtest(backtest_report, show_positions=True, show_trades=True, precision=4):
-    print("====================Backtest report===============================")
-    print(f"* Start date: {backtest_report.backtest_start_date}")
-    print(f"* End date: {backtest_report.backtest_end_date}")
-    print(f"* Number of days: {backtest_report.number_of_days}")
-    print(f"* Number of runs: {backtest_report.number_of_runs}")
-    print("====================Portfolio overview============================")
-    print(f"* Number of orders: {backtest_report.number_of_orders}")
-    print(f"* Initial balance: "
-          f"{backtest_report.initial_unallocated:.{precision}f} "
-          f"{backtest_report.trading_symbol}")
-    print(f"* Final balance: {backtest_report.total_value:.{precision}f} "
-          f"{backtest_report.trading_symbol}")
-    print(f"* Total net gain: {backtest_report.total_net_gain:.{precision}f} "
-          f"{backtest_report.trading_symbol}")
-    print(f"* Total net gain percentage: "
-          f"{backtest_report.total_net_gain_percentage:.{precision}f}%")
-    print(f"* Growth rate: "
-          f"{float(backtest_report.growth_rate):.{precision}f}%")
-    print(f"* Growth {backtest_report.growth:.{precision}f} "
-          f"{backtest_report.trading_symbol}")
-
-    if show_positions:
-        print("====================Positions overview========================")
-        print(f"* Number of positions at the end of backtest: {backtest_report.number_of_positions}")
-        print(f"* Total cost of current positions: "
-              f"{backtest_report.total_cost:.{precision}f} "
-              f"{backtest_report.trading_symbol}")
-        for position in backtest_report.positions:
-            print(
-                f"{position.symbol}, "
-                f"amount: {position.amount:.{precision}f}, "
-                f"cost: {position.cost:.{precision}f} "
-                f"{backtest_report.trading_symbol}, "
-                f"value: {position.value:.{precision}f} "
-                f"{backtest_report.trading_symbol}, "
-                f"growth: {position.growth:.{precision}f} "
-                f"{backtest_report.trading_symbol} "
-                f"({position.growth_rate:.{precision}f}%)."
-            )
-
-    if show_trades:
-        print("====================Trades overview===========================")
-        print(f"* Number of trades closed: "
-              f"{backtest_report.number_of_trades_closed}")
-        print(
-            f"* Number of trades open: "
-            f"{backtest_report.number_of_trades_open}"
-        )
-        print(f"* Percentage of positive trades: "
-              f"{backtest_report.percentage_positive_trades}%")
-        print(f"* Percentage of negative trades: "
-              f"{backtest_report.percentage_negative_trades}%")
-        print(f"* Average trade size: "
-              f"{backtest_report.average_trade_size:.{precision}f} "
-              f"{backtest_report.trading_symbol}")
-        print(f"* Average trade duration: "
-              f"{backtest_report.average_trade_duration} hours")
-        for trade in backtest_report.trades:
-            print(
-                f"{trade.target_symbol} -> {trade.trading_symbol}, "
-                f"open date: {trade.opened_at}, "
-                f"close date: {trade.closed_at}, "
-                f"size: {trade.size:.{precision}f} {trade.trading_symbol}, "
-                f"net gain: {trade.net_gain:.{precision}f}, "
-                f"net gain percentage: "
-                f"{trade.net_gain_percentage:.{precision}f}%, "
-                f"duration: {trade.duration} hours, "
-                f"open price: {trade.open_price}, "
-                f"close price: {trade.closed_price}"
-            )
-    print("==================================================================")

investing_algorithm_framework/infrastructure/models/order/order_fee.py

@@ -1,21 +0,0 @@
-from sqlalchemy import Column, Integer, String, ForeignKey, Float
-from sqlalchemy.orm import relationship
-
-from investing_algorithm_framework.domain import OrderFee
-from investing_algorithm_framework.infrastructure.database import SQLBaseModel
-from investing_algorithm_framework.infrastructure.models.model_extension \
-    import SQLAlchemyModelExtension
-
-
-class SQLOrderFee(OrderFee, SQLBaseModel, SQLAlchemyModelExtension):
-    __tablename__ = "order_fees"
-    id = Column(Integer, primary_key=True, unique=True)
-    currency = Column(String)
-    cost = Column(Float)
-    rate = Column(Float)
-    order_id = Column(Integer, ForeignKey('orders.id'))
-    order = relationship("SQLOrder", back_populates="fee")
-
-    def __init__(self, currency, cost, rate, order_id):
-        super().__init__(currency, cost, rate)
-        self.order_id = order_id

investing_algorithm_framework/infrastructure/repositories/order_fee_repository.py

@@ -1,15 +0,0 @@
-from investing_algorithm_framework.infrastructure.models import SQLOrderFee
-from .repository import Repository
-
-
-class SQLOrderFeeRepository(Repository):
-    base_class = SQLOrderFee
-    DEFAULT_NOT_FOUND_MESSAGE = "Order fee not found"
-
-    def _apply_query_params(self, db, query, query_params):
-        order_query_param = self.get_query_param("order", query_params)
-
-        if order_query_param:
-            query = query.filter_by(order_id=order_query_param)
-
-        return query