#![allow(unexpected_cfgs, clippy::useless_conversion)]
use pyo3::prelude::*;
use pyo3::types::PyDict;
pub const SEED_RANGE: &str = "an integer from 0 to 2**64 - 1 (18446744073709551615)";
pub(crate) fn seed_from(value: &Bound<'_, PyAny>, name: &str) -> PyResult<u64> {
let refuse = |what: String| {
ValidationError::new_err(format!("{name} must be {SEED_RANGE}, got {what}"))
};
let shown = || -> String {
value.repr().map(|r| r.to_string()).unwrap_or_else(|_| "?".to_string())
};
let type_name = || -> String {
value.get_type().name().map(|n| n.to_string()).unwrap_or_else(|_| "?".to_string())
};
if value.is_instance_of::<pyo3::types::PyBool>() {
return Err(refuse(format!("{}, a bool", shown())));
}
match value.extract::<u64>() {
Ok(seed) => Ok(seed),
Err(e) if e.is_instance_of::<pyo3::exceptions::PyOverflowError>(value.py()) => {
Err(refuse(shown()))
}
Err(_) => Err(refuse(format!("{}, a {}", shown(), type_name()))),
}
}
pub(crate) fn case_hint(given: &str, valid: &[&str], note: &str) -> String {
match valid
.iter()
.find(|v| **v != given && v.eq_ignore_ascii_case(given))
{
Some(v) => format!(" Did you mean {v:?}? {note}"),
None => String::new(),
}
}
pub(crate) fn unknown_preset(name: &str) -> String {
let names = crate::params::ModelParams::preset_names();
format!(
"unknown model preset {name:?}.{} Shipped presets: {}",
case_hint(name, names, "Preset names are lower case."),
names.join(", ")
)
}
pub(crate) fn unknown_sector(sector: &str) -> String {
format!(
"unknown sector {sector:?}.{} Valid sectors: {}",
case_hint(sector, &crate::sectors::keys(), "Sector names are lower case."),
crate::sectors::keys().join(", ")
)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) struct Seed(pub u64);
impl<'py> FromPyObject<'py> for Seed {
fn extract_bound(value: &Bound<'py, PyAny>) -> PyResult<Self> {
seed_from(value, "seed").map(Seed)
}
}
pub(crate) enum Given<'py> {
Missing,
Value(Bound<'py, PyAny>),
}
impl<'py> FromPyObject<'py> for Given<'py> {
fn extract_bound(value: &Bound<'py, PyAny>) -> PyResult<Self> {
Ok(Given::Value(value.clone()))
}
}
#[pyfunction]
#[pyo3(signature = (value, name = "seed"))]
fn check_seed(value: &Bound<'_, PyAny>, name: &str) -> PyResult<u64> {
seed_from(value, name)
}
#[pyclass(name = "GameRng", module = "tradefloor._core")]
pub struct PyGameRng {
inner: crate::GameRng,
}
#[pymethods]
impl PyGameRng {
#[new]
fn new(seed: Seed, sequence: u32) -> Self {
Self {
inner: crate::GameRng::new(seed.0, sequence),
}
}
fn next_float(&mut self) -> f64 {
self.inner.next_f64()
}
fn next_normal(&mut self) -> f64 {
self.inner.next_normal()
}
fn next_int(&mut self, min: i64, max: i64) -> i64 {
self.inner.next_int(min, max)
}
fn next_bool(&mut self, p: f64) -> bool {
self.inner.next_bool(p)
}
fn __copy__(&self) -> Self {
Self {
inner: self.inner.clone(),
}
}
fn __deepcopy__(&self, _memo: &Bound<'_, PyAny>) -> Self {
self.__copy__()
}
fn __repr__(&self) -> String {
"GameRng(...)".to_string()
}
}
pyo3::create_exception!(
_core,
ValidationError,
pyo3::exceptions::PyValueError,
"Raised when construction input is rejected at the boundary. Subclasses \
ValueError, so `except ValueError` keeps working while the specific type \
is available to callers who want it. The taxonomy is deliberately tiny: \
a simulator that invents an error type per field teaches users to catch \
Exception, which catches the bugs too."
);
#[pyfunction]
#[pyo3(signature = (*, size, universe_seed, seed, days, ticks, preset))]
fn fixed_simulation_digest(size: usize, universe_seed: &Bound<'_, PyAny>, seed: Seed,
days: usize, ticks: usize, preset: &str)
-> PyResult<String> {
let universe_seed = seed_from(universe_seed, "universe_seed")?;
crate::engine::fixed_simulation_digest(
size, universe_seed, seed.0, days, ticks, preset)
.ok_or_else(|| ValidationError::new_err(
format!("unknown preset {preset:?}")))
}
#[pyfunction]
fn version() -> &'static str {
env!("CARGO_PKG_VERSION")
}
#[pyfunction]
fn parse_contract_symbol<'py>(py: Python<'py>, symbol: &str) -> PyResult<Bound<'py, PyDict>> {
let parsed = crate::derivatives::ContractSymbol::parse(symbol).map_err(ValidationError::new_err)?;
contract_symbol_dict(py, &parsed)
}
#[pyfunction]
#[pyo3(signature = (root, expiry, right = None, strike = None))]
fn format_contract_symbol(root: &str, expiry: i64, right: Option<&str>, strike: Option<f64>) -> PyResult<String> {
use crate::derivatives::{ContractSymbol, Right};
let symbol = match (right, strike) {
(None, None) => ContractSymbol::future(root, expiry),
(Some(r), Some(k)) => {
let right = match r {
"C" => Right::Call,
"P" => Right::Put,
other => {
return Err(ValidationError::new_err(format!(
"an option's right is \"C\" or \"P\", got {other:?}"
)))
}
};
ContractSymbol::option(root, expiry, right, k)
}
_ => {
return Err(ValidationError::new_err(
"an option needs both right and strike, and a future neither".to_string(),
))
}
};
symbol.map(|s| s.to_string()).map_err(ValidationError::new_err)
}
fn contract_symbol_dict<'py>(
py: Python<'py>,
s: &crate::derivatives::ContractSymbol,
) -> PyResult<Bound<'py, PyDict>> {
use crate::derivatives::SymbolKind;
let d = PyDict::new_bound(py);
d.set_item("symbol", s.to_string())?;
d.set_item("root", &s.root)?;
d.set_item("expiry", s.expiry)?;
match s.kind {
SymbolKind::Option { right, .. } => {
d.set_item("kind", "option")?;
d.set_item("right", right.letter().to_string())?;
d.set_item("strike", s.strike())?;
}
_ => {
d.set_item("kind", "future")?;
d.set_item("right", py.None())?;
d.set_item("strike", py.None())?;
}
}
Ok(d)
}
#[pyfunction]
fn check_rate(name: &str, fraction: f64) -> PyResult<f64> {
crate::units::check_rate(name, fraction).map_err(ValidationError::new_err)
}
#[pymodule]
fn _core(m: &Bound<'_, PyModule>) -> PyResult<()> {
m.add_class::<PyGameRng>()?;
m.add_function(wrap_pyfunction!(version, m)?)?;
m.add_function(wrap_pyfunction!(parse_contract_symbol, m)?)?;
m.add_function(wrap_pyfunction!(format_contract_symbol, m)?)?;
m.add_function(wrap_pyfunction!(fixed_simulation_digest, m)?)?;
m.add_function(wrap_pyfunction!(check_rate, m)?)?;
m.add_function(wrap_pyfunction!(check_seed, m)?)?;
m.add_function(wrap_pyfunction!(fair_value, m)?)?;
m.add_function(wrap_pyfunction!(sectors, m)?)?;
m.add_function(wrap_pyfunction!(step_mispricing_daily, m)?)?;
m.add_function(wrap_pyfunction!(apply_mispricing, m)?)?;
m.add_function(wrap_pyfunction!(characteristic_root_moduli, m)?)?;
m.add_function(wrap_pyfunction!(crowd_adjusted_root_moduli, m)?)?;
m.add_function(wrap_pyfunction!(impulse_response, m)?)?;
m.add_function(wrap_pyfunction!(model_preset, m)?)?;
m.add_function(wrap_pyfunction!(preset_names, m)?)?;
m.add_function(wrap_pyfunction!(calibrated_flow, m)?)?;
m.add_function(wrap_pyfunction!(assess_external_flow, m)?)?;
m.add_class::<PyMispricingState>()?;
m.add_class::<PyFairValue>()?;
m.add_class::<crate::python_book::PyOrderBook>()?;
m.add_class::<crate::python_book::PyFill>()?;
m.add_class::<crate::python_book::PyMatchResult>()?;
m.add_class::<crate::python_book::PyPriceLevel>()?;
m.add_class::<crate::python_book::PySweepCost>()?;
m.add_class::<crate::python_params::PyModelParams>()?;
m.add_class::<crate::python_engine::PyEngine>()?;
m.add_class::<crate::python_engine::PySurface>()?;
m.add_class::<crate::python_engine::PyInstrument>()?;
m.add_class::<crate::python_engine::PyMacro>()?;
m.add_class::<crate::python_engine::PyTickResult>()?;
m.add_class::<crate::python_batch::PyEngineBatch>()?;
m.add_class::<crate::python_engine::PyNews>()?;
m.add_class::<crate::python_engine::PyNewsImpact>()?;
m.add_class::<crate::python_arrow::PyArrowStream>()?;
m.add_function(wrap_pyfunction!(crate::python_arrow::fills_stream, m)?)?;
m.add_function(wrap_pyfunction!(crate::python_engine::market_status, m)?)?;
m.add_function(wrap_pyfunction!(crate::python_engine::random_instruments, m)?)?;
m.add_function(wrap_pyfunction!(crate::python_engine::rate_instruments, m)?)?;
m.add_function(wrap_pyfunction!(crate::python_engine::rate_specs, m)?)?;
m.add_function(wrap_pyfunction!(crate::python_engine::sector_volatility, m)?)?;
m.add_function(wrap_pyfunction!(crate::python_engine::sector_daily_sigma, m)?)?;
m.add_function(wrap_pyfunction!(crate::python_engine::stationary_sigma, m)?)?;
m.add_function(wrap_pyfunction!(crate::python_engine::crisis_epicentre_solve, m)?)?;
m.add("ValidationError", m.py().get_type_bound::<ValidationError>())?;
m.add(
"OrderError",
m.py().get_type_bound::<crate::python_book::OrderError>(),
)?;
m.add("__version__", env!("CARGO_PKG_VERSION"))?;
Ok(())
}
#[pyclass(name = "FairValue", module = "tradefloor._core", frozen, get_all)]
#[derive(Debug, Clone, Copy)]
pub struct PyFairValue {
pub fair_value: f64,
pub target_pe: f64,
pub sector_anchor_pe: f64,
pub rate_adjustment: f64,
pub qe_adjustment: f64,
pub book_value_path: bool,
}
#[pymethods]
impl PyFairValue {
fn __repr__(&self) -> String {
format!(
"FairValue(fair_value={:.4}, target_pe={:.4}, book_value_path={})",
self.fair_value, self.target_pe, self.book_value_path
)
}
}
#[pyfunction]
#[pyo3(signature = (
*,
eps = None,
sector,
revenue_growth = None,
federal_funds_rate = 0.0,
corporate_bond_yield = None,
qe_pe_boost = None,
book_value_per_share = None,
neutral_discount_rate = None,
qe_assets_ratio = None,
qe_pe_gain = None,
qe_pe_stock_gain = None,
rate_pe_sensitivity = None,
fair_value_book_floor = None,
model = None,
))]
#[allow(clippy::too_many_arguments)]
fn fair_value(
eps: Option<f64>,
sector: &str,
revenue_growth: Option<f64>,
federal_funds_rate: f64,
corporate_bond_yield: Option<f64>,
qe_pe_boost: Option<f64>,
book_value_per_share: Option<f64>,
neutral_discount_rate: Option<f64>,
qe_assets_ratio: Option<f64>,
qe_pe_gain: Option<f64>,
qe_pe_stock_gain: Option<f64>,
rate_pe_sensitivity: Option<f64>,
fair_value_book_floor: Option<f64>,
model: Option<&Bound<'_, PyAny>>,
) -> PyResult<PyFairValue> {
use ValidationError as Rejected;
let s = crate::sectors::by_key(sector).ok_or_else(|| {
Rejected::new_err(crate::python::unknown_sector(sector))
})?;
for (name, value) in [
("eps", eps),
("book_value_per_share", book_value_per_share),
("revenue_growth", revenue_growth),
("qe_pe_boost", qe_pe_boost),
("qe_assets_ratio", qe_assets_ratio),
("qe_pe_gain", qe_pe_gain),
("qe_pe_stock_gain", qe_pe_stock_gain),
("rate_pe_sensitivity", rate_pe_sensitivity),
("fair_value_book_floor", fair_value_book_floor),
] {
if let Some(v) = value {
if !v.is_finite() {
return Err(Rejected::new_err(format!(
"{name} must be finite, got {v}"
)));
}
}
}
crate::units::check_rate("federal_funds_rate", federal_funds_rate)
.map_err(Rejected::new_err)?;
if let Some(y) = corporate_bond_yield {
crate::units::check_rate("corporate_bond_yield", y).map_err(Rejected::new_err)?;
}
if let Some(r) = neutral_discount_rate {
crate::units::check_rate("neutral_discount_rate", r).map_err(Rejected::new_err)?;
}
let explicit = [
("neutral_discount_rate", neutral_discount_rate),
("qe_pe_gain", qe_pe_gain),
("qe_pe_stock_gain", qe_pe_stock_gain),
("rate_pe_sensitivity", rate_pe_sensitivity),
("fair_value_book_floor", fair_value_book_floor),
];
let (neutral, qe_gain, qe_stock_gain, sensitivity, book_floor) = match model {
Some(m) => {
let both: Vec<&str> = explicit
.iter()
.filter(|(_, v)| v.is_some())
.map(|(name, _)| *name)
.collect();
if !both.is_empty() {
return Err(Rejected::new_err(format!(
"model and {} were both given, and the model carries {}. Pass \
the model alone, or a ModelParams built with the value you want \
(ModelParams.from_preset(name, {}=...)).",
both.join(", "),
if both.len() == 1 { "it" } else { "them" },
both[0]
)));
}
let p = crate::python_engine::model_params_from(Some(m))?;
(p.neutral_discount_rate, p.qe_pe_gain, p.qe_pe_stock_gain,
p.rate_pe_sensitivity, p.fair_value_book_floor)
}
None => (
neutral_discount_rate.unwrap_or(crate::fair_value::NEUTRAL_DISCOUNT_RATE),
qe_pe_gain.unwrap_or(1.0),
qe_pe_stock_gain.unwrap_or(0.0),
rate_pe_sensitivity.unwrap_or(crate::fair_value::RATE_PE_SENSITIVITY),
fair_value_book_floor.unwrap_or(0.0),
),
};
let economy = crate::fair_value::EconomyValuationInputs {
corporate_bond_yield: corporate_bond_yield.map(crate::units::fraction_to_percent),
federal_funds_rate: crate::units::fraction_to_percent(federal_funds_rate),
qe_pe_boost,
qe_assets_ratio,
};
let company = crate::fair_value::CompanyValuationInputs {
sector_avg_pe: Some(s.avg_pe),
eps,
book_value_per_share,
revenue_growth,
};
let b = crate::fair_value::compute_fair_value_at(
&company, &economy, book_floor, qe_gain, qe_stock_gain, neutral, sensitivity,
);
Ok(PyFairValue {
fair_value: b.fair_value,
target_pe: b.target_pe,
sector_anchor_pe: b.sector_anchor_pe,
rate_adjustment: b.rate_adjustment,
qe_adjustment: b.qe_adjustment,
book_value_path: b.book_value_path,
})
}
#[pyfunction]
fn sectors() -> Vec<String> {
crate::sectors::keys().iter().map(|s| s.to_string()).collect()
}
#[pyclass(name = "MispricingState", module = "tradefloor._core", frozen, get_all)]
#[derive(Debug, Clone, Copy)]
pub struct PyMispricingState {
pub s: f64,
pub s_prev: f64,
}
#[pymethods]
impl PyMispricingState {
#[new]
#[pyo3(signature = (s = 0.0, s_prev = None))]
fn new(s: f64, s_prev: Option<f64>) -> PyResult<Self> {
for (name, v) in [("s", Some(s)), ("s_prev", s_prev)] {
if let Some(v) = v {
if !v.is_finite() {
return Err(ValidationError::new_err(format!(
"{name} must be finite, got {v}"
)));
}
}
}
match s_prev {
Some(prev) => Ok(Self { s, s_prev: prev }),
None => {
let st = crate::mispricing::create_mispricing_state(s);
Ok(Self { s: st.s, s_prev: st.s_prev })
}
}
}
fn __repr__(&self) -> String {
format!("MispricingState(s={}, s_prev={})", self.s, self.s_prev)
}
}
#[pyfunction]
#[pyo3(signature = (state, *, innovation = 0.0, shock = 0.0))]
fn step_mispricing_daily(
state: &PyMispricingState,
innovation: f64,
shock: f64,
) -> PyResult<PyMispricingState> {
for (name, v) in [("innovation", innovation), ("shock", shock)] {
if !v.is_finite() {
return Err(ValidationError::new_err(format!(
"{name} must be finite, got {v}"
)));
}
}
let next = crate::mispricing::step_mispricing(
&crate::mispricing::MispricingState { s: state.s, s_prev: state.s_prev },
&crate::mispricing::MispricingInputs { innovation, shock },
);
Ok(PyMispricingState { s: next.s, s_prev: next.s_prev })
}
#[pyfunction]
fn apply_mispricing(fair_value: f64, s: f64) -> f64 {
crate::mispricing::apply_mispricing(fair_value, s)
}
#[pyfunction]
#[pyo3(signature = (phi = None, theta = None))]
fn characteristic_root_moduli(phi: Option<f64>, theta: Option<f64>) -> (f64, f64) {
crate::mispricing::characteristic_root_moduli(phi, theta)
}
#[pyfunction]
fn crowd_adjusted_root_moduli() -> (f64, f64) {
crate::mispricing::crowd_adjusted_root_moduli()
}
#[pyfunction]
#[pyo3(signature = (horizon_days, phi = None, theta = None))]
fn impulse_response(horizon_days: i64, phi: Option<f64>, theta: Option<f64>) -> PyResult<Vec<f64>> {
if horizon_days < 0 {
return Err(ValidationError::new_err(format!(
"horizon_days must be >= 0, got {horizon_days}"
)));
}
Ok(crate::mispricing::impulse_response(horizon_days, phi, theta))
}
#[pyfunction]
#[pyo3(signature = (name = None))]
fn model_preset(py: Python<'_>, name: Option<&str>) -> PyResult<PyObject> {
use crate::mispricing as m;
let name = name.unwrap_or(crate::params::DEFAULT_PRESET_NAME);
let preset = crate::params::ModelParams::preset(name).ok_or_else(|| {
ValidationError::new_err(crate::python::unknown_preset(name))
})?;
let d = pyo3::types::PyDict::new_bound(py);
d.set_item("name", name)?;
d.set_item(
"mispricing_half_life_days",
preset.mispricing_half_life_days,
)?;
d.set_item("mispricing_phi", preset.mispricing_phi)?;
d.set_item("momentum_theta", preset.momentum_theta)?;
d.set_item("mispricing_cap", preset.mispricing_cap)?;
d.set_item("daily_shock_cap", m::DAILY_SHOCK_CAP)?;
d.set_item("crowd_valuation_gain", preset.crowd_valuation_gain)?;
d.set_item("crowd_momentum_gain", preset.crowd_momentum_gain)?;
d.set_item("crowd_lean_cap", preset.crowd_lean_cap)?;
Ok(d.into())
}
#[pyfunction]
#[pyo3(signature = (model = None))]
fn calibrated_flow(
py: Python<'_>,
model: Option<&Bound<'_, PyAny>>,
) -> PyResult<PyObject> {
let params = crate::python_engine::model_params_from(model)?;
let f = crate::flow::CalibratedFlow::of(¶ms);
let d = pyo3::types::PyDict::new_bound(py);
d.set_item("company_news_rate", f.company_news_rate)?;
d.set_item("company_news_sigma", f.company_news_sigma)?;
d.set_item("company_news_variance", f.company_news_variance())?;
d.set_item("sector_news_rate", f.sector_news_rate)?;
d.set_item("market_news_rate", f.market_news_rate)?;
d.set_item("news_sector_weight", f.news_sector_weight)?;
d.set_item("news_market_weight", f.news_market_weight)?;
d.set_item("idio_jump_rate", f.idio_jump_rate)?;
d.set_item("idio_jump_sigma", f.idio_jump_sigma)?;
d.set_item("market_jump_rate", f.market_jump_rate)?;
d.set_item("market_jump_mean", f.market_jump_mean)?;
d.set_item("market_jump_sigma", f.market_jump_sigma)?;
d.set_item("market_factor_sigma", f.market_factor_sigma)?;
d.set_item("macro_shock_share", f.macro_shock_share)?;
d.set_item("macro_steps_per_session", f.macro_steps_per_session)?;
d.set_item("off_session_ticks_per_session", f.off_session_ticks_per_session)?;
d.set_item("news_drift", f.news_drift)?;
for (k, phase) in crate::flow::CYCLE_PHASES.iter().enumerate() {
let name = phase.as_str();
d.set_item(format!("{name}_share"), f.phase_shares[k])?;
d.set_item(format!("{name}_mean_sessions"), f.phase_mean_sessions[k])?;
d.set_item(format!("{name}_sd_sessions"), f.phase_sd_sessions[k])?;
d.set_item(format!("{name}_run_limit"), f.phase_run_limit[k])?;
}
d.set_item("downturn_share", f.downturn_share)?;
d.set_item("downturn_mean_sessions", f.downturn_mean_sessions)?;
d.set_item("downturn_run_limit", f.downturn_run_limit)?;
Ok(d.into_py(py))
}
const FLOW_TALLY_KEYS: [&str; 16] = [
"names", "sessions", "company_events", "company_sum_sq", "sector_events",
"sector_sum_sq", "market_events", "market_sum_sq", "fundamental_events",
"fundamental_sum_sq", "vix_writes", "vix_write_abs", "vix_write_max",
"macro_steps", "macro_shock_steps", "macro_shock_load",
];
const FLOW_TALLY_OPTIONAL_KEYS: [&str; 9] = [
"company_sum", "sector_sum", "market_sum", "fundamental_sum", "off_session_ticks",
"vix_target_writes", "vix_target_write_abs", "vix_target_floor_sessions", "cycle_phases",
];
#[pyfunction]
#[pyo3(signature = (tally, model = None))]
fn assess_external_flow(
py: Python<'_>,
tally: &Bound<'_, pyo3::types::PyDict>,
model: Option<&Bound<'_, PyAny>>,
) -> PyResult<PyObject> {
let params = crate::python_engine::model_params_from(model)?;
for key in tally.keys().iter() {
let k: String = key.extract()?;
if !FLOW_TALLY_KEYS.contains(&k.as_str())
&& !FLOW_TALLY_OPTIONAL_KEYS.contains(&k.as_str())
{
return Err(ValidationError::new_err(format!(
"unknown flow tally key {k:?}; the keys are {FLOW_TALLY_KEYS:?} and, \
optionally, {FLOW_TALLY_OPTIONAL_KEYS:?}")));
}
}
let get = |k: &str| -> PyResult<Bound<'_, PyAny>> {
tally.get_item(k)?.ok_or_else(|| ValidationError::new_err(format!(
"the flow tally needs {k:?}; the keys are {FLOW_TALLY_KEYS:?}")))
};
let count = |k: &str| -> PyResult<u64> {
get(k)?.extract::<u64>().map_err(|_| ValidationError::new_err(format!(
"{k} must be a non-negative integer")))
};
let real = |k: &str| -> PyResult<f64> {
let v: f64 = get(k)?.extract().map_err(|_| ValidationError::new_err(format!(
"{k} must be a number")))?;
if !(v >= 0.0) || !v.is_finite() {
return Err(ValidationError::new_err(format!(
"{k} must be finite and non-negative, got {v}")));
}
Ok(v)
};
let signed = |k: &str| -> PyResult<f64> {
match tally.get_item(k)? {
None => Ok(0.0),
Some(v) => {
let v: f64 = v.extract().map_err(|_| ValidationError::new_err(format!(
"{k} must be a number")))?;
if !v.is_finite() {
return Err(ValidationError::new_err(format!(
"{k} must be finite, got {v}")));
}
Ok(v)
}
}
};
let mut obs = crate::flow::ExternalFlow::new(count("names")? as usize);
obs.company_sum = signed("company_sum")?;
obs.sector_sum = signed("sector_sum")?;
obs.market_sum = signed("market_sum")?;
obs.fundamental_sum = signed("fundamental_sum")?;
let optional_count = |k: &str| -> PyResult<u64> {
match tally.get_item(k)? {
None => Ok(0),
Some(v) => v.extract::<u64>().map_err(|_| ValidationError::new_err(format!(
"{k} must be a non-negative integer"))),
}
};
obs.off_session_ticks = optional_count("off_session_ticks")?;
obs.vix_target_writes = optional_count("vix_target_writes")?;
obs.vix_target_floor_sessions = optional_count("vix_target_floor_sessions")?;
obs.vix_target_write_abs = match tally.get_item("vix_target_write_abs")? {
None => 0.0,
Some(_) => real("vix_target_write_abs")?,
};
obs.sessions = count("sessions")?;
obs.company_events = count("company_events")?;
obs.company_sum_sq = real("company_sum_sq")?;
obs.sector_events = count("sector_events")?;
obs.sector_sum_sq = real("sector_sum_sq")?;
obs.market_events = count("market_events")?;
obs.market_sum_sq = real("market_sum_sq")?;
obs.fundamental_events = count("fundamental_events")?;
obs.fundamental_sum_sq = real("fundamental_sum_sq")?;
obs.vix_writes = count("vix_writes")?;
obs.vix_write_abs = real("vix_write_abs")?;
obs.vix_write_max = real("vix_write_max")?;
obs.macro_steps = count("macro_steps")?;
obs.macro_shock_steps = count("macro_shock_steps")?;
obs.macro_shock_load = real("macro_shock_load")?;
if let Some(v) = tally.get_item("cycle_phases")? {
let names: Vec<String> = v.extract().map_err(|_| ValidationError::new_err(
"cycle_phases must be a list of phase names, one a session"))?;
for name in names {
let phase = crate::economy::CyclePhase::from_name(&name).ok_or_else(|| {
ValidationError::new_err(format!(
"unknown cycle phase {name:?} in cycle_phases; the phases are {:?}",
crate::flow::CYCLE_PHASES.map(|p| p.as_str())))
})?;
obs.record_cycle_phase(phase);
}
}
let a = obs.assess(¶ms);
let d = pyo3::types::PyDict::new_bound(py);
d.set_item("inside", a.inside)?;
d.set_item("company_news_ratio", a.company_news_ratio)?;
d.set_item("common_news_ratio", a.common_news_ratio)?;
d.set_item("fundamental_ratio", a.fundamental_ratio)?;
d.set_item("vix_write_per_session", a.vix_write_per_session)?;
d.set_item("vix_target_per_session", a.vix_target_per_session)?;
d.set_item("vix_target_floor_share", a.vix_target_floor_share)?;
d.set_item("macro_shock_share", a.macro_shock_share)?;
d.set_item("macro_shock_load", a.macro_shock_load)?;
d.set_item("macro_steps_per_session", a.macro_steps_per_session)?;
d.set_item("off_session_ticks_per_session", a.off_session_ticks_per_session)?;
d.set_item("news_drift", a.news_drift)?;
d.set_item("fundamental_drift", a.fundamental_drift)?;
for (k, phase) in crate::flow::CYCLE_PHASES.iter().enumerate() {
d.set_item(format!("{}_share", phase.as_str()), a.phase_shares[k])?;
d.set_item(format!("{}_longest", phase.as_str()), a.phase_longest[k])?;
}
d.set_item("downturn_share", a.downturn_share)?;
d.set_item("downturn_longest", a.downturn_longest)?;
d.set_item("findings", a.findings)?;
Ok(d.into_py(py))
}
#[pyfunction]
fn preset_names() -> Vec<String> {
crate::params::ModelParams::preset_names()
.iter()
.map(|s| (*s).to_string())
.collect()
}