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

investing_algorithm_framework/infrastructure/database/sql_alchemy.py

@@ -0,0 +1,120 @@
+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, \
+    OperationalException
+
+Session = sessionmaker()
+logger = logging.getLogger("investing_algorithm_framework")
+
+
+class SQLAlchemyAdapter:
+
+    def __init__(self, app):
+        self._app = app
+        if SQLALCHEMY_DATABASE_URI not in app.config \
+                or app.config[SQLALCHEMY_DATABASE_URI] is None:
+            raise OperationalException("SQLALCHEMY_DATABASE_URI not set")
+
+        global Session
+        engine = create_engine(
+            app.config[SQLALCHEMY_DATABASE_URI],
+            connect_args={'check_same_thread': False},
+            poolclass=StaticPool
+        )
+        Session.configure(bind=engine)
+
+
+def setup_sqlalchemy(app, throw_exception_if_not_set=True):
+
+    try:
+        SQLAlchemyAdapter(app)
+    except OperationalException as e:
+        if throw_exception_if_not_set:
+            raise e
+
+    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 the `created_at` and `updated_at`
+    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)

investing_algorithm_framework/infrastructure/models/__init__.py

@@ -0,0 +1,16 @@
+from .order import SQLOrder, SQLOrderMetadata
+from .portfolio import SQLPortfolio, SQLPortfolioSnapshot
+from .position import SQLPosition, SQLPositionSnapshot
+from .trades import SQLTrade, SQLTradeStopLoss, SQLTradeTakeProfit
+
+__all__ = [
+    "SQLOrder",
+    "SQLPosition",
+    "SQLPortfolio",
+    "SQLPositionSnapshot",
+    "SQLPortfolioSnapshot",
+    "SQLTrade",
+    "SQLTradeStopLoss",
+    "SQLTradeTakeProfit",
+    "SQLOrderMetadata",
+]

investing_algorithm_framework/infrastructure/models/decimal_parser.py

@@ -0,0 +1,14 @@
+from decimal import Decimal, getcontext
+
+
+def count_number_of_decimals(value) -> int:
+    value = str(value)
+    if "." in value:
+        return len(value) - value.index(".") - 1
+    else:
+        return 0
+
+
+def parse_decimal(value) -> Decimal:
+    getcontext().prec = count_number_of_decimals(value)
+    return Decimal(value)

investing_algorithm_framework/infrastructure/models/model_extension.py

@@ -0,0 +1,6 @@
+class SQLAlchemyModelExtension:
+
+    def update(self, data):
+
+        for attr, value in data.items():
+            setattr(self, attr, value)

investing_algorithm_framework/infrastructure/models/order/__init__.py

@@ -0,0 +1,4 @@
+from .order import SQLOrder
+from .order_metadata import SQLOrderMetadata
+
+__all__ = ["SQLOrder", "SQLOrderMetadata"]

investing_algorithm_framework/infrastructure/models/order/order.py

@@ -0,0 +1,124 @@
+import logging
+from datetime import datetime, timezone
+
+from sqlalchemy import Column, Integer, String, DateTime, ForeignKey, Float
+from sqlalchemy.orm import relationship
+
+from investing_algorithm_framework.domain import OrderType, \
+    OrderSide, Order, OrderStatus
+from investing_algorithm_framework.infrastructure.database import SQLBaseModel
+from investing_algorithm_framework.infrastructure.models.model_extension \
+    import SQLAlchemyModelExtension
+from investing_algorithm_framework.infrastructure.models.\
+    order_trade_association import order_trade_association
+
+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.
+    """
+    __tablename__ = "orders"
+    id = Column(Integer, primary_key=True, unique=True)
+    external_id = Column(Integer)
+    target_symbol = Column(String)
+    trading_symbol = Column(String)
+    order_side = Column(String, nullable=False, default=OrderSide.BUY.value)
+    order_type = Column(String, nullable=False, default=OrderType.LIMIT.value)
+    trades = relationship(
+        'SQLTrade', secondary=order_trade_association, back_populates='orders'
+    )
+    price = Column(Float)
+    amount = Column(Float)
+    remaining = Column(Float, default=None)
+    filled = Column(Float, default=None)
+    cost = Column(Float, default=0)
+    status = Column(String, default=OrderStatus.CREATED.value)
+    position_id = Column(Integer, ForeignKey('positions.id'))
+    position = relationship("SQLPosition", back_populates="orders")
+    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)
+    sell_order_metadata_id = Column(Integer, ForeignKey('orders.id'))
+    order_metadata = relationship(
+        'SQLOrderMetadata', back_populates='order'
+    )
+
+    def update(self, data):
+
+        if "status" in data and data["status"] is not None:
+            data["status"] = OrderStatus.from_value(data["status"]).value
+
+        super().update(data)
+
+    @staticmethod
+    def from_order(order):
+        return SQLOrder(
+            external_id=order.external_id,
+            amount=order.get_amount(),
+            filled=order.get_filled(),
+            remaining=order.get_remaining(),
+            price=order.price,
+            order_type=order.get_order_type(),
+            order_side=order.get(),
+            status=order.get_status(),
+            target_symbol=order.get_target_symbol(),
+            trading_symbol=order.get_trading_symbol(),
+            created_at=order.get_created_at(),
+            updated_at=order.get_updated_at(),
+        )
+
+    @staticmethod
+    def from_ccxt_order(ccxt_order):
+        """
+        Create an Order object from a CCXT order object
+
+        Args:
+            ccxt_order: CCXT order object
+
+        Returns:
+            Order: Order object
+        """
+        status = OrderStatus.from_value(ccxt_order["status"])
+        target_symbol = ccxt_order.get("symbol").split("/")[0]
+        trading_symbol = ccxt_order.get("symbol").split("/")[1]
+        ccxt_fee = ccxt_order.get("fee", None)
+        order_fee = None
+        order_fee_rate = None
+        order_fee_currency = None
+
+        if ccxt_fee is not None:
+            order_fee = ccxt_fee.get("cost", None)
+            order_fee_rate = ccxt_fee.get("rate", None)
+            order_fee_currency = ccxt_fee.get("currency", None)
+
+        return Order(
+            external_id=ccxt_order.get("id", None),
+            target_symbol=target_symbol,
+            trading_symbol=trading_symbol,
+            price=ccxt_order.get("price", None),
+            amount=ccxt_order.get("amount", None),
+            status=status,
+            order_type=ccxt_order.get("type", None),
+            order_side=ccxt_order.get("side", None),
+            filled=ccxt_order.get("filled", None),
+            remaining=ccxt_order.get("remaining", None),
+            cost=ccxt_order.get("cost", None),
+            order_fee=order_fee,
+            order_fee_rate=order_fee_rate,
+            order_fee_currency=order_fee_currency,
+            created_at=ccxt_order.get("datetime", None),
+        )
+
+    def __lt__(self, other):
+        # Define the less-than comparison based on created_at attribute
+        return self.created_at < other.created_at

investing_algorithm_framework/infrastructure/models/order/order_metadata.py

@@ -0,0 +1,44 @@
+import logging
+
+from sqlalchemy import Column, Integer, ForeignKey, Float
+from sqlalchemy.orm import relationship
+
+from investing_algorithm_framework.infrastructure.database import SQLBaseModel
+from investing_algorithm_framework.infrastructure.models.model_extension \
+    import SQLAlchemyModelExtension
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+
+class SQLOrderMetadata(SQLBaseModel, SQLAlchemyModelExtension):
+    __tablename__ = "sql_order_metadata"
+    id = Column(Integer, primary_key=True, unique=True)
+    order_id = Column(Integer, ForeignKey('orders.id'))
+    order = relationship('SQLOrder', back_populates='order_metadata')
+    trade_id = Column(Integer)
+    stop_loss_id = Column(Integer)
+    take_profit_id = Column(Integer)
+    amount = Column(Float)
+    amount_pending = Column(Float)
+
+    def __init__(
+        self,
+        order_id,
+        amount,
+        amount_pending,
+        trade_id=None,
+        stop_loss_id=None,
+        take_profit_id=None,
+    ):
+        self.order_id = order_id
+        self.trade_id = trade_id
+        self.stop_loss_id = stop_loss_id
+        self.take_profit_id = take_profit_id
+        self.amount = amount
+        self.amount_pending = amount_pending
+
+    def __repr__(self):
+        return f"<SQLOrderMetadata(id={self.id}, order_id={self.order_id}, " \
+               f"trade_id={self.trade_id}, stop_loss_id={self.stop_loss_id}, "\
+               f"take_profit_id={self.take_profit_id}, amount={self.amount}, "\
+               f"amount_pending={self.amount_pending})>"

investing_algorithm_framework/infrastructure/models/order_trade_association.py

@@ -0,0 +1,10 @@
+from sqlalchemy import Table, Column, Integer, ForeignKey
+from investing_algorithm_framework.infrastructure.database import SQLBaseModel
+
+# Association table
+order_trade_association = Table(
+    'order_trade',  # Table name
+    SQLBaseModel.metadata,
+    Column('order_id', Integer, ForeignKey('orders.id'), primary_key=True),
+    Column('trade_id', Integer, ForeignKey('trades.id'), primary_key=True)
+)

investing_algorithm_framework/infrastructure/models/portfolio/__init__.py

@@ -0,0 +1,4 @@
+from .sql_portfolio import SQLPortfolio
+from .portfolio_snapshot import SQLPortfolioSnapshot
+
+__all__ = ['SQLPortfolio', "SQLPortfolioSnapshot"]

investing_algorithm_framework/infrastructure/models/portfolio/portfolio_snapshot.py

@@ -0,0 +1,37 @@
+from sqlalchemy import Column, Integer, String, DateTime, Float
+from sqlalchemy.orm import relationship
+
+from investing_algorithm_framework.domain import PortfolioSnapshot
+from investing_algorithm_framework.infrastructure.database import SQLBaseModel
+from investing_algorithm_framework.infrastructure.models.model_extension \
+    import SQLAlchemyModelExtension
+
+
+class SQLPortfolioSnapshot(
+    PortfolioSnapshot, SQLBaseModel, SQLAlchemyModelExtension
+):
+    """
+    SQLAlchemy model for portfolio snapshots.
+
+    Portfolio snapshots represent the state of a portfolio at a specific
+    point in time.
+    """
+    __tablename__ = "portfolio_snapshots"
+    id = Column(Integer, primary_key=True)
+    portfolio_id = Column(String, nullable=False)
+    trading_symbol = Column(String, nullable=False)
+    pending_value = Column(Float, nullable=False, default=0)
+    unallocated = Column(Float, nullable=False, default=0)
+    net_size = Column(Float, nullable=False, default=0)
+    total_net_gain = Column(Float, nullable=False, default=0)
+    total_revenue = Column(Float, nullable=False, default=0)
+    total_cost = Column(Float, nullable=False, default=0)
+    total_value = Column(Float, nullable=False, default=0)
+    cash_flow = Column(Float, nullable=False, default=0)
+    created_at = Column(DateTime, nullable=False, default=0)
+    position_snapshots = relationship(
+        "SQLPositionSnapshot",
+        back_populates="portfolio_snapshot",
+        lazy="dynamic",
+        cascade="all,delete",
+    )

investing_algorithm_framework/infrastructure/models/portfolio/sql_portfolio.py

@@ -0,0 +1,114 @@
+from datetime import datetime, timezone
+
+from sqlalchemy import Column, Integer, String, DateTime, Float, Boolean
+from sqlalchemy import UniqueConstraint
+from sqlalchemy.orm import relationship
+from sqlalchemy.orm import validates
+
+from investing_algorithm_framework.domain import Portfolio
+from investing_algorithm_framework.infrastructure.database import SQLBaseModel
+from investing_algorithm_framework.infrastructure.models.model_extension \
+    import SQLAlchemyModelExtension
+
+
+class SQLPortfolio(Portfolio, SQLBaseModel, SQLAlchemyModelExtension):
+    __tablename__ = "portfolios"
+    id = Column(Integer, primary_key=True)
+    identifier = Column(String, nullable=False, unique=True)
+    trading_symbol = Column(String, nullable=False)
+    realized = Column(Float, nullable=False, default=0)
+    total_revenue = Column(Float, nullable=False, default=0)
+    total_cost = Column(Float, nullable=False, default=0)
+    total_net_gain = Column(Float, nullable=False, default=0)
+    total_trade_volume = Column(Float, nullable=False, default=0)
+    net_size = Column(Float, nullable=False, default=0)
+    unallocated = Column(Float, nullable=False, default=0)
+    initial_balance = Column(Float, nullable=True)
+    market = Column(String, nullable=False)
+    positions = relationship(
+        "SQLPosition",
+        back_populates="portfolio",
+        lazy="dynamic",
+        cascade="all,delete",
+    )
+    created_at = Column(DateTime, nullable=False)
+    updated_at = Column(DateTime, nullable=False)
+    initialized = Column(Boolean, nullable=False, default=False)
+
+    __table_args__ = (
+        UniqueConstraint(
+            'trading_symbol',
+            'identifier',
+            name='_trading_currency_identifier_uc'
+        ),
+    )
+
+    @validates('trading_symbol')
+    def _write_once(self, key, value):
+        existing = getattr(self, key)
+
+        if existing is not None:
+            raise ValueError("{} is write-once".format(key))
+        return value
+
+    def __init__(
+        self,
+        trading_symbol,
+        market,
+        unallocated,
+        initialized,
+        initial_balance=None,
+        identifier=None,
+        created_at=None,
+        updated_at=None,
+    ):
+
+        if identifier is None:
+            identifier = market
+
+        if created_at is None:
+            created_at = datetime.now(tz=timezone.utc)
+
+        if updated_at is None:
+            updated_at = datetime.now(tz=timezone.utc)
+
+        super().__init__(
+            trading_symbol=trading_symbol,
+            market=market,
+            identifier=identifier,
+            net_size=unallocated,
+            unallocated=unallocated,
+            realized=0,
+            total_revenue=0,
+            total_cost=0,
+            created_at=created_at,
+            updated_at=updated_at,
+            initialized=initialized,
+            initial_balance=initial_balance,
+        )
+
+    def update(self, data):
+
+        if "net_size" in data:
+            self.net_size = data.pop("net_size")
+
+        if "unallocated" in data:
+            self.unallocated = data.pop("unallocated")
+
+        if "realized" in data:
+            self.realized = data.pop("realized")
+
+        if "total_revenue" in data:
+            self.total_revenue = data.pop("total_revenue")
+
+        if "total_trade_volume" in data:
+            self.total_trade_volume = data.pop("total_trade_volume")
+
+        if "total_cost" in data:
+            self.total_cost = data.pop("total_cost")
+
+        if "total_net_gain" in data:
+            self.total_net_gain = data.pop("total_net_gain")
+
+        super().update(data)
+        return self

investing_algorithm_framework/infrastructure/models/position/__init__.py

@@ -0,0 +1,4 @@
+from .position import SQLPosition
+from .position_snapshot import SQLPositionSnapshot
+
+__all__ = ["SQLPosition", "SQLPositionSnapshot"]

investing_algorithm_framework/infrastructure/models/position/position.py

@@ -0,0 +1,63 @@
+from sqlalchemy import Column, Integer, String, ForeignKey, Float
+from sqlalchemy import UniqueConstraint
+from sqlalchemy.orm import relationship, validates
+
+from investing_algorithm_framework.domain import Position
+from investing_algorithm_framework.infrastructure.database import SQLBaseModel
+from investing_algorithm_framework.infrastructure.models.model_extension \
+    import SQLAlchemyModelExtension
+
+
+class SQLPosition(SQLBaseModel, Position, SQLAlchemyModelExtension):
+    __tablename__ = "positions"
+    id = Column(Integer, primary_key=True, unique=True)
+    symbol = Column(String)
+    amount = Column(Float)
+    cost = Column(Float)
+    orders = relationship(
+        "SQLOrder",
+        back_populates="position",
+        lazy="dynamic",
+        cascade="all, delete-orphan"
+    )
+    portfolio_id = Column(Integer, ForeignKey('portfolios.id'))
+    portfolio = relationship("SQLPortfolio", back_populates="positions")
+    __table_args__ = (
+        UniqueConstraint(
+            'symbol', 'portfolio_id', name='_symbol_portfolio_uc'
+        ),
+    )
+
+    def __init__(
+        self,
+        symbol,
+        amount=0,
+        cost=0,
+        portfolio_id=None,
+    ):
+        super(SQLPosition, self).__init__()
+        self.symbol = symbol
+        self.amount = amount
+        self.portfolio_id = portfolio_id
+        self.cost = cost
+
+    @validates('id', 'symbol')
+    def _write_once(self, key, value):
+        existing = getattr(self, key)
+        if existing is not None:
+            raise ValueError("{} is write-once".format(key))
+        return value
+
+    def update(self, data):
+
+        if 'amount' in data:
+            self.amount = data.pop('amount')
+
+        if 'cost' in data:
+            self.cost = data.pop('cost')
+
+        super(SQLPosition, self).update(data)
+
+    @property
+    def ccxt_symbol(self):
+        return f"{self.symbol}/{self.portfolio.trading_symbol}"

investing_algorithm_framework/infrastructure/models/position/position_snapshot.py

@@ -0,0 +1,23 @@
+from sqlalchemy import Column, Integer, String, ForeignKey, Float
+from sqlalchemy.orm import relationship
+
+from investing_algorithm_framework.domain import PositionSnapshot
+from investing_algorithm_framework.infrastructure.database import SQLBaseModel
+from investing_algorithm_framework.infrastructure.models.model_extension \
+    import SQLAlchemyModelExtension
+
+
+class SQLPositionSnapshot(
+    SQLBaseModel, PositionSnapshot, SQLAlchemyModelExtension
+):
+    __tablename__ = "position_snapshots"
+    id = Column(Integer, primary_key=True, unique=True)
+    symbol = Column(String)
+    amount = Column(Float)
+    cost = Column(Float)
+    portfolio_snapshot_id = Column(
+        Integer, ForeignKey('portfolio_snapshots.id')
+    )
+    portfolio_snapshot = relationship(
+        "SQLPortfolioSnapshot", back_populates="position_snapshots"
+    )

investing_algorithm_framework/infrastructure/models/trades/__init__.py

@@ -0,0 +1,9 @@
+from .trade import SQLTrade
+from .trade_stop_loss import SQLTradeStopLoss
+from .trade_take_profit import SQLTradeTakeProfit
+
+__all__ = [
+    "SQLTrade",
+    "SQLTradeStopLoss",
+    "SQLTradeTakeProfit",
+]