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

investing_algorithm_framework/infrastructure/database/sql_alchemy.py

@@ -1,13 +1,14 @@
 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(__name__)
+logger = logging.getLogger("investing_algorithm_framework")
 
 
 class SQLAlchemyAdapter:
@@ -19,18 +20,11 @@ class SQLAlchemyAdapter:
             raise OperationalException("SQLALCHEMY_DATABASE_URI not set")
 
         global Session
-
-        if app.config[SQLALCHEMY_DATABASE_URI] != "sqlite:///:memory:":
-            engine = create_engine(
-                app.config[SQLALCHEMY_DATABASE_URI],
-                connect_args={'check_same_thread': False},
-                poolclass=StaticPool
-            )
-        else:
-            engine = create_engine(
-                app.config[SQLALCHEMY_DATABASE_URI],
-            )
-
+        engine = create_engine(
+            app.config[SQLALCHEMY_DATABASE_URI],
+            connect_args={'check_same_thread': False},
+            poolclass=StaticPool
+        )
         Session.configure(bind=engine)
 
 
@@ -45,9 +39,89 @@ def setup_sqlalchemy(app, throw_exception_if_not_set=True):
     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 one of the following attributes are
+    present: created_at, updated_at, closed_at, opened_at, triggered_at.
+    If so, it will check if these datetime
+    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)
+
+    if hasattr(target, "triggered_at"):
+        dt = getattr(target, "triggered_at")
+        if dt and dt.tzinfo is None:
+            target.triggered_at = dt.replace(tzinfo=timezone.utc)

investing_algorithm_framework/infrastructure/models/__init__.py

@@ -1,7 +1,16 @@
-from .order import SQLOrder, SQLOrderFee
-from .portfolio import SQLPortfolio
-from .position import SQLPosition, SQLPositionCost
+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", "SQLPositionCost", "SQLOrderFee"
+    "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/order/__init__.py

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

investing_algorithm_framework/infrastructure/models/order/order.py

@@ -1,111 +1,105 @@
 import logging
-from datetime import datetime
+from datetime import datetime, timezone
 
-from sqlalchemy import Column, Integer, String, DateTime, Float, ForeignKey
+from sqlalchemy import Column, Integer, String, DateTime, ForeignKey, Float
 from sqlalchemy.orm import relationship
 
-from investing_algorithm_framework.domain.models import OrderType, \
-    OrderSide, Order, OrderStatus, OrderFee
+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(__name__)
+logger = logging.getLogger("investing_algorithm_framework")
 
 
-class SQLOrder(SQLBaseModel, Order, SQLAlchemyModelExtension):
+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)
-    side = Column(String, nullable=False, default=OrderSide.BUY.value)
-    type = Column(String, nullable=False, default=OrderType.LIMIT.value)
+    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)
-    filled_amount = Column(Float)
-    remaining_amount = Column(Float)
-    cost = Column(Float)
-    status = Column(String)
+    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, default=datetime.utcnow)
-    updated_at = Column(DateTime, default=datetime.utcnow)
-    trade_closed_at = Column(DateTime, default=None)
-    trade_closed_price = Column(Float, default=None)
-    net_gain = Column(Float, default=0)
-    fee = relationship(
-        "SQLOrderFee",
-        uselist=False,
-        back_populates="order",
-        cascade="all, delete"
+    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 __init__(
-        self,
-        side,
-        type,
-        status,
-        amount,
-        position_id=None,
-        target_symbol=None,
-        trading_symbol=None,
-        external_id=None,
-        price=None,
-        created_at=None,
-        updated_at=None,
-        trade_closed_at=None,
-        trade_closed_price=None,
-        net_gain=0,
-        filled_amount=None,
-        remaining_amount=None,
-        cost=None,
-        fee=None
-    ):
-        super().__init__(
-            target_symbol=target_symbol,
-            trading_symbol=trading_symbol,
-            type=type,
-            side=side,
-            status=status,
-            amount=amount,
-            price=price,
-            external_id=external_id,
-            position_id=position_id,
-            net_gain=net_gain,
-            trade_closed_at=trade_closed_at,
-            trade_closed_price=trade_closed_price,
-            created_at=created_at,
-            updated_at=updated_at,
-            filled_amount=filled_amount,
-            remaining_amount=remaining_amount,
-            cost=cost,
-            fee=fee
-        )
+    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,
-            type=order.get_type(),
-            side=order.get_side(),
+            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(),
-            trade_closed_at=order.get_trade_closed_at(),
-            trade_closed_price=order.get_trade_closed_price(),
-            net_gain=order.get_net_gain(),
         )
 
     @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),
@@ -114,11 +108,17 @@ class SQLOrder(SQLBaseModel, Order, SQLAlchemyModelExtension):
             price=ccxt_order.get("price", None),
             amount=ccxt_order.get("amount", None),
             status=status,
-            type=ccxt_order.get("type", None),
-            side=ccxt_order.get("side", None),
-            filled_amount=ccxt_order.get("filled", None),
-            remaining_amount=ccxt_order.get("remaining", None),
+            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),
-            fee=OrderFee.from_ccxt_fee(ccxt_order.get("fee", 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

@@ -1,3 +1,4 @@
-from .portfolio import SQLPortfolio
+from .sql_portfolio import SQLPortfolio
+from .portfolio_snapshot import SQLPortfolioSnapshot
 
-__all__ = ['SQLPortfolio']
+__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/{portfolio.py → sql_portfolio.py}

@@ -1,4 +1,6 @@
-from sqlalchemy import Column, Integer, String, Float
+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
@@ -9,7 +11,7 @@ from investing_algorithm_framework.infrastructure.models.model_extension \
     import SQLAlchemyModelExtension
 
 
-class SQLPortfolio(SQLBaseModel, Portfolio, SQLAlchemyModelExtension):
+class SQLPortfolio(Portfolio, SQLBaseModel, SQLAlchemyModelExtension):
     __tablename__ = "portfolios"
     id = Column(Integer, primary_key=True)
     identifier = Column(String, nullable=False, unique=True)
@@ -18,8 +20,10 @@ class SQLPortfolio(SQLBaseModel, Portfolio, SQLAlchemyModelExtension):
     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",
@@ -27,6 +31,10 @@ class SQLPortfolio(SQLBaseModel, Portfolio, SQLAlchemyModelExtension):
         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',
@@ -43,11 +51,27 @@ class SQLPortfolio(SQLBaseModel, Portfolio, SQLAlchemyModelExtension):
             raise ValueError("{} is write-once".format(key))
         return value
 
-    def __init__(self, trading_symbol, market, unallocated, identifier=None):
+    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,
@@ -57,4 +81,34 @@ class SQLPortfolio(SQLBaseModel, Portfolio, SQLAlchemyModelExtension):
             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

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

investing_algorithm_framework/infrastructure/models/position/position.py

@@ -1,11 +1,11 @@
-from sqlalchemy import Column, Integer, String, Float, ForeignKey
+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
-from investing_algorithm_framework.domain import Position
 
 
 class SQLPosition(SQLBaseModel, Position, SQLAlchemyModelExtension):
@@ -13,18 +13,13 @@ class SQLPosition(SQLBaseModel, Position, SQLAlchemyModelExtension):
     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"
     )
-    position_costs = relationship(
-        "SQLPositionCost",
-        back_populates="position",
-        lazy="dynamic",
-        cascade="all, delete-orphan"
-    )
     portfolio_id = Column(Integer, ForeignKey('portfolios.id'))
     portfolio = relationship("SQLPortfolio", back_populates="positions")
     __table_args__ = (
@@ -32,19 +27,19 @@ class SQLPosition(SQLBaseModel, Position, SQLAlchemyModelExtension):
             'symbol', 'portfolio_id', name='_symbol_portfolio_uc'
         ),
     )
-    _cost = 0
 
     def __init__(
         self,
         symbol,
         amount=0,
-        portfolio_id=None
+        cost=0,
+        portfolio_id=None,
     ):
         super(SQLPosition, self).__init__()
         self.symbol = symbol
         self.amount = amount
         self.portfolio_id = portfolio_id
-        self.cost = 0
+        self.cost = cost
 
     @validates('id', 'symbol')
     def _write_once(self, key, value):
@@ -53,6 +48,16 @@ class SQLPosition(SQLBaseModel, Position, SQLAlchemyModelExtension):
             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"
+    )