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

investing_algorithm_framework/infrastructure/repositories/__init__.py

@@ -0,0 +1,21 @@
+from .order_repository import SQLOrderRepository
+from .order_metadata_repository import SQLOrderMetadataRepository
+from .portfolio_repository import SQLPortfolioRepository
+from .portfolio_snapshot_repository import SQLPortfolioSnapshotRepository
+from .position_repository import SQLPositionRepository
+from .position_snapshot_repository import SQLPositionSnapshotRepository
+from .trade_repository import SQLTradeRepository
+from .trade_stop_loss_repository import SQLTradeStopLossRepository
+from .trade_take_profit_repository import SQLTradeTakeProfitRepository
+
+__all__ = [
+    "SQLOrderRepository",
+    "SQLPositionRepository",
+    "SQLPositionSnapshotRepository",
+    "SQLPortfolioRepository",
+    "SQLPortfolioSnapshotRepository",
+    "SQLTradeRepository",
+    "SQLTradeTakeProfitRepository",
+    "SQLTradeStopLossRepository",
+    "SQLOrderMetadataRepository"
+]

investing_algorithm_framework/infrastructure/repositories/order_metadata_repository.py

@@ -0,0 +1,17 @@
+from investing_algorithm_framework.infrastructure.models import \
+    SQLOrderMetadata
+from .repository import Repository
+
+
+class SQLOrderMetadataRepository(Repository):
+    base_class = SQLOrderMetadata
+    DEFAULT_NOT_FOUND_MESSAGE = "The requested order metadata was not found"
+
+    def _apply_query_params(self, db, query, query_params):
+
+        if "order_id" in query_params:
+            query = query.filter(
+               SQLOrderMetadata.order_id == query_params["order_id"]
+            )
+
+        return query

investing_algorithm_framework/infrastructure/repositories/order_repository.py

@@ -0,0 +1,96 @@
+from investing_algorithm_framework.domain import OrderStatus, OrderType, \
+    OrderSide
+from investing_algorithm_framework.infrastructure.models import SQLOrder, \
+    SQLPosition, SQLPortfolio
+from .repository import Repository
+
+
+class SQLOrderRepository(Repository):
+    base_class = SQLOrder
+    DEFAULT_NOT_FOUND_MESSAGE = "The requested order was not found"
+
+    def _apply_query_params(self, db, query, query_params):
+        id_query_param = self.get_query_param("id", query_params)
+        external_id_query_param = self.get_query_param(
+            "external_id", query_params
+        )
+        portfolio_query_param = self.get_query_param(
+            "portfolio_id", query_params
+        )
+        side_query_param = self.get_query_param("order_side", query_params)
+        type_query_param = self.get_query_param("order_type", query_params)
+        status_query_param = self.get_query_param("status", query_params)
+        price_query_param = self.get_query_param("price", query_params)
+        amount_query_param = self.get_query_param("amount", query_params)
+        position_query_param = self.get_query_param(
+            "position", query_params, many=True
+        )
+        target_symbol_query_param = self.get_query_param(
+            "target_symbol", query_params
+        )
+        trading_symbol_query_param = self.get_query_param(
+            "trading_symbol", query_params
+        )
+        order_by_created_at_asc = self.get_query_param(
+            "order_by_created_at_asc", query_params
+        )
+
+        if id_query_param:
+            query = query.filter_by(id=id_query_param)
+
+        if portfolio_query_param is not None:
+            portfolio = db.query(SQLPortfolio).filter_by(
+                id=portfolio_query_param
+            ).first()
+
+            if portfolio:
+                positions = db.query(SQLPosition).filter_by(
+                    portfolio_id=portfolio.id
+                ).all()
+                position_ids = [p.id for p in positions]
+                query = query.filter(SQLOrder.position_id.in_(position_ids))
+            else:
+                query = query.filter_by(id=None)
+
+        if external_id_query_param:
+            query = query.filter_by(external_id=external_id_query_param)
+
+        if side_query_param:
+            order_side = OrderSide.from_value(side_query_param)
+            query = query.filter_by(order_side=order_side.value)
+
+        if type_query_param:
+            order_type = OrderType.from_value(type_query_param)
+            query = query.filter_by(order_type=order_type.value)
+
+        if status_query_param:
+            status = OrderStatus.from_value(status_query_param)
+            query = query.filter_by(status=status.value)
+
+        if price_query_param:
+            query = query.filter(SQLOrder.price == price_query_param)
+
+        if amount_query_param:
+            query = query.filter_by(amount=amount_query_param)
+
+        if position_query_param:
+            query = query.filter(SQLOrder.position_id.in_(
+                position_query_param)
+            )
+
+        if target_symbol_query_param:
+            query = query.filter(
+                SQLOrder.target_symbol == target_symbol_query_param
+            )
+
+        if trading_symbol_query_param:
+            query = query.filter(
+                SQLOrder.trading_symbol == trading_symbol_query_param
+            )
+
+        if order_by_created_at_asc:
+            query = query.order_by(SQLOrder.created_at.asc())
+        else:
+            query = query.order_by(SQLOrder.created_at.desc())
+
+        return query

investing_algorithm_framework/infrastructure/repositories/portfolio_repository.py

@@ -0,0 +1,30 @@
+from investing_algorithm_framework.infrastructure.models import SQLPortfolio, \
+    SQLPosition
+from .repository import Repository
+
+
+class SQLPortfolioRepository(Repository):
+    base_class = SQLPortfolio
+    DEFAULT_NOT_FOUND_MESSAGE = "Portfolio not found"
+
+    def _apply_query_params(self, db, query, query_params):
+        id_query_param = query_params.get("id")
+        market_query_param = query_params.get("market")
+        identifier_query_param = query_params.get("identifier")
+        position_query_param = query_params.get("position")
+
+        if id_query_param:
+            query = query.filter_by(id=id_query_param)
+
+        if market_query_param:
+            query = query.filter_by(market=market_query_param.upper())
+
+        if identifier_query_param:
+            query = query.filter_by(identifier=identifier_query_param.upper())
+
+        if position_query_param:
+            position = db.query(SQLPosition)\
+                .filter_by(id=position_query_param).first()
+            query = query.filter_by(id=position.portfolio_id)
+
+        return query

investing_algorithm_framework/infrastructure/repositories/portfolio_snapshot_repository.py

@@ -0,0 +1,56 @@
+from investing_algorithm_framework.infrastructure.models import \
+    SQLPortfolioSnapshot
+from .repository import Repository
+
+
+class SQLPortfolioSnapshotRepository(Repository):
+    base_class = SQLPortfolioSnapshot
+    DEFAULT_NOT_FOUND_MESSAGE = "Portfolio snapshot not found"
+
+    def _apply_query_params(self, db, query, query_params):
+        portfolio_id_query_param = self.get_query_param(
+            "portfolio_id", query_params
+        )
+        created_at_query_param = self.get_query_param(
+            "created_at", query_params
+        )
+        created_at_gt_query_param = self.get_query_param(
+            "created_at_gt", query_params
+        )
+        created_at_gte_query_param = self.get_query_param(
+            "created_at_gte", query_params
+        )
+        created_at_lt_query_param = self.get_query_param(
+            "created_at_lt", query_params
+        )
+        created_at_lte_query_param = self.get_query_param(
+            "created_at_lte", query_params
+        )
+
+        if portfolio_id_query_param is not None:
+            query = query.filter_by(portfolio_id=portfolio_id_query_param)
+
+        if created_at_query_param is not None:
+            query = query.filter_by(created_at=created_at_query_param)
+
+        if created_at_gt_query_param is not None:
+            query = query.filter(
+                SQLPortfolioSnapshot.created_at > created_at_gt_query_param
+            )
+
+        if created_at_gte_query_param is not None:
+            query = query.filter(
+                SQLPortfolioSnapshot.created_at >= created_at_gt_query_param
+            )
+
+        if created_at_lt_query_param is not None:
+            query = query.filter(
+                SQLPortfolioSnapshot.created_at < created_at_lt_query_param
+            )
+
+        if created_at_lte_query_param is not None:
+            query = query.filter(
+                SQLPortfolioSnapshot.created_at <= created_at_lte_query_param
+            )
+
+        return query

investing_algorithm_framework/infrastructure/repositories/position_repository.py

@@ -0,0 +1,66 @@
+from sqlalchemy import cast, Numeric, Float
+
+from investing_algorithm_framework.infrastructure.models import SQLPosition
+from .repository import Repository
+
+
+class SQLPositionRepository(Repository):
+    base_class = SQLPosition
+    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)
+        amount_gt_query_param = self.get_query_param("amount_gt", query_params)
+        amount_gte_query_param = self.get_query_param(
+            "amount_gte", query_params
+        )
+        amount_lt_query_param = self.get_query_param("amount_lt", query_params)
+        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(
+                cast(SQLPosition.amount, Float) == amount_query_param
+            )
+
+        if symbol_query_param:
+            query = query.filter_by(symbol=symbol_query_param)
+
+        if portfolio_query_param is not None:
+            query = query.filter_by(portfolio_id=portfolio_query_param)
+
+        if amount_gt_query_param is not None:
+            query = query.filter(
+                cast(SQLPosition.amount, Numeric) > amount_gt_query_param
+            )
+
+        if amount_gte_query_param is not None:
+            query = query.filter(
+                cast(SQLPosition.amount, Numeric) >= amount_gte_query_param
+            )
+
+        if amount_lt_query_param is not None:
+            query = query.filter(
+                cast(SQLPosition.amount, Numeric) < amount_lt_query_param
+            )
+
+        if amount_lte_query_param:
+            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/position_snapshot_repository.py

@@ -0,0 +1,21 @@
+from investing_algorithm_framework.infrastructure.models import \
+    SQLPositionSnapshot
+from .repository import Repository
+
+
+class SQLPositionSnapshotRepository(Repository):
+    base_class = SQLPositionSnapshot
+    DEFAULT_NOT_FOUND_MESSAGE = "Position snapshot not found"
+
+    def _apply_query_params(self, db, query, query_params):
+        portfolio_snapshot_query_param = self.get_query_param(
+            "portfolio_snapshot", query_params
+        )
+
+        if portfolio_snapshot_query_param is not None:
+            query = query\
+                .filter_by(
+                    portfolio_snapshot_id=portfolio_snapshot_query_param
+                )
+
+        return query

investing_algorithm_framework/infrastructure/repositories/repository.py

@@ -0,0 +1,299 @@
+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 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, 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")
+
+        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)
+                update_object.update(data)
+                db.add(update_object)
+                db.commit()
+                return self.get(object_id)
+            except SQLAlchemyError as e:
+                logger.error(e)
+                db.rollback()
+                raise OperationalException("Error updating object")
+
+    def update_all(self, query_params, data):
+
+        with Session() as db:
+            try:
+                selection = self.get_all(query_params)
+
+                for item in selection:
+                    try:
+                        item.update(db, data)
+                    except SQLAlchemyError as e:
+                        logger.error(e)
+                        db.rollback()
+
+                db.commit()
+
+            except SQLAlchemyError as e:
+                logger.error(e)
+                db.rollback()
+                raise OperationalException("Error updating object")
+
+    def delete(self, object_id):
+
+        with Session() as db:
+            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 OperationalException("Error deleting object")
+
+    def delete_all(self, query_params):
+
+        with Session() as db:
+            if query_params is None:
+                raise OperationalException("No parameters are required")
+
+            try:
+                query_set = db.query(self.base_class)
+                query_set = self.apply_query_params(
+                    db, query_set, query_params
+                )
+
+                for item in query_set.all():
+                    item.delete(db)
+                    db.commit()
+
+            except SQLAlchemyError as e:
+                logger.error(e)
+                db.rollback()
+                raise OperationalException("Error deleting all objects")
+
+    def get_all(self, query_params=None):
+        query_params = MultiDict(query_params)
+
+        with Session() as db:
+            try:
+                query_set = db.query(self.base_class)
+                query_set = self.apply_query_params(
+                    db, query_set, query_params
+                )
+                return query_set.all()
+            except SQLAlchemyError as e:
+                logger.error(e)
+                raise OperationalException("Error getting all objects")
+
+    def get(self, object_id):
+
+        with Session() as db:
+            match = db.query(self.base_class).filter_by(id=object_id) \
+                .first()
+
+            if not match:
+                raise OperationalException(
+                    self.DEFAULT_NOT_FOUND_MESSAGE
+                )
+
+            return match
+
+    @abstractmethod
+    def _apply_query_params(self, db, query, query_params):
+        raise NotImplementedError()
+
+    def apply_query_params(self, db, query, query_params):
+
+        if query_params is not None:
+            query_params = MultiDict(query_params)
+            query = self._apply_query_params(db, query, query_params)
+
+        return query
+
+    def exists(self, query_params):
+        with Session() as db:
+            try:
+                query = db.query(self.base_class)
+                query = self.apply_query_params(db, query, query_params)
+                return query.first() is not None
+            except SQLAlchemyError as e:
+                logger.error(e)
+                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)
+                query = self.apply_query_params(db, query, query_params)
+                result = query.first()
+
+                if result is None:
+                    raise OperationalException(self.DEFAULT_NOT_FOUND_MESSAGE)
+
+                return result
+            except SQLAlchemyError as e:
+                logger.error(e)
+                raise OperationalException(self.DEFAULT_NOT_FOUND_MESSAGE)
+
+    def count(self, query_params=None):
+
+        with Session() as db:
+            try:
+                query = db.query(self.base_class)
+                query = self.apply_query_params(db, query, query_params)
+                return query.count()
+            except SQLAlchemyError as e:
+                logger.error(e)
+                raise OperationalException("Error counting objects")
+
+    def normalize_query_param(self, value):
+        """
+        Given a non-flattened query parameter value,
+        and if the value is a list only containing 1 item,
+        then the value is flattened.
+
+        :param value: a value from a query parameter
+        :return: a normalized query parameter value
+        """
+        return value if len(value) > 1 else value[0]
+
+    def is_query_param_present(self, key, params, throw_exception=False):
+        query_params = self.normalize_query(params)
+
+        if key not in query_params:
+
+            if not throw_exception:
+                return False
+
+            raise OperationalException(f"{key} is not specified")
+        else:
+            return True
+
+    def normalize_query(self, params):
+        """
+        Converts query parameters from only containing one value for
+        each parameter, to include parameters with multiple values as lists.
+
+        :param params: a flask query parameters data structure
+        :return: a dict of normalized query parameters
+        """
+        if isinstance(params, MultiDict):
+            params = params.to_dict(flat=False)
+
+        return {k: self.normalize_query_param(v) for k, v in params.items()}
+
+    def get_query_param(self, key, params, default=None, many=False):
+        boolean_array = ["true", "false"]
+
+        if params is None or key not in params:
+            return default
+
+        params = self.normalize_query(params)
+        selection = params.get(key, default)
+
+        if not isinstance(selection, list):
+
+            if selection is None:
+                selection = []
+            else:
+                selection = [selection]
+
+        new_selection = []
+
+        for index, selected in enumerate(selection):
+
+            if isinstance(selected, str) and selected.lower() in boolean_array:
+                new_selection.append(selected.lower() == "true")
+            else:
+                new_selection.append(selected)
+
+        if not many:
+
+            if len(new_selection) == 0:
+                return None
+
+            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")