Running in professional mode

import horizon as hz
from horizon.accounts import (
    Account, AccountRegistry, AccountSubType, Custodian,
    InvestmentPolicyStatement,
)
from horizon.asset_classes import AssetClass
from horizon.audit import AuditLog, SQLiteSink
from horizon.risk.buckets import BucketLimits
from horizon.risk.config import RiskConfig

# One-time setup (do at process start)
custodian = Custodian(
    custodian_id="cust_schwab", display_name="Schwab Advisor Services",
    venue_name="schwab",
)
ips = InvestmentPolicyStatement(
    allowed_asset_classes=frozenset([AssetClass.Equity]),
    excluded_tickers=frozenset({"TSLA"}),
    max_pct_single_issuer=0.10,
    allow_shorts=False,
    allow_margin=False,
    max_drawdown_pct=0.20,
)
account = Account(
    account_id="acc_jane_taxable",
    sub_type=AccountSubType.SMA,
    display_name="Jane Taxable",
    client_id="cli_jane",
    custodian_id="cust_schwab",
    venue_name="schwab",
    ips=ips,
    asset_class_allowlist=frozenset([AssetClass.Equity]),
)
registry = AccountRegistry()
registry.add_custodian(custodian)
registry.add_account(account)

audit_log = AuditLog(sink=SQLiteSink("audit.db"))

risk = RiskConfig()
risk.buckets = BucketLimits(
    max_notional_per_issuer_usd=50_000,
    max_pct_per_sector=0.30,
    max_size_pct_of_adv=0.01,
)
risk.per_order.max_price_band_bps = 500
risk.per_order.max_spread_bps = 500
risk.per_order.max_feed_age_seconds = 15

result = hz.run(
    mode="backtest",
    strategies=[MyStrategy],
    asset_classes=[AssetClass.Equity],
    universe=["AAPL", "MSFT", "NVDA"],
    risk=risk,
    accounts=registry,
    audit_log=audit_log,
)

result = hz.run(..., accounts=registry, audit_log=audit_log)

for account_id, book in result.lot_books.items():
    print(f"Account {account_id}")
    print(f"  Open lots: {len(book.open_lots())}")
    print(f"  Realized P&L: ${book.realized_pnl():,.2f}")

for adj in result.wash_sale_adjustments:
    print(f"  wash sale: ${adj.disallowed_loss:,.2f} "
          f"carried from {adj.closed_lot_id} -> {adj.replacement_lot_id}")

for account_id, trades in result.day_trades.items():
    print(f"Account {account_id}: {len(trades)} day trades")

for lot in book.closed_lots():
    print(f"  {lot.market_id}: {lot.quantity} @ ${lot.acquired_price:.2f} "
          f"-> ${lot.closed_price:.2f}, realized ${lot.realized_pnl:.2f}, "
          f"long-term: {lot.is_long_term}, wash: {lot.was_wash_sale}")

from horizon.execution.locates import EasyToBorrowListProvider

etb = EasyToBorrowListProvider(
    etb={"AAPL", "MSFT", "GOOG", "AMZN"},   # daily firm ETB list
    default_borrow_fee_bps=25.0,
)

result = hz.run(
    ...,
    accounts=registry,
    audit_log=audit_log,
    locates=etb,
)

result = hz.run(..., detect_wash_sales=False)

from horizon.audit import AuditCategory, AuditChain

events = list(audit_log._sink.read_range())

# Verify the hash chain is intact
broken = AuditChain.verify(events)
assert broken == [], f"chain corrupted at {broken}"

passes = [e for e in events if e.category == AuditCategory.RiskDecision
          and e.payload.get("kind") == "pass"]
rejects = [e for e in events if e.category == AuditCategory.RiskDecision
           and e.payload.get("kind") == "reject"]

from collections import Counter
by_layer = Counter(e.payload.get("layer") for e in rejects)
# Counter({'ips': 8, 'buckets': 12, 'nbbo': 3, 'buying_power': 1})

ips_rejects = [e for e in rejects if e.payload.get("layer") == "ips"]
for e in ips_rejects[:3]:
    print(e.timestamp, e.market_id, e.message)

  result = hz.run(
      mode="backtest",
      strategies=[MyStrategy],
      universe=[...],
+     accounts=registry,
+     audit_log=audit_log,
  )

from horizon.execution.allocation import RotationalAllocator

result = hz.run(
    ...,
    accounts=registry,              # 2 or more accounts
    allocator=RotationalAllocator(),
    audit_log=audit_log,
)

result = hz.run(
    mode="live",
    feed=my_live_feed,
    strategies=[MyStrategy],
    accounts=registry,
    audit_log=audit_log,
    max_duration_s=3600,
)