- Algorithm status iterator

- Add example for running algorithm as iterator
- Add objects instead of dicts in result Dataframe
- Add max_leverage parameter

Signed-off-by: Nikola Losic <nikolalosic@protonmail.ch>

Author: nikolalosic

examples/algorithms/test_algo/test_algo.py

@@ -38,5 +38,7 @@ async def handle_data(context, data):
     num_assets = len(context.assets)
     target_percent = 1.0 / num_assets
     for asset in context.assets:
-        await context.order_target_percent(asset=asset,
-                                           target=target_percent, style=MarketOrder())
+        # await context.order_target_percent(asset=asset,
+        #                                    target=target_percent, style=MarketOrder())
+        await context.order_target(asset=asset,
+                                           target=0.1, style=MarketOrder())

examples/run_simulation_daily.py

@@ -83,10 +83,23 @@ async def _run_simulation():
         logger.error(result.errors)
     print(result.perf.head(n=10).to_markdown())
 
+    cash_flow = {"date": [], "cash_change": [], "cash_left": []}
+
+
     # Get cash from algo
     start_cash = sum(exchange.get_start_cash_balance() for exchange in result.trading_algorithm.exchanges.values())
     logger.info(f"Starting_cash: {start_cash}")
 
+    for transaction_freq in result.perf.transactions:
+        for transaction in transaction_freq:
+            print(transaction)
+            start_cash -=  transaction.total_price()
+            cash_flow["date"].append(transaction.dt)
+            cash_flow["cash_change"].append(-transaction.total_price())
+            cash_flow["cash_left"].append(start_cash)
+
+    cash_flow_df = pl.DataFrame(data=cash_flow)
+    print(cash_flow)
 
 if __name__ == "__main__":
     configure_logging(level=logging.INFO, file_name="mylog.log")

examples/run_simulation_iter_daily.py

@@ -0,0 +1,93 @@
+import asyncio
+import datetime
+import logging
+import pathlib
+
+import polars as pl
+import structlog
+
+from ziplime.utils.bundle_utils import get_bundle_service
+from ziplime.utils.logging_utils import configure_logging
+
+from pathlib import Path
+
+import pytz
+
+from ziplime.core.ingest_data import get_asset_service
+from ziplime.core.run_simulation import run_simulation_iter
+from ziplime.finance.commission import PerShare, DEFAULT_PER_SHARE_COST, DEFAULT_MINIMUM_COST_PER_EQUITY_TRADE
+
+logger = structlog.get_logger(__name__)
+
+
+async def _run_simulation():
+    start_date = datetime.datetime(year=2025, month=1, day=3, tzinfo=pytz.timezone("America/New_York"))
+    end_date = datetime.datetime(year=2025, month=2, day=1, tzinfo=pytz.timezone("America/New_York"))
+
+    bundle_service = get_bundle_service()
+
+    asset_service = get_asset_service(
+        clear_asset_db=False,
+        db_path=str(pathlib.Path(__file__).parent.parent.resolve().joinpath("data", "assets.sqlite"))
+    )
+    # Use aggregations if you ingested data of frequnecy less than 1 day
+    aggregations = [
+        pl.col("open").first(),
+        pl.col("high").max(),
+        pl.col("low").min(),
+        pl.col("close").last(),
+        pl.col("volume").sum(),
+        pl.col("symbol").last()
+    ]
+    market_data_bundle = await bundle_service.load_bundle(bundle_name="limex_us_minute_data",
+                                                          bundle_version=None,
+                                                          frequency=datetime.timedelta(days=1),
+                                                          start_date=start_date,
+                                                          end_date=end_date,
+                                                          symbols=["META", "AAPL", "AMZN", "NFLX", "GOOGL",
+                                                                   ],
+                                                          start_auction_delta=datetime.timedelta(minutes=15),
+                                                          end_auction_delta=datetime.timedelta(minutes=15),
+                                                          aggregations=aggregations,
+                                                          )
+
+    custom_data_sources = []
+    # custom_data_sources.append(
+    #     await bundle_service.load_bundle(bundle_name="limex_us_fundamental_data", bundle_version=None))
+
+    equity_commission = PerShare(
+        cost=DEFAULT_PER_SHARE_COST,
+        min_trade_cost=DEFAULT_MINIMUM_COST_PER_EQUITY_TRADE,
+
+    )
+
+    # run daily simulation
+    async for status in run_simulation_iter(
+            start_date=start_date,
+            end_date=end_date,
+            trading_calendar="NYSE",
+            algorithm_file=str(Path("algorithms/test_algo/test_algo.py").absolute()),
+            total_cash=100000.0,
+            market_data_source=market_data_bundle,
+            custom_data_sources=custom_data_sources,
+            config_file=str(Path("algorithms/test_algo/test_algo_config.json").absolute()),
+            emission_rate=datetime.timedelta(days=1),
+            benchmark_asset_symbol="AAPL",
+            benchmark_returns=None,
+            stop_on_error=True,
+            asset_service=asset_service,
+            equity_commission=equity_commission
+    ):
+        print(status)
+        if status.errors:
+            logger.error(status.errors)
+        if status.result:
+            logger.info("Algorithm finished")
+        # print(status.perf.head(n=10).to_markdown())
+
+    # Get cash from algo
+
+
+if __name__ == "__main__":
+    configure_logging(level=logging.INFO, file_name="mylog.log")
+    asyncio.run(_run_simulation())