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

investing_algorithm_framework/infrastructure/database/sql_alchemy.py

@@ -1,6 +1,7 @@
 import logging
 
 from sqlalchemy import create_engine, StaticPool
+from sqlalchemy import inspect
 from sqlalchemy.orm import DeclarativeBase, sessionmaker
 
 from investing_algorithm_framework.domain import SQLALCHEMY_DATABASE_URI, \
@@ -38,9 +39,89 @@ def setup_sqlalchemy(app, throw_exception_if_not_set=True):
     return app
 
 
+
 class SQLBaseModel(DeclarativeBase):
     pass
 
 
 def create_all_tables():
     SQLBaseModel.metadata.create_all(bind=Session().bind)
+
+
+from sqlalchemy import event
+from sqlalchemy.orm import mapper
+from datetime import timezone
+
+def clear_db(db_uri):
+    """
+    Clear the database by dropping all tables.
+    This is useful for testing purposes.
+
+    Args:
+        db_uri (str): The database URI to connect to.
+
+    Returns:
+        None
+    """
+    # Drop all tables before deleting file
+    try:
+        engine = create_engine(db_uri)
+        inspector = inspect(engine)
+        if inspector.get_table_names():
+            logger.info("Dropping all tables in backtest database")
+            SQLBaseModel.metadata.drop_all(bind=engine)
+    except Exception as e:
+        logger.error(f"Error dropping tables: {e}")
+
+    # # Clear mappers (if using classical mappings)
+    # try:
+    #     clear_mappers()
+    # except Exception:
+    #     pass  # ignore if not needed
+
+
+@event.listens_for(mapper, "load")
+def attach_utc_timezone_on_load(target, context):
+    """
+    For each model instance loaded from the database,
+    this function will check if one of the following attributes are
+    present: created_at, updated_at, closed_at, opened_at, triggered_at.
+    If so, it will check if these datetime
+    attributes are timezone-naive and, if so, will set them to UTC.
+
+    Its documented in the contributing guide (https://coding-kitties.github
+    .io/investing-algorithm-framework/Contributing%20Guide/contributing)
+    that each datetime attribute should be utc timezone-aware.
+
+    Args:
+        target: The model instance being loaded from the database.
+        context: The context in which the event is being handled.
+
+    Returns:
+        None
+    """
+    # This will apply to every model instance loaded from the DB
+    if hasattr(target, "created_at"):
+        dt = getattr(target, "created_at")
+        if dt and dt.tzinfo is None:
+            target.created_at = dt.replace(tzinfo=timezone.utc)
+
+    if hasattr(target, "updated_at"):
+        dt = getattr(target, "updated_at")
+        if dt and dt.tzinfo is None:
+            target.updated_at = dt.replace(tzinfo=timezone.utc)
+
+    if hasattr(target, "closed_at"):
+        dt = getattr(target, "closed_at")
+        if dt and dt.tzinfo is None:
+            target.closed_at = dt.replace(tzinfo=timezone.utc)
+
+    if hasattr(target, "opened_at"):
+        dt = getattr(target, "opened_at")
+        if dt and dt.tzinfo is None:
+            target.opened_at = dt.replace(tzinfo=timezone.utc)
+
+    if hasattr(target, "triggered_at"):
+        dt = getattr(target, "triggered_at")
+        if dt and dt.tzinfo is None:
+            target.triggered_at = dt.replace(tzinfo=timezone.utc)

investing_algorithm_framework/infrastructure/models/__init__.py

@@ -1,8 +1,3 @@
-from .market_data_sources import CCXTOrderBookMarketDataSource, \
-    CCXTTickerMarketDataSource, CCXTOHLCVMarketDataSource, \
-    CCXTOHLCVBacktestMarketDataSource, CSVOHLCVMarketDataSource, \
-    CSVTickerMarketDataSource, PandasOHLCVBacktestMarketDataSource, \
-    PandasOHLCVMarketDataSource
 from .order import SQLOrder, SQLOrderMetadata
 from .portfolio import SQLPortfolio, SQLPortfolioSnapshot
 from .position import SQLPosition, SQLPositionSnapshot
@@ -14,16 +9,8 @@ __all__ = [
     "SQLPortfolio",
     "SQLPositionSnapshot",
     "SQLPortfolioSnapshot",
-    "CCXTOHLCVBacktestMarketDataSource",
-    "CCXTOrderBookMarketDataSource",
-    "CCXTTickerMarketDataSource",
-    "CCXTOHLCVMarketDataSource",
-    "CSVTickerMarketDataSource",
-    "CSVOHLCVMarketDataSource",
     "SQLTrade",
     "SQLTradeStopLoss",
     "SQLTradeTakeProfit",
     "SQLOrderMetadata",
-    "PandasOHLCVBacktestMarketDataSource",
-    "PandasOHLCVMarketDataSource"
 ]

investing_algorithm_framework/infrastructure/models/order/order.py

@@ -1,5 +1,5 @@
 import logging
-from datetime import datetime
+from datetime import datetime, timezone
 
 from sqlalchemy import Column, Integer, String, DateTime, ForeignKey, Float
 from sqlalchemy.orm import relationship
@@ -15,6 +15,10 @@ from investing_algorithm_framework.infrastructure.models.\
 logger = logging.getLogger("investing_algorithm_framework")
 
 
+def utcnow():
+    return datetime.now(tz=timezone.utc)
+
+
 class SQLOrder(Order, SQLBaseModel, SQLAlchemyModelExtension):
     """
     SQLOrder model based on the Order domain model.
@@ -37,8 +41,10 @@ class SQLOrder(Order, SQLBaseModel, SQLAlchemyModelExtension):
     status = Column(String, default=OrderStatus.CREATED.value)
     position_id = Column(Integer, ForeignKey('positions.id'))
     position = relationship("SQLPosition", back_populates="orders")
-    created_at = Column(DateTime, default=datetime.utcnow)
-    updated_at = Column(DateTime, default=datetime.utcnow)
+    created_at = Column(DateTime(timezone=True), default=utcnow)
+    updated_at = Column(
+        DateTime(timezone=True), default=utcnow, onupdate=utcnow
+    )
     order_fee = Column(Float, default=None)
     order_fee_currency = Column(String, default=None)
     order_fee_rate = Column(Float, default=None)

investing_algorithm_framework/infrastructure/models/trades/trade_stop_loss.py

@@ -1,4 +1,5 @@
-from sqlalchemy import Column, Integer, String, Float, ForeignKey, Boolean
+from sqlalchemy import Column, Integer, String, Float, ForeignKey, Boolean, \
+    DateTime
 from sqlalchemy.orm import relationship
 
 from investing_algorithm_framework.domain import TradeStopLoss
@@ -14,19 +15,33 @@ class SQLTradeStopLoss(TradeStopLoss, SQLBaseModel, SQLAlchemyModelExtension):
     A trade stop loss is a stop loss strategy for a trade.
 
     Attributes:
-    * trade: Trade - the trade that the take profit is for
-    * take_profit: float - the take profit percentage
-    * trade_risk_type: TradeRiskType - the type of trade risk, either
-        trailing or fixed
-    * sell_percentage: float - the percentage of the trade to sell when the
-
+     - trade (Trade): the trade that the take profit is for
+     - percentage (float): the stop loss percentage
+     - trailing (bool): indicates whether the stop loss is trailing
+     - sell_percentage (float) the percentage of the trade to sell
+        when the stop loss is triggered.
+    - open_price (float): the price at which the trade was opened.
+    - high_water_mark (float): the highest price reached since the trade
+        was opened.
+    - high_water_mark_date (String): the date when the high water mark
+        was reached.
+    - stop_loss_price (float): the calculated stop loss price based on
+        the high watermark and percentage.
+    - sell_prices (String): a serialized list of prices at which
+        stop losses were executed.
+    - sell_dates (String): a serialized list of dates when
+        stop losses were executed.
+    - sell_amount (float): the total amount sold due to stop losses.
+    - sold_amount (float): the total amount that has been sold due
+        to stop losses.
+    - active (bool): indicates whether the stop loss is currently active.
     """
 
     __tablename__ = "trade_stop_losses"
     id = Column(Integer, primary_key=True, unique=True)
     trade_id = Column(Integer, ForeignKey('trades.id'))
     trade = relationship('SQLTrade', back_populates='stop_losses')
-    trade_risk_type = Column(String)
+    trailing = Column(Boolean)
     percentage = Column(Float)
     sell_percentage = Column(Float)
     open_price = Column(Float)
@@ -38,3 +53,7 @@ class SQLTradeStopLoss(TradeStopLoss, SQLBaseModel, SQLAlchemyModelExtension):
     sell_amount = Column(Float)
     sold_amount = Column(Float)
     active = Column(Boolean)
+    triggered = Column(Boolean, default=False)
+    triggered_at = Column(DateTime, default=None)
+    created_at = Column(DateTime)
+    updated_at = Column(DateTime, default=None)

investing_algorithm_framework/infrastructure/models/trades/trade_take_profit.py

@@ -1,4 +1,5 @@
-from sqlalchemy import Column, Integer, String, Float, ForeignKey, Boolean
+from sqlalchemy import Column, Integer, String, Float, ForeignKey, Boolean, \
+    DateTime
 from sqlalchemy.orm import relationship
 
 from investing_algorithm_framework.domain import TradeTakeProfit
@@ -16,18 +17,27 @@ class SQLTradeTakeProfit(
     A trade take profit is a take profit strategy for a trade.
 
     Attributes:
-    * trade: Trade - the trade that the take profit is for
-    * take_profit: float - the take profit percentage
-    * trade_risk_type: TradeRiskType - the type of trade risk, either
-        trailing or fixed
-    * sell_percentage: float - the percentage of the trade to sell when the
+    - trade (Trade): the trade that the take profit is for
+    - percentage (float): the take profit percentage
+    - trailing (bool): indicates whether the take profit is trailing
+    - sell_percentage (float) the percentage of the trade to sell
+         when the take profit is triggered.
+    - target_price (float): the target price at which to take profit.
+    - sell_prices (String): a serialized list of prices at which
+            take profits were executed.
+    - sell_dates (String): a serialized list of dates when
+            take profits were executed.
+    - sell_amount (float): the total amount sold due to take profits.
+    - sold_amount (float): the total amount that has been sold due
+        to take profits.
+    - active (bool): indicates whether the take profit is currently active.
     """
 
     __tablename__ = "trade_take_profits"
     id = Column(Integer, primary_key=True, unique=True)
     trade_id = Column(Integer, ForeignKey('trades.id'))
     trade = relationship('SQLTrade', back_populates='take_profits')
-    trade_risk_type = Column(String)
+    trailing = Column(Boolean)
     percentage = Column(Float)
     sell_percentage = Column(Float)
     open_price = Column(Float)
@@ -39,3 +49,7 @@ class SQLTradeTakeProfit(
     sell_dates = Column(String)
     sold_amount = Column(Float)
     active = Column(Boolean)
+    triggered = Column(Boolean, default=False)
+    triggered_at = Column(DateTime, default=None)
+    created_at = Column(DateTime)
+    updated_at = Column(DateTime, default=None)

investing_algorithm_framework/infrastructure/order_executors/__init__.py

@@ -1,4 +1,5 @@
 from .ccxt_order_executor import CCXTOrderExecutor
+from .backtest_oder_executor import BacktestOrderExecutor
 
 
 def get_default_order_executors():
@@ -15,5 +16,6 @@ def get_default_order_executors():
 
 __all__ = [
     'CCXTOrderExecutor',
+    'BacktestOrderExecutor',
     'get_default_order_executors',
 ]

investing_algorithm_framework/infrastructure/order_executors/backtest_oder_executor.py

@@ -0,0 +1,28 @@
+from investing_algorithm_framework.domain import OrderExecutor, OrderStatus, \
+    INDEX_DATETIME, Order
+
+
+class BacktestOrderExecutor(OrderExecutor):
+    """
+    Backtest implementation of order executor. This executor is used to
+    simulate order execution in a backtesting environment.
+
+    !Important: This executor does not actually execute orders on any market.
+        It should be used only for backtesting purposes.
+    """
+
+    def execute_order(self, portfolio, order, market_credential) -> Order:
+        order.status = OrderStatus.OPEN.value
+        order.remaining = order.get_amount()
+        order.filled = 0
+        order.updated_at = self.config[INDEX_DATETIME]
+        return order
+
+    def cancel_order(self, portfolio, order, market_credential) -> Order:
+        order.status = OrderStatus.CANCELED.value
+        order.remaining = 0
+        order.updated_at = self.config[INDEX_DATETIME]
+        return order
+
+    def supports_market(self, market):
+        return True

investing_algorithm_framework/infrastructure/repositories/repository.py

@@ -1,6 +1,7 @@
 import logging
 from abc import ABC, abstractmethod
 from typing import Callable
+from dateutil.parser import parse
 
 from sqlalchemy.exc import SQLAlchemyError
 from werkzeug.datastructures import MultiDict
@@ -12,6 +13,16 @@ from investing_algorithm_framework.infrastructure.database import Session
 logger = logging.getLogger("investing_algorithm_framework")
 
 
+def convert_datetime_fields(data, datetime_fields):
+    for field in datetime_fields:
+        if field in data and isinstance(data[field], str):
+            try:
+                data[field] = parse(data[field])
+            except Exception:
+                pass  # Ignore if not a valid datetime string
+    return data
+
+
 class Repository(ABC):
     base_class: Callable
     DEFAULT_NOT_FOUND_MESSAGE = "The requested resource was not found"
@@ -20,7 +31,6 @@ class Repository(ABC):
 
     def create(self, data, save=True):
         created_object = self.base_class(**data)
-
         if save:
             with Session() as db:
                 try:
@@ -35,7 +45,11 @@ class Repository(ABC):
         return created_object
 
     def update(self, object_id, data):
-
+        # List all datetime fields for your model
+        datetime_fields = [
+            "created_at", "updated_at", "closed_at", "opened_at"
+        ]
+        data = convert_datetime_fields(data, datetime_fields)
         with Session() as db:
             try:
                 update_object = self.get(object_id)

investing_algorithm_framework/infrastructure/repositories/trade_repository.py

@@ -1,7 +1,7 @@
 import logging
 from sqlalchemy.exc import SQLAlchemyError
 
-from investing_algorithm_framework.domain import OrderStatus, ApiException
+from investing_algorithm_framework.domain import TradeStatus, ApiException
 from investing_algorithm_framework.infrastructure.models import SQLPosition, \
     SQLPortfolio, SQLTrade, SQLOrder
 from investing_algorithm_framework.infrastructure.database import Session
@@ -43,7 +43,7 @@ class SQLTradeRepository(Repository):
                 .filter(SQLPosition.portfolio_id == portfolio.id)
 
         if status_query_param:
-            status = OrderStatus.from_value(status_query_param)
+            status = TradeStatus.from_value(status_query_param)
             # Explicitly filter on SQLTrade.status
             query = query.filter(SQLTrade.status == status.value)
 

investing_algorithm_framework/infrastructure/repositories/trade_stop_loss_repository.py

@@ -14,10 +14,16 @@ class SQLTradeStopLossRepository(Repository):
 
     def _apply_query_params(self, db, query, query_params):
         trade_query_param = self.get_query_param("trade_id", query_params)
+        triggered_query_param = self.get_query_param(
+            "triggered", query_params
+        )
 
         if trade_query_param:
             query = query.filter(
                 SQLTradeStopLoss.trade_id == trade_query_param
             )
 
+        if triggered_query_param is not None:
+            query = query.filter_by(triggered=triggered_query_param)
+
         return query

investing_algorithm_framework/infrastructure/repositories/trade_take_profit_repository.py

@@ -14,10 +14,16 @@ class SQLTradeTakeProfitRepository(Repository):
 
     def _apply_query_params(self, db, query, query_params):
         trade_query_param = self.get_query_param("trade_id", query_params)
+        triggered_query_param = self.get_query_param(
+            "triggered", query_params
+        )
 
         if trade_query_param:
             query = query.filter(
                 SQLTradeTakeProfit.trade_id == trade_query_param
             )
 
+        if triggered_query_param is not None:
+            query = query.filter_by(triggered=triggered_query_param)
+
         return query

investing_algorithm_framework/infrastructure/services/__init__.py

@@ -1,11 +1,7 @@
-from .market_service import CCXTMarketService
-from .performance_service import PerformanceService
 from .azure import AzureBlobStorageStateHandler
 from .aws import AWSS3StorageStateHandler
 
 __all__ = [
-    "PerformanceService",
-    "CCXTMarketService",
     "AzureBlobStorageStateHandler",
     "AWSS3StorageStateHandler"
 ]

investing_algorithm_framework/services/__init__.py

@@ -1,8 +1,9 @@
 from .backtesting import BacktestService
+from .trade_order_evaluator import BacktestTradeOrderEvaluator, \
+    TradeOrderEvaluator, DefaultTradeOrderEvaluator
 from .configuration_service import ConfigurationService
 from .market_credential_service import MarketCredentialService
-from .market_data_source_service import MarketDataSourceService, \
-    BacktestMarketDataSourceService, DataProviderService
+from .data_providers import DataProviderService
 from .order_service import OrderService, OrderBacktestService, \
     OrderExecutorLookup
 from .portfolios import PortfolioService, BacktestPortfolioService, \
@@ -10,17 +11,41 @@ from .portfolios import PortfolioService, BacktestPortfolioService, \
     PortfolioSnapshotService, PortfolioProviderLookup
 from .positions import PositionService, PositionSnapshotService
 from .repository_service import RepositoryService
-from .strategy_orchestrator_service import StrategyOrchestratorService
-from .trade_service import TradeService
+from .trade_service import TradeService, TradeStopLossService, \
+    TradeTakeProfitService
+from .metrics import get_annual_volatility, \
+    get_sortino_ratio, get_drawdown_series, get_max_drawdown, \
+    get_equity_curve, get_price_efficiency_ratio, get_sharpe_ratio, \
+    get_profit_factor, get_cumulative_profit_factor_series, \
+    get_rolling_profit_factor_series, \
+    get_cagr, get_standard_deviation_returns, \
+    get_standard_deviation_downside_returns, \
+    get_total_return, get_cumulative_exposure, get_exposure_ratio, \
+    get_yearly_returns, get_monthly_returns, get_best_year, \
+    get_best_month, get_worst_year, get_worst_month, get_best_trade, \
+    get_worst_trade, get_average_yearly_return, get_average_trade_gain, \
+    get_average_trade_loss, get_average_monthly_return, \
+    get_percentage_winning_months, get_average_trade_duration, \
+    get_trade_frequency, get_win_rate, get_win_loss_ratio, \
+    get_calmar_ratio, get_max_drawdown_absolute, get_current_win_loss_ratio, \
+    get_max_drawdown_duration, get_max_daily_drawdown, get_trades_per_day, \
+    get_trades_per_year, get_average_monthly_return_losing_months, \
+    get_average_monthly_return_winning_months, get_percentage_winning_years, \
+    get_rolling_sharpe_ratio, create_backtest_metrics, get_total_growth, \
+    get_total_loss, get_risk_free_rate_us, get_median_trade_return, \
+    get_average_trade_return, get_cumulative_return, \
+    get_cumulative_return_series, get_average_trade_size, \
+    get_positive_trades, get_negative_trades, get_number_of_trades, \
+    get_current_win_rate, get_current_average_trade_return, \
+    get_current_average_trade_loss, get_current_average_trade_duration, \
+    get_current_average_trade_gain, create_backtest_metrics_for_backtest
 
 __all__ = [
-    "StrategyOrchestratorService",
     "OrderService",
     "RepositoryService",
     "PortfolioService",
     "PositionService",
     "PortfolioConfigurationService",
-    "MarketDataSourceService",
     "BacktestService",
     "OrderBacktestService",
     "ConfigurationService",
@@ -28,11 +53,83 @@ __all__ = [
     "PortfolioSnapshotService",
     "PositionSnapshotService",
     "MarketCredentialService",
-    "BacktestMarketDataSourceService",
     "BacktestPortfolioService",
     "TradeService",
     "DataProviderService",
     "OrderExecutorLookup",
-    "PortfolioServiceV2",
+    "BacktestTradeOrderEvaluator",
     "PortfolioProviderLookup",
+    "TradeOrderEvaluator",
+    "DefaultTradeOrderEvaluator",
+    "get_risk_free_rate_us",
+    "get_annual_volatility",
+    "get_sortino_ratio",
+    "get_drawdown_series",
+    "get_max_drawdown",
+    "get_equity_curve",
+    "get_price_efficiency_ratio",
+    "get_sharpe_ratio",
+    "get_profit_factor",
+    "get_cumulative_profit_factor_series",
+    "get_rolling_profit_factor_series",
+    "get_sharpe_ratio",
+    "get_cagr",
+    "get_standard_deviation_returns",
+    "get_standard_deviation_downside_returns",
+    "get_max_drawdown_absolute",
+    "get_total_return",
+    "get_cumulative_exposure",
+    "get_exposure_ratio",
+    "get_average_trade_duration",
+    "get_win_rate",
+    "get_win_loss_ratio",
+    "get_calmar_ratio",
+    "get_trade_frequency",
+    "get_yearly_returns",
+    "get_monthly_returns",
+    "get_best_year",
+    "get_best_month",
+    "get_worst_year",
+    "get_worst_month",
+    "get_best_trade",
+    "get_worst_trade",
+    "get_average_yearly_return",
+    "get_average_trade_loss",
+    "get_average_monthly_return",
+    "get_percentage_winning_months",
+    "get_average_trade_duration",
+    "get_trade_frequency",
+    "get_win_rate",
+    "get_win_loss_ratio",
+    "get_calmar_ratio",
+    "get_max_drawdown_duration",
+    "get_max_daily_drawdown",
+    "get_trades_per_day",
+    "get_trades_per_year",
+    "get_average_monthly_return_losing_months",
+    "get_average_monthly_return_winning_months",
+    "get_percentage_winning_years",
+    "get_rolling_sharpe_ratio",
+    "get_total_growth",
+    "create_backtest_metrics",
+    "get_total_loss",
+    "get_median_trade_return",
+    "get_average_trade_gain",
+    "get_average_trade_size",
+    "get_average_trade_return",
+    "get_positive_trades",
+    "get_negative_trades",
+    "get_number_of_trades",
+    "get_cumulative_return",
+    "get_cumulative_return_series",
+    "get_current_win_loss_ratio",
+    "get_current_win_rate",
+    "get_current_win_loss_ratio",
+    "get_current_average_trade_loss",
+    "get_current_average_trade_duration",
+    "get_current_average_trade_gain",
+    "get_current_average_trade_return",
+    "create_backtest_metrics_for_backtest",
+    "TradeStopLossService",
+    "TradeTakeProfitService"
 ]