Skip to main content

nautilus_interactive_brokers/python/
conversion.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! Python conversion utilities for Interactive Brokers types.
17
18use ibapi::contracts::{Contract, ContractDetails, SecurityType};
19use nautilus_core::python::{to_pytype_err, to_pyvalue_err};
20use pyo3::{
21    prelude::*,
22    types::{PyBytes, PyDict, PyList},
23};
24
25use crate::common::{
26    contracts::parse_contract_from_json,
27    enums::{IbComboLegOpenClose, IbSecurityType},
28};
29
30/// Convert a Python object to a JSON value.
31pub fn py_to_json_value(obj: &Bound<'_, PyAny>) -> PyResult<serde_json::Value> {
32    // Try to call .json() first (NautilusConfig)
33    if let Ok(json_bytes) = obj.call_method0("json")
34        && let Ok(bytes) = json_bytes.clone().cast_into::<PyBytes>()
35    {
36        let json_str = std::str::from_utf8(bytes.as_bytes())
37            .map_err(|e| to_pyvalue_err(format!("Invalid UTF-8 in json output: {e}")))?;
38
39        let value: serde_json::Value = serde_json::from_str(json_str)
40            .map_err(|e| to_pyvalue_err(format!("Invalid JSON: {e}")))?;
41
42        return Ok(value);
43    }
44
45    // Try to treat as dict
46    if let Ok(dict) = obj.clone().cast_into::<pyo3::types::PyDict>() {
47        // Convert dict to JSON value using Python's json module
48        let json_mod = obj.py().import("json")?;
49        let json_str_obj = json_mod.call_method1("dumps", (dict,))?;
50        let json_str = json_str_obj.extract::<String>()?;
51
52        let value: serde_json::Value = serde_json::from_str(&json_str)
53            .map_err(|e| to_pyvalue_err(format!("Invalid JSON from dict: {e}")))?;
54
55        return Ok(value);
56    }
57
58    Err(to_pytype_err("Expected object with .json() or dict"))
59}
60
61/// Convert a Python object (IBContract or dict) to a Rust Contract.
62///
63/// # Errors
64///
65/// Returns an error if conversion fails.
66pub fn py_to_contract(obj: &Bound<'_, PyAny>) -> PyResult<Contract> {
67    let value = py_to_json_value(obj)?;
68    parse_contract_from_json(&value)
69        .map_err(|e| to_pyvalue_err(format!("Failed to parse contract: {e}")))
70}
71
72/// Convert a Python list of objects to a vector of Rust Contracts.
73pub fn py_list_to_contracts(obj: &Bound<'_, PyAny>) -> PyResult<Vec<Contract>> {
74    let list = obj.clone().cast_into::<pyo3::types::PyList>()?;
75    let mut contracts = Vec::with_capacity(list.len());
76    for item in list.iter() {
77        contracts.push(py_to_contract(&item)?);
78    }
79
80    Ok(contracts)
81}
82
83/// Convert a Python list of objects to a vector of JSON values.
84pub fn py_list_to_json_values(obj: &Bound<'_, PyAny>) -> PyResult<Vec<serde_json::Value>> {
85    let list = obj.clone().cast_into::<pyo3::types::PyList>()?;
86    let mut values = Vec::with_capacity(list.len());
87    for item in list.iter() {
88        values.push(py_to_json_value(&item)?);
89    }
90
91    Ok(values)
92}
93
94fn security_type_to_ib_str(security_type: &SecurityType) -> String {
95    IbSecurityType::try_from(security_type).map_or_else(
96        |_| security_type.to_string(),
97        |security_type| security_type.to_string(),
98    )
99}
100
101fn combo_leg_open_close_to_i32(open_close: ibapi::contracts::ComboLegOpenClose) -> i32 {
102    IbComboLegOpenClose::from(open_close).as_i32()
103}
104
105pub fn contract_to_pydict<'py>(
106    py: Python<'py>,
107    contract: &Contract,
108) -> PyResult<Bound<'py, PyDict>> {
109    let dict = PyDict::new(py);
110    dict.set_item("secType", security_type_to_ib_str(&contract.security_type))?;
111    dict.set_item("conId", contract.contract_id)?;
112    dict.set_item("exchange", contract.exchange.as_str())?;
113    dict.set_item("primaryExchange", contract.primary_exchange.as_str())?;
114    dict.set_item("symbol", contract.symbol.as_str())?;
115    dict.set_item("localSymbol", contract.local_symbol.as_str())?;
116    dict.set_item("currency", contract.currency.as_str())?;
117    dict.set_item("tradingClass", &contract.trading_class)?;
118    dict.set_item(
119        "lastTradeDateOrContractMonth",
120        &contract.last_trade_date_or_contract_month,
121    )?;
122    dict.set_item(
123        "lastTradeDate",
124        contract
125            .last_trade_date
126            .as_ref()
127            .map_or_default(ToString::to_string),
128    )?;
129    dict.set_item("multiplier", &contract.multiplier)?;
130    dict.set_item("strike", contract.strike)?;
131    dict.set_item(
132        "right",
133        contract.right.as_ref().map_or("", |right| right.as_str()),
134    )?;
135    dict.set_item("includeExpired", contract.include_expired)?;
136    dict.set_item(
137        "secIdType",
138        contract
139            .security_id_type
140            .as_ref()
141            .map_or("", |security_id_type| security_id_type.as_str()),
142    )?;
143    dict.set_item("secId", &contract.security_id)?;
144    dict.set_item("description", &contract.description)?;
145    dict.set_item("issuerId", &contract.issuer_id)?;
146    dict.set_item("comboLegsDescrip", &contract.combo_legs_description)?;
147
148    if !contract.combo_legs.is_empty() {
149        let combo_legs = PyList::empty(py);
150        for leg in &contract.combo_legs {
151            let leg_dict = PyDict::new(py);
152            leg_dict.set_item("conId", leg.contract_id)?;
153            leg_dict.set_item("ratio", leg.ratio)?;
154            leg_dict.set_item("action", leg.action.as_str())?;
155            leg_dict.set_item("exchange", &leg.exchange)?;
156            leg_dict.set_item("openClose", combo_leg_open_close_to_i32(leg.open_close))?;
157            leg_dict.set_item("shortSaleSlot", leg.short_sale_slot)?;
158            leg_dict.set_item("designatedLocation", &leg.designated_location)?;
159            leg_dict.set_item("exemptCode", leg.exempt_code)?;
160            combo_legs.append(leg_dict)?;
161        }
162
163        dict.set_item("comboLegs", combo_legs)?;
164    }
165
166    if let Some(delta_neutral) = &contract.delta_neutral_contract {
167        let delta_dict = PyDict::new(py);
168        delta_dict.set_item("conId", delta_neutral.contract_id)?;
169        delta_dict.set_item("delta", delta_neutral.delta)?;
170        delta_dict.set_item("price", delta_neutral.price)?;
171        dict.set_item("deltaNeutralContract", delta_dict)?;
172    }
173
174    Ok(dict)
175}
176
177pub fn contract_details_to_pyobject(
178    py: Python<'_>,
179    details: &ContractDetails,
180) -> PyResult<Py<PyAny>> {
181    let details_dict = PyDict::new(py);
182
183    details_dict.set_item("contract", contract_to_pydict(py, &details.contract)?)?;
184    details_dict.set_item("marketName", &details.market_name)?;
185    details_dict.set_item("minTick", details.min_tick)?;
186    details_dict.set_item("orderTypes", details.order_types.join(","))?;
187    details_dict.set_item("validExchanges", details.valid_exchanges.join(","))?;
188    details_dict.set_item("priceMagnifier", details.price_magnifier)?;
189    details_dict.set_item("underConId", details.under_contract_id)?;
190    details_dict.set_item("longName", &details.long_name)?;
191    details_dict.set_item("contractMonth", &details.contract_month)?;
192    details_dict.set_item("industry", &details.industry)?;
193    details_dict.set_item("category", &details.category)?;
194    details_dict.set_item("subcategory", &details.subcategory)?;
195    details_dict.set_item("timeZoneId", &details.time_zone_id)?;
196    details_dict.set_item("tradingHours", details.trading_hours.join(";"))?;
197    details_dict.set_item("liquidHours", details.liquid_hours.join(";"))?;
198    details_dict.set_item("evRule", &details.ev_rule)?;
199    details_dict.set_item("evMultiplier", details.ev_multiplier)?;
200    details_dict.set_item("aggGroup", details.agg_group)?;
201    details_dict.set_item("underSymbol", &details.under_symbol)?;
202    details_dict.set_item("underSecType", &details.under_security_type)?;
203    details_dict.set_item("marketRuleIds", details.market_rule_ids.join(","))?;
204    details_dict.set_item("realExpirationDate", &details.real_expiration_date)?;
205    details_dict.set_item("lastTradeTime", &details.last_trade_time)?;
206    details_dict.set_item("stockType", &details.stock_type)?;
207    details_dict.set_item("cusip", &details.cusip)?;
208    details_dict.set_item("ratings", &details.ratings)?;
209    details_dict.set_item("descAppend", &details.desc_append)?;
210    details_dict.set_item("bondType", &details.bond_type)?;
211    details_dict.set_item("couponType", &details.coupon_type)?;
212    details_dict.set_item("callable", details.callable)?;
213    details_dict.set_item("putable", details.putable)?;
214    details_dict.set_item("coupon", details.coupon)?;
215    details_dict.set_item("convertible", details.convertible)?;
216    details_dict.set_item("maturity", &details.maturity)?;
217    details_dict.set_item("issueDate", &details.issue_date)?;
218    details_dict.set_item("nextOptionDate", &details.next_option_date)?;
219    details_dict.set_item("nextOptionType", &details.next_option_type)?;
220    details_dict.set_item("nextOptionPartial", details.next_option_partial)?;
221    details_dict.set_item("notes", &details.notes)?;
222    details_dict.set_item(
223        "minSize",
224        details
225            .min_size
226            .map_or_else(String::new, |value| value.to_string()),
227    )?;
228    details_dict.set_item(
229        "sizeIncrement",
230        details
231            .size_increment
232            .map_or_else(String::new, |value| value.to_string()),
233    )?;
234    details_dict.set_item(
235        "suggestedSizeIncrement",
236        details
237            .suggested_size_increment
238            .map_or_else(String::new, |value| value.to_string()),
239    )?;
240    details_dict.set_item("fundName", &details.fund_name)?;
241    details_dict.set_item("fundFamily", &details.fund_family)?;
242    details_dict.set_item("fundType", &details.fund_type)?;
243    details_dict.set_item("fundFrontLoad", &details.fund_front_load)?;
244    details_dict.set_item("fundBackLoad", &details.fund_back_load)?;
245    details_dict.set_item(
246        "fundBackLoadTimeInterval",
247        &details.fund_back_load_time_interval,
248    )?;
249    details_dict.set_item("fundManagementFee", &details.fund_management_fee)?;
250    details_dict.set_item("fundClosed", details.fund_closed)?;
251    details_dict.set_item(
252        "fundClosedForNewInvestors",
253        details.fund_closed_for_new_investors,
254    )?;
255    details_dict.set_item("fundClosedForNewMoney", details.fund_closed_for_new_money)?;
256    details_dict.set_item("fundNotifyAmount", &details.fund_notify_amount)?;
257    details_dict.set_item(
258        "fundMinimumInitialPurchase",
259        &details.fund_minimum_initial_purchase,
260    )?;
261    details_dict.set_item(
262        "fundSubsequentMinimumPurchase",
263        &details.fund_subsequent_minimum_purchase,
264    )?;
265    details_dict.set_item("fundBlueSkyStates", &details.fund_blue_sky_states)?;
266    details_dict.set_item("fundBlueSkyTerritories", &details.fund_blue_sky_territories)?;
267
268    if !details.sec_id_list.is_empty() {
269        let sec_id_list = PyDict::new(py);
270        for item in &details.sec_id_list {
271            sec_id_list.set_item(&item.tag, &item.value)?;
272        }
273
274        details_dict.set_item("secIdList", sec_id_list)?;
275    }
276
277    Ok(details_dict.into_any().unbind())
278}