1use std::{
17 collections::hash_map::DefaultHasher,
18 hash::{Hash, Hasher},
19};
20
21use nautilus_core::{
22 from_pydict,
23 python::{IntoPyObjectNautilusExt, to_pyvalue_err},
24};
25use pyo3::{basic::CompareOp, prelude::*, types::PyDict};
26use rust_decimal::Decimal;
27use ustr::Ustr;
28
29use crate::{
30 identifiers::{InstrumentId, Symbol},
31 instruments::CryptoOptionSpread,
32 python::instruments::register_crypto_currencies_from_dict,
33 types::{Currency, Money, Price, Quantity},
34};
35
36#[pymethods]
37#[pyo3_stub_gen::derive::gen_stub_pymethods]
38impl CryptoOptionSpread {
39 #[expect(clippy::too_many_arguments)]
42 #[new]
43 #[pyo3(signature = (instrument_id, raw_symbol, underlying, quote_currency, settlement_currency, is_inverse, strategy_type, activation_ns, expiration_ns, price_precision, size_precision, price_increment, size_increment,ts_event, ts_init, multiplier=None, lot_size=None, max_quantity=None, min_quantity=None, max_notional=None, min_notional=None, max_price=None, min_price=None, margin_init=None, margin_maint=None, maker_fee=None, taker_fee=None, tick_scheme=None, info=None))]
44 fn py_new(
45 instrument_id: InstrumentId,
46 raw_symbol: Symbol,
47 underlying: Currency,
48 quote_currency: Currency,
49 settlement_currency: Currency,
50 is_inverse: bool,
51 strategy_type: &str,
52 activation_ns: u64,
53 expiration_ns: u64,
54 price_precision: u8,
55 size_precision: u8,
56 price_increment: Price,
57 size_increment: Quantity,
58 ts_event: u64,
59 ts_init: u64,
60 multiplier: Option<Quantity>,
61 lot_size: Option<Quantity>,
62 max_quantity: Option<Quantity>,
63 min_quantity: Option<Quantity>,
64 max_notional: Option<Money>,
65 min_notional: Option<Money>,
66 max_price: Option<Price>,
67 min_price: Option<Price>,
68 margin_init: Option<Decimal>,
69 margin_maint: Option<Decimal>,
70 maker_fee: Option<Decimal>,
71 taker_fee: Option<Decimal>,
72 tick_scheme: Option<String>,
73 info: Option<Py<PyDict>>,
74 ) -> PyResult<Self> {
75 let info_map = if let Some(info_dict) = info {
76 Python::attach(|py| from_pydict(py, &info_dict))?
77 } else {
78 None
79 };
80
81 Self::new_checked(
82 instrument_id,
83 raw_symbol,
84 underlying,
85 quote_currency,
86 settlement_currency,
87 is_inverse,
88 Ustr::from(strategy_type),
89 activation_ns.into(),
90 expiration_ns.into(),
91 price_precision,
92 size_precision,
93 price_increment,
94 size_increment,
95 multiplier,
96 lot_size,
97 max_quantity,
98 min_quantity,
99 max_notional,
100 min_notional,
101 max_price,
102 min_price,
103 margin_init,
104 margin_maint,
105 maker_fee,
106 taker_fee,
107 tick_scheme.map(|name| ustr::Ustr::from(name.as_str())),
108 info_map,
109 ts_event.into(),
110 ts_init.into(),
111 )
112 .map_err(to_pyvalue_err)
113 }
114
115 fn __hash__(&self) -> isize {
116 let mut hasher = DefaultHasher::new();
117 self.hash(&mut hasher);
118 hasher.finish() as isize
119 }
120
121 fn __richcmp__(&self, other: &Self, op: CompareOp, py: Python<'_>) -> Py<PyAny> {
122 match op {
123 CompareOp::Eq => self.eq(other).into_py_any_unwrap(py),
124 CompareOp::Ne => self.ne(other).into_py_any_unwrap(py),
125 _ => py.NotImplemented(),
126 }
127 }
128
129 #[getter]
130 fn type_name(&self) -> &'static str {
131 stringify!(CryptoOptionSpread)
132 }
133
134 #[getter]
135 #[pyo3(name = "id")]
136 fn py_id(&self) -> InstrumentId {
137 self.id
138 }
139
140 #[getter]
141 #[pyo3(name = "raw_symbol")]
142 fn py_raw_symbol(&self) -> Symbol {
143 self.raw_symbol
144 }
145
146 #[getter]
147 #[pyo3(name = "underlying")]
148 fn py_underlying(&self) -> Currency {
149 self.underlying
150 }
151
152 #[getter]
153 #[pyo3(name = "quote_currency")]
154 fn py_quote_currency(&self) -> Currency {
155 self.quote_currency
156 }
157
158 #[getter]
159 #[pyo3(name = "settlement_currency")]
160 fn py_settlement_currency(&self) -> Currency {
161 self.settlement_currency
162 }
163
164 #[getter]
165 #[pyo3(name = "is_inverse")]
166 fn py_is_inverse(&self) -> bool {
167 self.is_inverse
168 }
169
170 #[getter]
171 #[pyo3(name = "strategy_type")]
172 fn py_strategy_type(&self) -> String {
173 self.strategy_type.to_string()
174 }
175
176 #[getter]
177 #[pyo3(name = "activation_ns")]
178 fn py_activation_ns(&self) -> u64 {
179 self.activation_ns.as_u64()
180 }
181
182 #[getter]
183 #[pyo3(name = "expiration_ns")]
184 fn py_expiration_ns(&self) -> u64 {
185 self.expiration_ns.as_u64()
186 }
187
188 #[getter]
189 #[pyo3(name = "price_precision")]
190 fn py_price_precision(&self) -> u8 {
191 self.price_precision
192 }
193
194 #[getter]
195 #[pyo3(name = "size_precision")]
196 fn py_size_precision(&self) -> u8 {
197 self.size_precision
198 }
199
200 #[getter]
201 #[pyo3(name = "price_increment")]
202 fn py_price_increment(&self) -> Price {
203 self.price_increment
204 }
205
206 #[getter]
207 #[pyo3(name = "size_increment")]
208 fn py_size_increment(&self) -> Quantity {
209 self.size_increment
210 }
211
212 #[getter]
213 #[pyo3(name = "multiplier")]
214 fn py_multiplier(&self) -> Quantity {
215 self.multiplier
216 }
217
218 #[getter]
219 #[pyo3(name = "lot_size")]
220 fn py_lot_size(&self) -> Quantity {
221 self.lot_size
222 }
223
224 #[getter]
225 #[pyo3(name = "max_quantity")]
226 fn py_max_quantity(&self) -> Option<Quantity> {
227 self.max_quantity
228 }
229
230 #[getter]
231 #[pyo3(name = "min_quantity")]
232 fn py_min_quantity(&self) -> Option<Quantity> {
233 self.min_quantity
234 }
235
236 #[getter]
237 #[pyo3(name = "max_notional")]
238 fn py_max_notional(&self) -> Option<Money> {
239 self.max_notional
240 }
241
242 #[getter]
243 #[pyo3(name = "min_notional")]
244 fn py_min_notional(&self) -> Option<Money> {
245 self.min_notional
246 }
247
248 #[getter]
249 #[pyo3(name = "max_price")]
250 fn py_max_price(&self) -> Option<Price> {
251 self.max_price
252 }
253
254 #[getter]
255 #[pyo3(name = "min_price")]
256 fn py_min_price(&self) -> Option<Price> {
257 self.min_price
258 }
259
260 #[getter]
261 #[pyo3(name = "margin_init")]
262 fn py_margin_init(&self) -> Decimal {
263 self.margin_init
264 }
265
266 #[getter]
267 #[pyo3(name = "margin_maint")]
268 fn py_margin_maint(&self) -> Decimal {
269 self.margin_maint
270 }
271
272 #[getter]
273 #[pyo3(name = "maker_fee")]
274 fn py_maker_fee(&self) -> Decimal {
275 self.maker_fee
276 }
277
278 #[getter]
279 #[pyo3(name = "taker_fee")]
280 fn py_taker_fee(&self) -> Decimal {
281 self.taker_fee
282 }
283
284 #[getter]
285 #[pyo3(name = "info")]
286 fn py_info(&self, py: Python<'_>) -> PyResult<Py<PyDict>> {
287 if let Some(ref info_map) = self.info {
288 let py_dict = PyDict::new(py);
289
290 for (key, value) in info_map {
291 let json_str = serde_json::to_string(value).map_err(to_pyvalue_err)?;
292 let py_value =
293 PyModule::import(py, "json")?.call_method("loads", (json_str,), None)?;
294 py_dict.set_item(key, py_value)?;
295 }
296 Ok(py_dict.unbind())
297 } else {
298 Ok(PyDict::new(py).unbind())
299 }
300 }
301
302 #[getter]
303 #[pyo3(name = "ts_event")]
304 fn py_ts_event(&self) -> u64 {
305 self.ts_event.as_u64()
306 }
307
308 #[getter]
309 #[pyo3(name = "ts_init")]
310 fn py_ts_init(&self) -> u64 {
311 self.ts_init.as_u64()
312 }
313
314 #[staticmethod]
315 #[pyo3(name = "from_dict")]
316 fn py_from_dict(py: Python<'_>, values: Py<PyDict>) -> PyResult<Self> {
317 register_crypto_currencies_from_dict(py, &values, &["underlying"]);
318 crate::python::instruments::from_dict_instrument_pyo3(py, values)
319 }
320
321 #[pyo3(name = "to_dict")]
322 fn py_to_dict(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
323 let dict = PyDict::new(py);
324 dict.set_item("type", stringify!(CryptoOptionSpread))?;
325 dict.set_item("id", self.id.to_string())?;
326 dict.set_item("raw_symbol", self.raw_symbol.to_string())?;
327 dict.set_item("underlying", self.underlying.code.to_string())?;
328 dict.set_item("quote_currency", self.quote_currency.code.to_string())?;
329 dict.set_item(
330 "settlement_currency",
331 self.settlement_currency.code.to_string(),
332 )?;
333 dict.set_item("is_inverse", self.is_inverse)?;
334 dict.set_item("strategy_type", self.strategy_type.to_string())?;
335 dict.set_item("activation_ns", self.activation_ns.as_u64())?;
336 dict.set_item("expiration_ns", self.expiration_ns.as_u64())?;
337 dict.set_item("price_precision", self.price_precision)?;
338 dict.set_item("size_precision", self.size_precision)?;
339 dict.set_item("price_increment", self.price_increment.to_string())?;
340 dict.set_item("size_increment", self.size_increment.to_string())?;
341 dict.set_item("multiplier", self.multiplier.to_string())?;
342 dict.set_item("lot_size", self.lot_size.to_string())?;
343 dict.set_item("margin_init", self.margin_init.to_string())?;
344 dict.set_item("margin_maint", self.margin_maint.to_string())?;
345 dict.set_item("maker_fee", self.maker_fee.to_string())?;
346 dict.set_item("taker_fee", self.taker_fee.to_string())?;
347 dict.set_item("ts_event", self.ts_event.as_u64())?;
348 dict.set_item("ts_init", self.ts_init.as_u64())?;
349
350 if let Some(ref info_map) = self.info {
351 let info_dict = PyDict::new(py);
352
353 for (key, value) in info_map {
354 let json_str = serde_json::to_string(value).map_err(to_pyvalue_err)?;
355 let py_value =
356 PyModule::import(py, "json")?.call_method("loads", (json_str,), None)?;
357 info_dict.set_item(key, py_value)?;
358 }
359 dict.set_item("info", info_dict)?;
360 } else {
361 dict.set_item("info", PyDict::new(py))?;
362 }
363
364 match self.max_quantity {
365 Some(value) => dict.set_item("max_quantity", value.to_string())?,
366 None => dict.set_item("max_quantity", py.None())?,
367 }
368
369 match self.min_quantity {
370 Some(value) => dict.set_item("min_quantity", value.to_string())?,
371 None => dict.set_item("min_quantity", py.None())?,
372 }
373
374 match self.max_notional {
375 Some(value) => dict.set_item("max_notional", value.to_string())?,
376 None => dict.set_item("max_notional", py.None())?,
377 }
378
379 match self.min_notional {
380 Some(value) => dict.set_item("min_notional", value.to_string())?,
381 None => dict.set_item("min_notional", py.None())?,
382 }
383
384 match self.max_price {
385 Some(value) => dict.set_item("max_price", value.to_string())?,
386 None => dict.set_item("max_price", py.None())?,
387 }
388
389 match self.min_price {
390 Some(value) => dict.set_item("min_price", value.to_string())?,
391 None => dict.set_item("min_price", py.None())?,
392 }
393 dict.set_item(
394 "tick_scheme",
395 crate::python::instruments::tick_scheme_to_py(self),
396 )?;
397 Ok(dict.into())
398 }
399}
400
401#[cfg(test)]
402mod tests {
403 use pyo3::{prelude::*, types::PyDict};
404 use rstest::rstest;
405
406 use crate::instruments::{CryptoOptionSpread, stubs::*};
407
408 #[rstest]
409 fn test_dict_round_trip(crypto_option_spread_btc_deribit: CryptoOptionSpread) {
410 Python::initialize();
411 Python::attach(|py| {
412 let original = crypto_option_spread_btc_deribit;
413 let values = original.py_to_dict(py).unwrap();
414 let values: Py<PyDict> = values.extract(py).unwrap();
415 let restored = CryptoOptionSpread::py_from_dict(py, values).unwrap();
416 assert_eq!(original, restored);
417 });
418 }
419}