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

investing_algorithm_framework/infrastructure/database/sql_alchemy.py

@@ -1,6 +1,7 @@
 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, \
@@ -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,10 +1,7 @@
-from .market_data_sources import CCXTOrderBookMarketDataSource, \
-    CCXTTickerMarketDataSource, CCXTOHLCVMarketDataSource, \
-    CCXTOHLCVBacktestMarketDataSource, CSVOHLCVMarketDataSource, \
-    CSVTickerMarketDataSource
-from .order import SQLOrder
+from .order import SQLOrder, SQLOrderMetadata
 from .portfolio import SQLPortfolio, SQLPortfolioSnapshot
 from .position import SQLPosition, SQLPositionSnapshot
+from .trades import SQLTrade, SQLTradeStopLoss, SQLTradeTakeProfit
 
 __all__ = [
     "SQLOrder",
@@ -12,10 +9,8 @@ __all__ = [
     "SQLPortfolio",
     "SQLPositionSnapshot",
     "SQLPortfolioSnapshot",
-    "CCXTOHLCVBacktestMarketDataSource",
-    "CCXTOrderBookMarketDataSource",
-    "CCXTTickerMarketDataSource",
-    "CCXTOHLCVMarketDataSource",
-    "CSVTickerMarketDataSource",
-    "CSVOHLCVMarketDataSource",
+    "SQLTrade",
+    "SQLTradeStopLoss",
+    "SQLTradeTakeProfit",
+    "SQLOrderMetadata",
 ]

investing_algorithm_framework/infrastructure/models/order/__init__.py

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

investing_algorithm_framework/infrastructure/models/order/order.py

@@ -1,5 +1,5 @@
 import logging
-from datetime import datetime
+from datetime import datetime, timezone
 
 from sqlalchemy import Column, Integer, String, DateTime, ForeignKey, Float
 from sqlalchemy.orm import relationship
@@ -9,11 +9,20 @@ from investing_algorithm_framework.domain import OrderType, \
 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)
@@ -21,59 +30,33 @@ class SQLOrder(Order, SQLBaseModel, SQLAlchemyModelExtension):
     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)
-    filled = Column(Float)
-    remaining = 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)
-    trade_closed_amount = Column(Float, default=None)
-    net_gain = Column(Float, default=0)
+    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)
+    order_fee_currency = Column(String, default=None)
     order_fee_rate = Column(Float, default=None)
-    _available_amount = None
+    sell_order_metadata_id = Column(Integer, ForeignKey('orders.id'))
+    order_metadata = relationship(
+        'SQLOrderMetadata', back_populates='order'
+    )
 
     def update(self, data):
 
-        if 'amount' in data and data['amount'] is not None:
-            amount = data.pop('amount')
-            self.amount = amount
-
-        if 'price' in data and data['price'] is not None:
-            price = data.pop('price')
-            self.price = price
-
-        if 'filled' in data and data['filled'] is not None:
-            filled = data.pop('filled')
-            self.filled = filled
-
-        if 'remaining' in data and data['remaining'] is not None:
-            remaining = data.pop('remaining')
-            self.remaining = remaining
-
-        if 'net_gain' in data and data['net_gain'] is not None:
-            net_gain = data.pop('net_gain')
-            self.net_gain = net_gain
-
-        if 'trade_closed_price' in data and \
-                data['trade_closed_price'] is not None:
-            trade_closed_price = data.pop('trade_closed_price')
-            self.trade_closed_price = trade_closed_price
-
-        if 'trade_closed_amount' in data and \
-                data['trade_closed_amount'] is not None:
-            trade_closed_amount = data.pop('trade_closed_amount')
-            self.trade_closed_amount = trade_closed_amount
-
         if "status" in data and data["status"] is not None:
-            self.status = OrderStatus.from_value(data.pop("status")).value
+            data["status"] = OrderStatus.from_value(data["status"]).value
 
         super().update(data)
 
@@ -82,6 +65,8 @@ class SQLOrder(Order, SQLBaseModel, SQLAlchemyModelExtension):
         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(),
@@ -90,17 +75,18 @@ class SQLOrder(Order, SQLBaseModel, SQLAlchemyModelExtension):
             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(),
-            trade_closed_amount=order.get_trade_closed_amount(),
-            net_gain=order.get_net_gain(),
         )
 
     @staticmethod
     def from_ccxt_order(ccxt_order):
         """
         Create an Order object from a CCXT order object
-        :param ccxt_order: 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]

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,4 +1,4 @@
-from .portfolio import SQLPortfolio
+from .sql_portfolio import SQLPortfolio
 from .portfolio_snapshot import SQLPortfolioSnapshot
 
 __all__ = ['SQLPortfolio', "SQLPortfolioSnapshot"]

investing_algorithm_framework/infrastructure/models/portfolio/portfolio_snapshot.py

@@ -10,15 +10,23 @@ from investing_algorithm_framework.infrastructure.models.model_extension \
 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(

investing_algorithm_framework/infrastructure/models/portfolio/{portfolio.py → sql_portfolio.py}

@@ -1,6 +1,6 @@
-from datetime import datetime
+from datetime import datetime, timezone
 
-from sqlalchemy import Column, Integer, String, DateTime, Float
+from sqlalchemy import Column, Integer, String, DateTime, Float, Boolean
 from sqlalchemy import UniqueConstraint
 from sqlalchemy.orm import relationship
 from sqlalchemy.orm import validates
@@ -23,6 +23,7 @@ class SQLPortfolio(Portfolio, SQLBaseModel, SQLAlchemyModelExtension):
     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",
@@ -30,8 +31,10 @@ class SQLPortfolio(Portfolio, SQLBaseModel, SQLAlchemyModelExtension):
         lazy="dynamic",
         cascade="all,delete",
     )
-    created_at = Column(DateTime, nullable=False, default=datetime.utcnow)
-    updated_at = Column(DateTime, nullable=False, default=datetime.utcnow)
+    created_at = Column(DateTime, nullable=False)
+    updated_at = Column(DateTime, nullable=False)
+    initialized = Column(Boolean, nullable=False, default=False)
+
     __table_args__ = (
         UniqueConstraint(
             'trading_symbol',
@@ -53,15 +56,21 @@ class SQLPortfolio(Portfolio, SQLBaseModel, SQLAlchemyModelExtension):
         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.utcnow()
+            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,
@@ -73,6 +82,9 @@ class SQLPortfolio(Portfolio, SQLBaseModel, SQLAlchemyModelExtension):
             total_revenue=0,
             total_cost=0,
             created_at=created_at,
+            updated_at=updated_at,
+            initialized=initialized,
+            initial_balance=initial_balance,
         )
 
     def update(self, data):

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",
+]

investing_algorithm_framework/infrastructure/models/trades/trade.py

@@ -0,0 +1,130 @@
+from sqlalchemy import Column, Integer, String, DateTime, Float
+from sqlalchemy.orm import relationship
+
+from investing_algorithm_framework.domain import Trade, TradeStatus
+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
+
+
+class SQLTrade(Trade, SQLBaseModel, SQLAlchemyModelExtension):
+    """
+    SQL Trade model
+
+    A trade is a combination of a buy and sell order that has been opened or
+    closed.
+
+    A trade is considered opened when a buy order is executed and there is
+    no corresponding sell order. A trade is considered closed when a sell
+    order is executed and the amount of the sell order is equal or larger
+    to the amount of the buy order.
+
+    A single sell order can close multiple buy orders. Also, a single
+    buy order can be closed by multiple sell orders.
+
+    Attributes:
+    orders: str, the id of the buy order
+        target_symbol: str, the target symbol of the trade
+        trading_symbol: str, the trading symbol of the trade
+        closed_at: datetime, the datetime when the trade was closed
+        amount: float, the amount of the trade
+        available_amount: float, the available amount of the trade
+        remaining: float, the remaining amount that is not filled by the
+            buy order that opened the trade.
+        filled_amount: float, the filled amount of the trade by the buy
+            order that opened the trade.
+        net_gain: float, the net gain of the trade
+        last_reported_price: float, the last reported price of the trade
+        last_reported_price_datetime: datetime, the datetime when the last
+            reported price was reported
+        created_at: datetime, the datetime when the trade was created
+        updated_at: datetime, the datetime when the trade was last updated
+        status: str, the status of the trade
+    """
+
+    __tablename__ = "trades"
+    id = Column(Integer, primary_key=True, unique=True)
+    orders = relationship(
+        'SQLOrder',
+        secondary=order_trade_association,
+        back_populates='trades',
+        lazy='joined'
+    )
+    target_symbol = Column(String)
+    trading_symbol = Column(String)
+    closed_at = Column(DateTime, default=None)
+    opened_at = Column(DateTime, default=None)
+    open_price = Column(Float, default=None)
+    amount = Column(Float, default=None)
+    available_amount = Column(Float, default=None)
+    filled_amount = Column(Float, default=None)
+    remaining = Column(Float, default=None)
+    net_gain = Column(Float, default=0)
+    cost = Column(Float, default=0)
+    last_reported_price = Column(Float, default=None)
+    last_reported_price_datetime = Column(DateTime, default=None)
+    high_water_mark = Column(Float, default=None)
+    high_water_mark_datetime = Column(DateTime, default=None)
+    updated_at = Column(DateTime, default=None)
+    status = Column(String, default=TradeStatus.CREATED.value)
+    # Stop losses should be actively loaded
+    stop_losses = relationship(
+        'SQLTradeStopLoss',
+        back_populates='trade',
+        lazy='joined'
+    )
+    # Take profits should be actively loaded
+    take_profits = relationship(
+        'SQLTradeTakeProfit',
+        back_populates='trade',
+        lazy='joined'
+    )
+
+    def __init__(
+        self,
+        buy_order,
+        target_symbol,
+        trading_symbol,
+        opened_at,
+        amount,
+        available_amount,
+        filled_amount,
+        remaining,
+        status=TradeStatus.CREATED.value,
+        closed_at=None,
+        updated_at=None,
+        net_gain=0,
+        cost=0,
+        last_reported_price=None,
+        last_reported_price_datetime=None,
+        high_water_mark=None,
+        high_water_mark_datetime=None,
+        sell_orders=[],
+        stop_losses=[],
+        take_profits=[],
+    ):
+        self.orders = [buy_order]
+        self.open_price = buy_order.price
+        self.target_symbol = target_symbol
+        self.trading_symbol = trading_symbol
+        self.closed_at = closed_at
+        self.amount = amount
+        self.available_amount = available_amount
+        self.filled_amount = filled_amount
+        self.remaining = remaining
+        self.net_gain = net_gain
+        self.cost = cost
+        self.last_reported_price = last_reported_price
+        self.last_reported_price_datetime = last_reported_price_datetime
+        self.high_water_mark = high_water_mark
+        self.high_water_mark_datetime = high_water_mark_datetime
+        self.opened_at = opened_at
+        self.updated_at = updated_at
+        self.status = status
+        self.stop_losses = stop_losses
+        self.take_profits = take_profits
+
+        if sell_orders is not None:
+            self.orders.extend(sell_orders)

investing_algorithm_framework/infrastructure/models/trades/trade_stop_loss.py

@@ -0,0 +1,59 @@
+from sqlalchemy import Column, Integer, String, Float, ForeignKey, Boolean, \
+    DateTime
+from sqlalchemy.orm import relationship
+
+from investing_algorithm_framework.domain import TradeStopLoss
+from investing_algorithm_framework.infrastructure.database import SQLBaseModel
+from investing_algorithm_framework.infrastructure.models.model_extension \
+    import SQLAlchemyModelExtension
+
+
+class SQLTradeStopLoss(TradeStopLoss, SQLBaseModel, SQLAlchemyModelExtension):
+    """
+    SQLTradeStopLoss model
+
+    A trade stop loss is a stop loss strategy for a trade.
+
+    Attributes:
+     - trade (Trade): the trade that the take profit is for
+     - percentage (float): the stop loss percentage
+     - trailing (bool): indicates whether the stop loss is trailing
+     - sell_percentage (float) the percentage of the trade to sell
+        when the stop loss is triggered.
+    - open_price (float): the price at which the trade was opened.
+    - high_water_mark (float): the highest price reached since the trade
+        was opened.
+    - high_water_mark_date (String): the date when the high water mark
+        was reached.
+    - stop_loss_price (float): the calculated stop loss price based on
+        the high watermark and percentage.
+    - sell_prices (String): a serialized list of prices at which
+        stop losses were executed.
+    - sell_dates (String): a serialized list of dates when
+        stop losses were executed.
+    - sell_amount (float): the total amount sold due to stop losses.
+    - sold_amount (float): the total amount that has been sold due
+        to stop losses.
+    - active (bool): indicates whether the stop loss is currently active.
+    """
+
+    __tablename__ = "trade_stop_losses"
+    id = Column(Integer, primary_key=True, unique=True)
+    trade_id = Column(Integer, ForeignKey('trades.id'))
+    trade = relationship('SQLTrade', back_populates='stop_losses')
+    trailing = Column(Boolean)
+    percentage = Column(Float)
+    sell_percentage = Column(Float)
+    open_price = Column(Float)
+    high_water_mark = Column(Float)
+    high_water_mark_date = Column(String)
+    stop_loss_price = Column(Float)
+    sell_prices = Column(String)
+    sell_dates = Column(String)
+    sell_amount = Column(Float)
+    sold_amount = Column(Float)
+    active = Column(Boolean)
+    triggered = Column(Boolean, default=False)
+    triggered_at = Column(DateTime, default=None)
+    created_at = Column(DateTime)
+    updated_at = Column(DateTime, default=None)