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

investing_algorithm_framework/infrastructure/repositories/trade_stop_loss_repository.py

@@ -0,0 +1,23 @@
+import logging
+
+from investing_algorithm_framework.infrastructure.models import \
+    SQLTradeStopLoss
+
+from .repository import Repository
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+
+class SQLTradeStopLossRepository(Repository):
+    base_class = SQLTradeStopLoss
+    DEFAULT_NOT_FOUND_MESSAGE = "The requested trade stop loss was not found"
+
+    def _apply_query_params(self, db, query, query_params):
+        trade_query_param = self.get_query_param("trade_id", query_params)
+
+        if trade_query_param:
+            query = query.filter(
+                SQLTradeStopLoss.trade_id == trade_query_param
+            )
+
+        return query

investing_algorithm_framework/infrastructure/repositories/trade_take_profit_repository.py

@@ -0,0 +1,23 @@
+import logging
+
+from investing_algorithm_framework.infrastructure.models import \
+    SQLTradeTakeProfit
+
+from .repository import Repository
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+
+class SQLTradeTakeProfitRepository(Repository):
+    base_class = SQLTradeTakeProfit
+    DEFAULT_NOT_FOUND_MESSAGE = "The requested trade take profit was not found"
+
+    def _apply_query_params(self, db, query, query_params):
+        trade_query_param = self.get_query_param("trade_id", query_params)
+
+        if trade_query_param:
+            query = query.filter(
+                SQLTradeTakeProfit.trade_id == trade_query_param
+            )
+
+        return query

investing_algorithm_framework/infrastructure/services/__init__.py

@@ -0,0 +1,7 @@
+from .azure import AzureBlobStorageStateHandler
+from .aws import AWSS3StorageStateHandler
+
+__all__ = [
+    "AzureBlobStorageStateHandler",
+    "AWSS3StorageStateHandler"
+]

investing_algorithm_framework/infrastructure/services/aws/__init__.py

@@ -0,0 +1,6 @@
+from .state_handler import AWSS3StorageStateHandler
+
+
+__all__ = [
+    "AWSS3StorageStateHandler",
+]

investing_algorithm_framework/infrastructure/services/aws/state_handler.py

@@ -0,0 +1,113 @@
+import os
+import logging
+import boto3
+from botocore.exceptions import NoCredentialsError, PartialCredentialsError
+from investing_algorithm_framework.domain import OperationalException, \
+    StateHandler
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+
+class AWSS3StorageStateHandler(StateHandler):
+    """
+    A state handler for AWS S3 storage.
+
+    This class provides methods to save and load state to and from
+    AWS S3 storage.
+
+    Attributes:
+        bucket_name (str): The name of the AWS S3 bucket.
+    """
+
+    def __init__(self, bucket_name: str = None):
+        self.bucket_name = bucket_name
+        self.s3_client = None
+
+    def initialize(self):
+        self.bucket_name = self.bucket_name or os.getenv("AWS_S3_BUCKET_NAME")
+
+        if not self.bucket_name:
+            raise OperationalException(
+                "AWS S3 state handler requires a bucket name or the "
+                "AWS_S3_BUCKET_NAME environment variable to be set."
+            )
+
+        self.s3_client = boto3.client("s3")
+
+    def save(self, source_directory: str):
+        """
+        Save the state to AWS S3.
+
+        Args:
+            source_directory (str): Directory to save the state
+
+        Returns:
+            None
+        """
+        logger.info("Saving state to AWS S3 ...")
+
+        try:
+            # Walk through the directory
+            for root, _, files in os.walk(source_directory):
+                for file_name in files:
+                    # Get the full path of the file
+                    file_path = os.path.join(root, file_name)
+
+                    # Construct the S3 object key (relative path in the bucket)
+                    s3_key = os.path.relpath(file_path, source_directory)\
+                        .replace("\\", "/")
+
+                    # Upload the file
+                    self.s3_client.upload_file(
+                        file_path, self.bucket_name, s3_key
+                    )
+
+        except (NoCredentialsError, PartialCredentialsError) as ex:
+            logger.error(f"Error saving state to AWS S3: {ex}")
+            raise OperationalException(
+                "AWS credentials are missing or incomplete."
+            )
+        except Exception as ex:
+            logger.error(f"Error saving state to AWS S3: {ex}")
+            raise ex
+
+    def load(self, target_directory: str):
+        """
+        Load the state from AWS S3.
+
+        Args:
+            target_directory (str): Directory to load the state
+
+        Returns:
+            None
+        """
+        logger.info("Loading state from AWS S3 ...")
+
+        try:
+            # Ensure the local directory exists
+            if not os.path.exists(target_directory):
+                os.makedirs(target_directory)
+
+            # List and download objects
+            response = self.s3_client.list_objects_v2(Bucket=self.bucket_name)
+            if "Contents" in response:
+                for obj in response["Contents"]:
+                    s3_key = obj["Key"]
+                    file_path = os.path.join(target_directory, s3_key)
+
+                    # Create subdirectories locally if needed
+                    os.makedirs(os.path.dirname(file_path), exist_ok=True)
+
+                    # Download object to file
+                    self.s3_client.download_file(
+                        self.bucket_name, s3_key, file_path
+                    )
+
+        except (NoCredentialsError, PartialCredentialsError) as ex:
+            logger.error(f"Error loading state from AWS S3: {ex}")
+            raise OperationalException(
+                "AWS credentials are missing or incomplete."
+            )
+        except Exception as ex:
+            logger.error(f"Error loading state from AWS S3: {ex}")
+            raise ex

investing_algorithm_framework/infrastructure/services/azure/__init__.py

@@ -0,0 +1,5 @@
+from .state_handler import AzureBlobStorageStateHandler
+
+__all__ = [
+    "AzureBlobStorageStateHandler"
+]

investing_algorithm_framework/infrastructure/services/azure/state_handler.py

@@ -0,0 +1,158 @@
+import os
+import logging
+
+from azure.storage.blob import ContainerClient
+from investing_algorithm_framework.domain import OperationalException, \
+    StateHandler
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+
+class AzureBlobStorageStateHandler(StateHandler):
+    """
+    A state handler for Azure Blob Storage.
+
+    This class provides methods to save and load state to and from
+    Azure Blob Storage.
+
+    Attributes:
+        connection_string (str): The connection string for Azure Blob Storage.
+        container_name (str): The name of the Azure Blob Storage container.
+    """
+
+    def __init__(
+        self, connection_string: str = None, container_name: str = None
+    ):
+        self.connection_string = connection_string
+        self.container_name = container_name
+
+    def initialize(self):
+        """
+        Internal helper to initialize the state handler.
+        """
+
+        if self.connection_string is None:
+
+            # Check if environment variable is set
+            self.connection_string = \
+                os.getenv("AZURE_STORAGE_CONNECTION_STRING")
+
+            if self.connection_string is None:
+                raise OperationalException(
+                    "Azure Blob Storage state handler requires" +
+                    " a connection string or an environment" +
+                    " variable AZURE_STORAGE_CONNECTION_STRING to be set."
+                )
+
+        if self.container_name is None:
+
+            # Check if environment variable is set
+            self.container_name = os.getenv("AZURE_STORAGE_CONTAINER_NAME")
+
+            if self.container_name is None:
+                raise OperationalException(
+                    "Azure Blob Storage state handler requires a" +
+                    " container name or an environment" +
+                    " variable AZURE_STORAGE_CONTAINER_NAME to be set."
+                )
+
+    def save(self, source_directory: str):
+        """
+        Save the state to Azure Blob Storage.
+
+        Parameters:
+            source_directory (str): Directory to save the state
+
+        Returns:
+            None
+        """
+        logger.info("Saving state to Azure Blob Storage ...")
+
+        try:
+            container_client = self._create_container_client()
+
+            # Create container if it does not exist
+            if not container_client.exists():
+                container_client.create_container()
+
+            # Walk through the directory
+            for root, _, files in os.walk(source_directory):
+                for file_name in files:
+                    # Get the full path of the file
+                    file_path = os.path.join(root, file_name)
+
+                    # Construct the blob name (relative path in the container)
+                    blob_name = os.path.relpath(file_path, source_directory)\
+                        .replace("\\", "/")
+
+                    # Upload the file
+                    with open(file_path, "rb") as data:
+                        container_client.upload_blob(
+                            name=blob_name, data=data, overwrite=True
+                        )
+
+        except Exception as ex:
+            logger.error(f"Error saving state to Azure Blob Storage: {ex}")
+            raise ex
+
+    def load(self, target_directory: str):
+        """
+        Load the state from Azure Blob Storage.
+
+        Parameters:
+            target_directory (str): Directory to load the state
+
+        Returns:
+            None
+        """
+        logger.info("Loading state from Azure Blob Storage ...")
+
+        try:
+            container_client = self._create_container_client()
+
+            # Ensure the local directory exists
+            if not os.path.exists(target_directory):
+                os.makedirs(target_directory)
+
+            # List and download blobs
+            for blob in container_client.list_blobs():
+                blob_name = blob.name
+                blob_file_path = os.path.join(target_directory, blob_name)
+
+                # Create subdirectories locally if needed
+                os.makedirs(os.path.dirname(blob_file_path), exist_ok=True)
+
+                # Download blob to file
+                with open(blob_file_path, "wb") as file:
+                    blob_client = container_client.get_blob_client(blob_name)
+                    file.write(blob_client.download_blob().readall())
+
+        except Exception as ex:
+            logger.error(f"Error loading state from Azure Blob Storage: {ex}")
+            raise ex
+
+    def _create_container_client(self):
+        """
+        Internal helper to create a Container clinet.
+
+        Returns:
+            ContainerClient
+        """
+
+        # Ensure the container exists
+        try:
+            container_client = ContainerClient.from_connection_string(
+                conn_str=self.connection_string,
+                container_name=self.container_name
+            )
+            container_client.create_container(timeout=10)
+        except Exception as e:
+
+            if "ContainerAlreadyExists" in str(e):
+                pass
+            else:
+                raise OperationalException(
+                    f"Error occurred while creating the container: {e}"
+                )
+
+        return container_client

investing_algorithm_framework/services/__init__.py

@@ -0,0 +1,132 @@
+from .backtesting import BacktestService
+from .trade_order_evaluator import BacktestTradeOrderEvaluator, \
+    TradeOrderEvaluator, DefaultTradeOrderEvaluator
+from .configuration_service import ConfigurationService
+from .market_credential_service import MarketCredentialService
+from .data_providers import DataProviderService
+from .order_service import OrderService, OrderBacktestService, \
+    OrderExecutorLookup
+from .portfolios import PortfolioService, BacktestPortfolioService, \
+    PortfolioConfigurationService, PortfolioSyncService, \
+    PortfolioSnapshotService, PortfolioProviderLookup
+from .positions import PositionService, PositionSnapshotService
+from .repository_service import RepositoryService
+from .trade_service import TradeService
+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__ = [
+    "OrderService",
+    "RepositoryService",
+    "PortfolioService",
+    "PositionService",
+    "PortfolioConfigurationService",
+    "BacktestService",
+    "OrderBacktestService",
+    "ConfigurationService",
+    "PortfolioSyncService",
+    "PortfolioSnapshotService",
+    "PositionSnapshotService",
+    "MarketCredentialService",
+    "BacktestPortfolioService",
+    "TradeService",
+    "DataProviderService",
+    "OrderExecutorLookup",
+    "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"
+]

investing_algorithm_framework/services/backtesting/__init__.py

@@ -0,0 +1,5 @@
+from .backtest_service import BacktestService
+
+__all__ = [
+    "BacktestService",
+]