Simulations

# List all available cached simulations
cached = client.simulation.list_cached()
print(f"Found {cached['total']} simulation groups")

for sim in cached["simulations"]:
    print(f"{sim['symbol']} {sim['date']} {sim['scenario']}: {sim['n_runs']} runs")
    print(f"  sim_id: {sim['example_sim_id']}")

# Filter by symbol
cached = client.simulation.list_cached(symbol="700.HK")

# Filter by scenario
cached = client.simulation.list_cached(scenario="flash_crash")

# Find a cached simulation
cached = client.simulation.list_cached(symbol="700.HK", scenario="normal")
sim_id = cached["simulations"][0]["example_sim_id"]

# Download full simulation data
df = client.simulation.get_sim_data(sim_id)
print(df.head())

# Download mid-price series
mid_df = client.simulation.get_sim_data(sim_id, "mid_price_by_min.parquet")

result = client.simulation.run(
    symbol="9999.HK",
    cal_date="2025-09-01",
    n_runs=10
)

job_id = result["job_id"]
sim_ids = result["queued_sim_ids"]
print(f"Submitted job {job_id} with {len(sim_ids)} simulations")

result = client.simulation.run(
    symbol="9999.HK",
    cal_date="2025-09-01",
    n_runs=20,
    scenario="flash_crash",
    scenario_params={
        "start_time": "11:00:00",
        "impact_multiplier": 15.0
    }
)

result = client.simulation.run(
    symbol="9999.HK",
    cal_date="2025-09-01",
    n_runs=50,
    exec_algos=[{
        "type": "twap",
        "order_size": 50000,              # Total volume to execute
        "horizon": "02:00:00",            # Execution window (HH:MM:SS)
        "start_time": "09:30:00",         # Optional, defaults to market open
        "frequency": "00:00:30",          # Optional, default 1s
        "side": "sell",                   # Optional, inferred from order_size sign
        "random_offset": True             # Optional, default True
    }]
)

result = client.simulation.run(
    symbol="9999.HK",
    cal_date="2025-09-01",
    n_runs=50,
    exec_algos=[{
        "type": "vwap",
        "order_size": 100000,
        "horizon": "02:00:00",
        "start_time": "10:00:00",
        "frequency": "00:00:30",
        "random_offset": True
    }]
)

import numpy as np
import pandas as pd
from datetime import date, datetime

def make_schedule(total_shares, start_t, end_t, cal_date, target_clip=100):
    """Distribute total_shares evenly across a datetime window."""
    start_dt = datetime.combine(cal_date, start_t)
    end_dt   = datetime.combine(cal_date, end_t)

    n_orders = int(np.ceil(total_shares / target_clip))
    idx = pd.date_range(start=start_dt, end=end_dt, periods=n_orders)

    # Spread remainder across first orders so total is exact
    q, r = divmod(total_shares, n_orders)
    sizes = np.full(n_orders, q, dtype=int)
    sizes[:r] += 1

    return pd.Series(sizes, index=idx)

cal_date = date(2025, 9, 1)
schedule = make_schedule(
    total_shares=10_000,
    start_t=datetime.strptime("09:30", "%H:%M").time(),
    end_t=datetime.strptime("12:00", "%H:%M").time(),
    cal_date=cal_date,
)

print(schedule)
print(f"Orders: {len(schedule)}, Total shares: {int(schedule.sum())}")

2025-09-01 09:30:00.000000000    100
2025-09-01 09:31:30.909090909    100
2025-09-01 09:33:01.818181818    100
2025-09-01 09:34:32.727272727    100
2025-09-01 09:36:03.636363636    100
                                 ...
2025-09-01 11:56:57.272727272    100
2025-09-01 11:58:28.181818181    100
2025-09-01 11:59:59.090909090    100
2025-09-01 12:00:00.000000000    100
dtype: int64

Orders: 100, Total shares: 10000

result = client.simulation.run(
    symbol="9999.HK",
    cal_date="2025-09-01",
    n_runs=10,
    exec_algos=[{
        "type": "css",
        "orders": schedule
    }]
)

from datetime import time

# Build a grid of execution windows to compare
windows = [
    (time(9, 30),  time(12, 0)),   # full morning
    (time(9, 30),  time(16, 0)),   # full day
    (time(13, 0),  time(16, 0)),   # full afternoon
]

exec_algos = [
    {"type": "css", "orders": make_schedule(10_000, s, e, cal_date)}
    for s, e in windows
]

result = client.simulation.run(
    symbol="9999.HK",
    cal_date="2025-09-01",
    n_runs=10,
    exec_algos=exec_algos,
)

# sim_ids are ordered: baseline[0:n_runs], strategy_0[n_runs:2*n_runs], ...
sim_ids = result["queued_sim_ids"]

status = client.simulation.get_job_status(job_id)

print(f"Total: {status['total_simulations']}")
print(f"Status: {status['status_summary']}")
print(f"Complete: {status['is_complete']}")

import time

result = client.simulation.run(
    symbol="9999.HK",
    cal_date="2025-09-01",
    n_runs=10
)
job_id = result["job_id"]

while True:
    status = client.simulation.get_job_status(job_id)
    summary = status.get("status_summary", {})
    completed = summary.get("complete", 0) + summary.get("completed", 0)
    total = status.get("total_simulations", len(sim_ids))
    print(f"
  {completed}/{total} complete", end="", flush=True)
    if status.get("is_complete"):
        break

    time.sleep(30)  # Check every 30 seconds

result = client.simulation.get_jobs()

print(f"You have {result['total']} jobs")

for job in result["jobs"]:
    print(f"Job {job['job_id']}")
    print(f"  Simulations: {len(job['sim_ids'])}")
    print(f"  Created: {job['created_at']}")

results = client.simulation.get_job_results(job_id)

print(f"Completed: {results['completed']}/{results['total_simulations']}")

for sim in results["simulations"]:
    if sim["status"] == "completed":
        print(f"Sim {sim['sim_id']}")
        print(f"  Files: {sim['available_files']}")
        print(f"  Metrics: {sim['metrics']}")

{symbol}:{cal_date}:{cal_hash}:{time}:{sim_hash}:{scenario}_{hash}:{algo}:{run}