#![allow(unexpected_cfgs, clippy::useless_conversion)]
use pyo3::prelude::*;
use pyo3::types::PyBytes;
use crate::economy::create_initial_central_bank_state;
use crate::engine::{Engine, SessionBuffer, SessionRequest, TickRequest};
use crate::market::{GameTime, TickCompany};
use crate::python::ValidationError;
fn f64_bytes(py: Python<'_>, values: &[f64]) -> Py<PyBytes> {
let mut out = Vec::with_capacity(values.len() * 8);
for v in values {
out.extend_from_slice(&v.to_le_bytes());
}
PyBytes::new_bound(py, &out).into()
}
#[pyclass(name = "EngineBatch", module = "tradefloor._core")]
pub struct PyEngineBatch {
engines: Vec<Engine>,
buffers: Vec<SessionBuffer>,
seeds: Vec<u64>,
tickers: Vec<String>,
market_open: bool,
}
#[pymethods]
impl PyEngineBatch {
#[new]
#[pyo3(signature = (*, seeds, universe, macro_state = None, model = None))]
fn new(
py: Python<'_>,
seeds: Vec<crate::python::Seed>,
universe: Vec<crate::python_engine::PyInstrument>,
macro_state: Option<crate::python_engine::PyMacro>,
model: Option<&Bound<'_, PyAny>>,
) -> PyResult<Self> {
let seeds: Vec<u64> = seeds.into_iter().map(|s| s.0).collect();
if seeds.is_empty() {
return Err(ValidationError::new_err("no seeds given"));
}
if universe.is_empty() {
return Err(ValidationError::new_err("universe is empty"));
}
if let Some(rate) = universe.iter().find(|i| i.is_rate()) {
return Err(ValidationError::new_err(format!(
"{} is a rate index, and EngineBatch runs equities only. Run a \
roster with rate instruments on Engine, or through run_many, \
one seed per engine.",
rate.ticker
)));
}
crate::python_engine::split_roster(&universe)?;
let mut sorted = seeds.clone();
sorted.sort_unstable();
sorted.dedup();
if sorted.len() != seeds.len() {
return Err(ValidationError::new_err(
"seeds must be distinct - a repeated seed is the same market twice, \
which reads as two samples and is one",
));
}
let params = crate::python_engine::model_params_from(model)?;
let settle_opening = macro_state.is_none();
let economy = crate::python_engine::economy_from(macro_state)?;
let companies: Vec<TickCompany> = universe
.iter()
.enumerate()
.map(|(i, inst)| inst.to_core_public(i))
.collect();
let sector_keys: Vec<String> =
crate::sectors::keys().iter().map(|s| s.to_string()).collect();
let engines = py.allow_threads(|| {
seeds
.iter()
.map(|seed| {
Engine::with_params_from_opening(
*seed,
companies.clone(),
economy.clone(),
create_initial_central_bank_state(0),
sector_keys.clone(),
params.clone(),
settle_opening,
)
})
.collect::<Vec<_>>()
});
let buffers = (0..engines.len()).map(|_| SessionBuffer::new()).collect();
Ok(Self {
engines,
buffers,
seeds,
tickers: universe.iter().map(|i| i.ticker.clone()).collect(),
market_open: false,
})
}
fn open_market(&mut self) {
self.market_open = true;
for engine in &mut self.engines {
engine.open_market();
}
}
#[pyo3(signature = (hour, minute, day_of_week, *, volatility = 1.0))]
fn tick(
&mut self,
hour: i64,
minute: i64,
day_of_week: i64,
volatility: f64,
) -> PyResult<()> {
if !(0..24).contains(&hour) || !(0..60).contains(&minute) || !(0..7).contains(&day_of_week)
{
return Err(ValidationError::new_err("invalid time"));
}
for engine in &mut self.engines {
engine.tick(&TickRequest {
time: GameTime {
hour,
minute,
day_of_week,
},
volatility_multiplier: volatility,
news: &[],
news_impact_queue: &[],
order_volumes: &[],
});
}
Ok(())
}
#[pyo3(signature = (hour, minute, day_of_week, ticks, *, volatility = 1.0))]
fn run_session(
&mut self,
hour: i64,
minute: i64,
day_of_week: i64,
ticks: usize,
volatility: f64,
) -> PyResult<()> {
if ticks == 0 {
return Err(ValidationError::new_err("ticks must be greater than zero"));
}
if !self.market_open {
self.open_market();
}
for (engine, buffer) in self.engines.iter_mut().zip(self.buffers.iter_mut()) {
let n = engine.len();
let innovations: Vec<Option<f64>> = vec![None; n];
let variances: Vec<f64> = engine
.companies()
.iter()
.map(|c| {
crate::sectors::by_key(&c.sector)
.map(|s| s.base_daily_variance())
.unwrap_or(0.000225)
})
.collect();
engine.run_session(
&SessionRequest {
start: GameTime {
hour,
minute,
day_of_week,
},
ticks,
volatility_multiplier: volatility,
news: &[],
news_impact_queue: &[],
order_volumes: &[],
fills: &[],
close_at_end: false,
reopen: false,
daily_innovations: &innovations,
sector_base_variances: &variances,
stop: None,
},
buffer,
);
}
Ok(())
}
fn prices(&self, py: Python<'_>) -> Py<PyBytes> {
let mut out = Vec::with_capacity(self.engines.len() * self.tickers.len());
for engine in &self.engines {
out.extend_from_slice(&engine.prices());
}
f64_bytes(py, &out)
}
fn column(&self, py: Python<'_>, field: &str) -> PyResult<Py<PyBytes>> {
let f = crate::python_engine::parse_field_public(field)?;
let mut out = Vec::with_capacity(self.engines.len() * self.tickers.len());
for engine in &self.engines {
out.extend_from_slice(&engine.column(f));
}
Ok(f64_bytes(py, &out))
}
#[getter]
fn draws_consumed(&self) -> Vec<usize> {
self.engines.iter().map(|e| e.draws_consumed()).collect()
}
#[getter]
fn model_fingerprint(&self) -> String {
self.engines[0].model_fingerprint().to_string()
}
#[getter]
fn model(&self) -> crate::python_params::PyModelParams {
crate::python_params::PyModelParams {
inner: self.engines[0].params().clone(),
}
}
#[getter]
fn seeds(&self) -> Vec<u64> {
self.seeds.clone()
}
#[getter]
fn tickers(&self) -> Vec<String> {
self.tickers.clone()
}
fn __len__(&self) -> usize {
self.engines.len()
}
#[getter]
fn shape(&self) -> (usize, usize) {
(self.engines.len(), self.tickers.len())
}
fn __repr__(&self) -> String {
format!(
"EngineBatch({} markets x {} instruments)",
self.engines.len(),
self.tickers.len()
)
}
}