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

investing_algorithm_framework/infrastructure/repositories/position_repository.py

@@ -9,6 +9,7 @@ class SQLPositionRepository(Repository):
     DEFAULT_NOT_FOUND_MESSAGE = "Position not found"
 
     def _apply_query_params(self, db, query, query_params):
+        id_query_param = self.get_query_param("id", query_params)
         amount_query_param = self.get_query_param("amount", query_params)
         symbol_query_param = self.get_query_param("symbol", query_params)
         portfolio_query_param = self.get_query_param("portfolio", query_params)
@@ -20,6 +21,10 @@ class SQLPositionRepository(Repository):
         amount_lte_query_param = self.get_query_param(
             "amount_lte", query_params
         )
+        order_id_query_param = self.get_query_param("order_id", query_params)
+
+        if id_query_param:
+            query = query.filter_by(id=id_query_param)
 
         if amount_query_param:
             query = query.filter(
@@ -51,5 +56,11 @@ class SQLPositionRepository(Repository):
             query = query.filter(
                 cast(SQLPosition.amount, Numeric) <= amount_lte_query_param
             )
+        # Filter by order_id, orders is a one-to-many relationship
+        # with 3 position
+        if order_id_query_param:
+            query = query.filter(
+                SQLPosition.orders.any(id=order_id_query_param)
+            )
 
         return query

investing_algorithm_framework/infrastructure/repositories/repository.py

@@ -1,38 +1,55 @@
 import logging
-from abc import ABC
+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,14 +137,15 @@ 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
 
+    @abstractmethod
     def _apply_query_params(self, db, query, query_params):
-        return query
+        raise NotImplementedError()
 
     def apply_query_params(self, db, query, query_params):
 
@@ -137,7 +156,6 @@ class Repository(ABC):
         return query
 
     def exists(self, query_params):
-
         with Session() as db:
             try:
                 query = db.query(self.base_class)
@@ -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,5 +1,10 @@
-from .market_service import MarketService
-from .market_backtest_service import MarketBacktestService
-from .performance_service import PerformanceService
+from .azure import AzureBlobStorageStateHandler
+from .aws import AWSS3StorageStateHandler
+from .backtesting import BacktestService, EventBacktestService
 
-__all__ = ["MarketService", "MarketBacktestService", "PerformanceService"]
+__all__ = [
+    "AzureBlobStorageStateHandler",
+    "AWSS3StorageStateHandler",
+    "BacktestService",
+    "EventBacktestService",
+]

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,193 @@
+import os
+import logging
+import boto3
+import stat
+from botocore.exceptions import NoCredentialsError, PartialCredentialsError
+from investing_algorithm_framework.domain import OperationalException, \
+    StateHandler
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+
+def _fix_permissions(target_directory: str):
+    """
+    Fix permissions on downloaded files to make them writable.
+
+    Args:
+        target_directory (str): Directory to fix permissions for
+    """
+    try:
+        # Fix the target directory itself
+        os.chmod(target_directory, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)
+
+        # Recursively fix all subdirectories and files
+        for root, dirs, files in os.walk(target_directory):
+            # Fix current directory permissions
+            os.chmod(root, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)
+
+            # Fix all subdirectories
+            for dir_name in dirs:
+                dir_path = os.path.join(root, dir_name)
+                os.chmod(dir_path, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)
+
+            # Fix all files - make them readable and writable
+            for file_name in files:
+                file_path = os.path.join(root, file_name)
+                os.chmod(
+                    file_path,
+                    stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IROTH
+                )
+
+        logger.info(f"Update permissions for {target_directory}")
+    except Exception as e:
+        logger.warning(f"Error fixing permissions: {e}")
+
+
+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 para or the "
+                "AWS_S3_BUCKET_NAME environment variable needs to be set "
+                "in the environment."
+            )
+
+        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)
+                    # Convert to forward slashes for S3 compatibility
+                    s3_key = s3_key.replace(os.sep, "/")
+
+                    self.s3_client.upload_file(
+                        file_path,
+                        self.bucket_name,
+                        s3_key,
+                        ExtraArgs={'ACL': 'private'}
+                    )
+
+        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.
+        """
+        logger.info("Loading state from AWS S3 ...")
+
+        try:
+            if not os.path.exists(target_directory):
+                os.makedirs(
+                    target_directory,
+                    mode=stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO
+                )
+
+            os.chmod(
+                target_directory, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO
+            )
+
+            response = self.s3_client.list_objects_v2(Bucket=self.bucket_name)
+
+            if "Contents" in response:
+                for obj in response["Contents"]:
+                    s3_key = obj["Key"]
+                    # Convert S3 forward slashes to OS-specific separators
+                    file_path = os.path.join(
+                        target_directory, s3_key.replace("/", os.sep)
+                    )
+
+                    os.makedirs(
+                        os.path.dirname(file_path),
+                        exist_ok=True,
+                        mode=stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO
+                    )
+
+                    self.s3_client.download_file(
+                        self.bucket_name, s3_key, file_path
+                    )
+
+                    if os.path.isfile(file_path):
+                        os.chmod(
+                            file_path,
+                            stat.S_IRUSR |
+                            stat.S_IWUSR |
+                            stat.S_IRGRP |
+                            stat.S_IROTH
+                        )
+                    else:
+                        os.chmod(
+                            file_path,
+                            stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO
+                        )
+
+            # Final recursive fix
+            _fix_permissions(target_directory)
+
+            # Add write permission to database file
+            db_file = os.path.join(
+                target_directory, "databases", "prod-database.sqlite3"
+            )
+            if os.path.exists(db_file):
+                os.chmod(
+                    db_file,
+                    stat.S_IRUSR |
+                    stat.S_IWUSR |
+                    stat.S_IRGRP |
+                    stat.S_IWGRP |
+                    stat.S_IROTH |
+                    stat.S_IWOTH
+                )
+                logger.info(
+                    f"Database file permissions "
+                    f"after fix: {oct(os.stat(db_file).st_mode)}"
+                )
+
+        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"
+]