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

investing_algorithm_framework/infrastructure/repositories/repository.py

@@ -1,38 +1,55 @@
 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
 
-from investing_algorithm_framework.domain import ApiException, \
+from investing_algorithm_framework.domain import OperationalException, \
     DEFAULT_PAGE_VALUE, DEFAULT_PER_PAGE_VALUE
 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"
     DEFAULT_PER_PAGE = DEFAULT_PER_PAGE_VALUE
     DEFAULT_PAGE = DEFAULT_PAGE_VALUE
 
-    def create(self, data):
+    def create(self, data, save=True):
+        created_object = self.base_class(**data)
+        if save:
+            with Session() as db:
+                try:
+                    db.add(created_object)
+                    db.commit()
+                    return self.get(created_object.id)
+                except SQLAlchemyError as e:
+                    logger.error(e)
+                    db.rollback()
+                    raise OperationalException("Error creating object")
 
-        with Session() as db:
-            try:
-                created_object = self.base_class(**data)
-                db.add(created_object)
-                db.commit()
-                return self.get(created_object.id)
-            except SQLAlchemyError as e:
-                logger.error(e)
-                db.rollback()
-                raise ApiException("Error creating object")
+        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)
@@ -43,7 +60,7 @@ class Repository(ABC):
             except SQLAlchemyError as e:
                 logger.error(e)
                 db.rollback()
-                raise ApiException("Error updating object")
+                raise OperationalException("Error updating object")
 
     def update_all(self, query_params, data):
 
@@ -63,7 +80,7 @@ class Repository(ABC):
             except SQLAlchemyError as e:
                 logger.error(e)
                 db.rollback()
-                raise ApiException("Error updating object")
+                raise OperationalException("Error updating object")
 
     def delete(self, object_id):
 
@@ -71,17 +88,18 @@ class Repository(ABC):
             try:
                 delete_object = self.get(object_id)
                 db.delete(delete_object)
+                db.commit()
                 return delete_object
             except SQLAlchemyError as e:
                 logger.error(e)
                 db.rollback()
-                raise ApiException("Error deleting object")
+                raise OperationalException("Error deleting object")
 
     def delete_all(self, query_params):
 
         with Session() as db:
             if query_params is None:
-                raise ApiException("No parameters are required")
+                raise OperationalException("No parameters are required")
 
             try:
                 query_set = db.query(self.base_class)
@@ -96,7 +114,7 @@ class Repository(ABC):
             except SQLAlchemyError as e:
                 logger.error(e)
                 db.rollback()
-                raise ApiException("Error deleting all objects")
+                raise OperationalException("Error deleting all objects")
 
     def get_all(self, query_params=None):
         query_params = MultiDict(query_params)
@@ -110,7 +128,7 @@ class Repository(ABC):
                 return query_set.all()
             except SQLAlchemyError as e:
                 logger.error(e)
-                raise ApiException("Error getting all objects")
+                raise OperationalException("Error getting all objects")
 
     def get(self, object_id):
 
@@ -119,8 +137,8 @@ class Repository(ABC):
                 .first()
 
             if not match:
-                raise ApiException(
-                    self.DEFAULT_NOT_FOUND_MESSAGE, status_code=404
+                raise OperationalException(
+                    self.DEFAULT_NOT_FOUND_MESSAGE
                 )
 
             return match
@@ -145,10 +163,13 @@ class Repository(ABC):
                 return query.first() is not None
             except SQLAlchemyError as e:
                 logger.error(e)
-                raise ApiException("Error checking if object exists")
+                raise OperationalException("Error checking if object exists")
 
     def find(self, query_params):
 
+        if query_params is None or len(query_params) == 0:
+            raise OperationalException("Find requires query parameters")
+
         with Session() as db:
             try:
                 query = db.query(self.base_class)
@@ -156,12 +177,12 @@ class Repository(ABC):
                 result = query.first()
 
                 if result is None:
-                    raise ApiException(self.DEFAULT_NOT_FOUND_MESSAGE)
+                    raise OperationalException(self.DEFAULT_NOT_FOUND_MESSAGE)
 
                 return result
             except SQLAlchemyError as e:
                 logger.error(e)
-                raise ApiException(self.DEFAULT_NOT_FOUND_MESSAGE)
+                raise OperationalException(self.DEFAULT_NOT_FOUND_MESSAGE)
 
     def count(self, query_params=None):
 
@@ -172,7 +193,7 @@ class Repository(ABC):
                 return query.count()
             except SQLAlchemyError as e:
                 logger.error(e)
-                raise ApiException("Error counting objects")
+                raise OperationalException("Error counting objects")
 
     def normalize_query_param(self, value):
         """
@@ -193,7 +214,7 @@ class Repository(ABC):
             if not throw_exception:
                 return False
 
-            raise ApiException(f"{key} is not specified")
+            raise OperationalException(f"{key} is not specified")
         else:
             return True
 
@@ -213,7 +234,7 @@ class Repository(ABC):
     def get_query_param(self, key, params, default=None, many=False):
         boolean_array = ["true", "false"]
 
-        if params is None:
+        if params is None or key not in params:
             return default
 
         params = self.normalize_query(params)
@@ -243,3 +264,36 @@ class Repository(ABC):
             return new_selection[0]
 
         return new_selection
+
+    def save(self, object_to_save):
+        """
+        Save an object to the database with SQLAlchemy.
+
+        Args:
+            object_to_save: instance of the object to save.
+
+        Returns:
+            Object: The saved object.
+        """
+        with Session() as db:
+            try:
+                db.add(object_to_save)
+                db.commit()
+                return self.get(object_to_save.id)
+            except SQLAlchemyError as e:
+                logger.error(e)
+                db.rollback()
+                raise OperationalException("Error saving object")
+
+    def save_objects(self, objects):
+
+        with Session() as db:
+            try:
+                for object in objects:
+                    db.add(object)
+                db.commit()
+                return objects
+            except SQLAlchemyError as e:
+                logger.error(e)
+                db.rollback()
+                raise OperationalException("Error saving objects")

investing_algorithm_framework/infrastructure/repositories/trade_repository.py

@@ -0,0 +1,71 @@
+import logging
+from sqlalchemy.exc import SQLAlchemyError
+
+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
+
+from .repository import Repository
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+
+class SQLTradeRepository(Repository):
+    base_class = SQLTrade
+    DEFAULT_NOT_FOUND_MESSAGE = "The requested trade was not found"
+
+    def _apply_query_params(self, db, query, query_params):
+        portfolio_query_param = self.get_query_param(
+            "portfolio_id", query_params
+        )
+        status_query_param = self.get_query_param("status", query_params)
+        target_symbol = self.get_query_param(
+            "target_symbol", query_params
+        )
+        trading_symbol = self.get_query_param("trading_symbol", query_params)
+        order_id_query_param = self.get_query_param("order_id", query_params)
+
+        if order_id_query_param:
+            query = query.filter(SQLTrade.orders.any(id=order_id_query_param))
+
+        if portfolio_query_param is not None:
+            portfolio = db.query(SQLPortfolio).filter_by(
+                id=portfolio_query_param
+            ).first()
+
+            if portfolio is None:
+                raise ApiException("Portfolio not found")
+
+            # Query trades belonging to the portfolio
+            query = db.query(SQLTrade).join(SQLOrder, SQLTrade.orders) \
+                .join(SQLPosition, SQLOrder.position_id == SQLPosition.id) \
+                .filter(SQLPosition.portfolio_id == portfolio.id)
+
+        if status_query_param:
+            status = TradeStatus.from_value(status_query_param)
+            # Explicitly filter on SQLTrade.status
+            query = query.filter(SQLTrade.status == status.value)
+
+        if target_symbol:
+            # Explicitly filter on SQLTrade.target_symbol
+            query = query.filter(SQLTrade.target_symbol == target_symbol)
+
+        if trading_symbol:
+            # Explicitly filter on SQLTrade.trading_symbol
+            query = query.filter(SQLTrade.trading_symbol == trading_symbol)
+
+        return query
+
+    def add_order_to_trade(self, trade, order):
+        with Session() as db:
+            try:
+                db.add(order)
+                db.add(trade)
+                trade.orders.append(order)
+                db.commit()
+                return trade
+            except SQLAlchemyError as e:
+                logger.error(f"Error saving trade: {e}")
+                db.rollback()
+                raise ApiException("Error saving trade")

investing_algorithm_framework/infrastructure/repositories/trade_stop_loss_repository.py

@@ -0,0 +1,29 @@
+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)
+        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

@@ -0,0 +1,29 @@
+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)
+        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,7 +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/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