nautilus_interactive_brokers/common/enums/

misc.rs

// -------------------------------------------------------------------------------------------------
//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
//  https://nautechsystems.io
//
//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
//  You may not use this file except in compliance with the License.
//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
// -------------------------------------------------------------------------------------------------

//! Interactive Brokers account, condition, and routing enumerations.

use std::fmt::Display;

/// Interactive Brokers order origin values.
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        from_py_object,
        rename_all = "SCREAMING_SNAKE_CASE"
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
pub enum IbOrderOrigin {
    #[default]
    Customer,
    Firm,
}

impl IbOrderOrigin {
    #[must_use]
    pub const fn as_i32(self) -> i32 {
        match self {
            Self::Customer => 0,
            Self::Firm => 1,
        }
    }
}

impl From<i32> for IbOrderOrigin {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Customer,
            1 => Self::Firm,
            _ => {
                tracing::warn!("Unknown IB order origin code {value}; using the default");
                Self::default()
            }
        }
    }
}

impl Display for IbOrderOrigin {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_i32())
    }
}

impl IbOrderOrigin {
    #[must_use]
    pub fn ibapi_order_origin(self) -> ibapi::orders::OrderOrigin {
        ibapi::orders::OrderOrigin::from(self.as_i32())
    }
}

/// Interactive Brokers institutional short-sale slot values.
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        from_py_object,
        rename_all = "SCREAMING_SNAKE_CASE"
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
pub enum IbShortSaleSlot {
    #[default]
    None,
    Broker,
    ThirdParty,
}

impl IbShortSaleSlot {
    #[must_use]
    pub const fn as_i32(self) -> i32 {
        match self {
            Self::None => 0,
            Self::Broker => 1,
            Self::ThirdParty => 2,
        }
    }
}

impl From<i32> for IbShortSaleSlot {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::None,
            1 => Self::Broker,
            2 => Self::ThirdParty,
            _ => {
                tracing::warn!("Unknown IB short-sale slot code {value}; using the default");
                Self::default()
            }
        }
    }
}

impl Display for IbShortSaleSlot {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_i32())
    }
}

impl IbShortSaleSlot {
    #[must_use]
    pub fn ibapi_short_sale_slot(self) -> ibapi::orders::ShortSaleSlot {
        ibapi::orders::ShortSaleSlot::from(self.as_i32())
    }
}

/// Interactive Brokers volatility type values.
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        from_py_object,
        rename_all = "SCREAMING_SNAKE_CASE"
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
pub enum IbVolatilityType {
    #[default]
    Daily,
    Annual,
}

impl IbVolatilityType {
    #[must_use]
    pub const fn as_i32(self) -> i32 {
        match self {
            Self::Daily => 1,
            Self::Annual => 2,
        }
    }
}

impl From<i32> for IbVolatilityType {
    fn from(value: i32) -> Self {
        match value {
            1 => Self::Daily,
            2 => Self::Annual,
            _ => {
                tracing::warn!("Unknown IB volatility type code {value}; using the default");
                Self::default()
            }
        }
    }
}

impl Display for IbVolatilityType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_i32())
    }
}

impl IbVolatilityType {
    #[must_use]
    pub fn ibapi_volatility_type(self) -> ibapi::orders::VolatilityType {
        ibapi::orders::VolatilityType::from(self.as_i32())
    }
}

/// Interactive Brokers VOL order reference price type values.
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        from_py_object,
        rename_all = "SCREAMING_SNAKE_CASE"
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
pub enum IbReferencePriceType {
    #[default]
    AverageOfNbbo,
    Nbbo,
}

impl IbReferencePriceType {
    #[must_use]
    pub const fn as_i32(self) -> i32 {
        match self {
            Self::AverageOfNbbo => 1,
            Self::Nbbo => 2,
        }
    }
}

impl From<i32> for IbReferencePriceType {
    fn from(value: i32) -> Self {
        match value {
            1 => Self::AverageOfNbbo,
            2 => Self::Nbbo,
            _ => {
                tracing::warn!("Unknown IB reference price type code {value}; using the default");
                Self::default()
            }
        }
    }
}

impl Display for IbReferencePriceType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_i32())
    }
}

impl IbReferencePriceType {
    #[must_use]
    pub fn ibapi_reference_price_type(self) -> ibapi::orders::ReferencePriceType {
        ibapi::orders::ReferencePriceType::from(self.as_i32())
    }
}

/// Interactive Brokers BOX auction strategy values.
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        from_py_object,
        rename_all = "SCREAMING_SNAKE_CASE"
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
pub enum IbAuctionStrategy {
    #[default]
    Match,
    Improvement,
    Transparent,
}

impl IbAuctionStrategy {
    #[must_use]
    pub const fn as_i32(self) -> i32 {
        match self {
            Self::Match => 1,
            Self::Improvement => 2,
            Self::Transparent => 3,
        }
    }
}

impl From<i32> for IbAuctionStrategy {
    fn from(value: i32) -> Self {
        match value {
            1 => Self::Match,
            2 => Self::Improvement,
            3 => Self::Transparent,
            _ => {
                tracing::warn!("Unknown IB auction strategy code {value}; using the default");
                Self::default()
            }
        }
    }
}

impl Display for IbAuctionStrategy {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_i32())
    }
}

/// Interactive Brokers option exercise action values.
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        from_py_object,
        rename_all = "SCREAMING_SNAKE_CASE"
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
pub enum IbExerciseAction {
    #[default]
    Exercise,
    Lapse,
}

impl IbExerciseAction {
    #[must_use]
    pub const fn as_i32(self) -> i32 {
        match self {
            Self::Exercise => 1,
            Self::Lapse => 2,
        }
    }
}

impl From<i32> for IbExerciseAction {
    fn from(value: i32) -> Self {
        match value {
            1 => Self::Exercise,
            2 => Self::Lapse,
            _ => {
                tracing::warn!("Unknown IB exercise action code {value}; using the default");
                Self::default()
            }
        }
    }
}

impl Display for IbExerciseAction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_i32())
    }
}

impl IbExerciseAction {
    #[must_use]
    pub const fn ibapi_exercise_action(self) -> ibapi::orders::ExerciseAction {
        match self {
            Self::Exercise => ibapi::orders::ExerciseAction::Exercise,
            Self::Lapse => ibapi::orders::ExerciseAction::Lapse,
        }
    }
}

/// Interactive Brokers news article type values.
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        from_py_object,
        rename_all = "SCREAMING_SNAKE_CASE"
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
pub enum IbArticleType {
    #[default]
    Text,
    Binary,
}

impl IbArticleType {
    #[must_use]
    pub const fn as_i32(self) -> i32 {
        match self {
            Self::Text => 0,
            Self::Binary => 1,
        }
    }
}

impl From<i32> for IbArticleType {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Text,
            1 => Self::Binary,
            _ => {
                tracing::warn!("Unknown IB article type code {value}; using the default");
                Self::default()
            }
        }
    }
}

impl Display for IbArticleType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_i32())
    }
}

impl IbArticleType {
    #[must_use]
    pub fn ibapi_article_type(self) -> ibapi::news::ArticleType {
        ibapi::news::ArticleType::from(self.as_i32())
    }
}

/// Interactive Brokers builder auction type values.
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        from_py_object,
        rename_all = "SCREAMING_SNAKE_CASE"
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
pub enum IbAuctionType {
    #[default]
    Opening,
    Closing,
    Volatility,
}

impl IbAuctionType {
    #[must_use]
    pub const fn as_i32(self) -> i32 {
        match self {
            Self::Opening => 1,
            Self::Closing => 2,
            Self::Volatility => 4,
        }
    }
}

impl From<i32> for IbAuctionType {
    fn from(value: i32) -> Self {
        match value {
            1 => Self::Opening,
            2 => Self::Closing,
            4 => Self::Volatility,
            _ => {
                tracing::warn!("Unknown IB auction type code {value}; using the default");
                Self::default()
            }
        }
    }
}

impl Display for IbAuctionType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_i32())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        from_py_object,
        rename_all = "SCREAMING_SNAKE_CASE"
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
pub enum IbRule80A {
    Individual,
    Agency,
    AgentOtherMember,
    IndividualPtia,
    AgencyPtia,
    AgentOtherMemberPtia,
    IndividualPt,
    AgencyPt,
    AgentOtherMemberPt,
}

impl IbRule80A {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Individual => "I",
            Self::Agency => "A",
            Self::AgentOtherMember => "W",
            Self::IndividualPtia => "J",
            Self::AgencyPtia => "U",
            Self::AgentOtherMemberPtia => "M",
            Self::IndividualPt => "K",
            Self::AgencyPt => "Y",
            Self::AgentOtherMemberPt => "N",
        }
    }
}

impl Display for IbRule80A {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        from_py_object,
        rename_all = "SCREAMING_SNAKE_CASE"
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
pub enum IbOrderOpenClose {
    Open,
    Close,
}

impl IbOrderOpenClose {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Open => "O",
            Self::Close => "C",
        }
    }
}

impl Display for IbOrderOpenClose {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        from_py_object,
        rename_all = "SCREAMING_SNAKE_CASE"
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
pub enum IbTwapStrategyType {
    Marketable,
    MatchingMidpoint,
    MatchingSameSide,
    MatchingLast,
}

impl IbTwapStrategyType {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Marketable => "Marketable",
            Self::MatchingMidpoint => "Matching Midpoint",
            Self::MatchingSameSide => "Matching Same Side",
            Self::MatchingLast => "Matching Last",
        }
    }
}

impl Display for IbTwapStrategyType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        from_py_object,
        rename_all = "SCREAMING_SNAKE_CASE"
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
pub enum IbRiskAversion {
    GetDone,
    Aggressive,
    Neutral,
    Passive,
}

impl IbRiskAversion {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::GetDone => "Get Done",
            Self::Aggressive => "Aggressive",
            Self::Neutral => "Neutral",
            Self::Passive => "Passive",
        }
    }
}

impl Display for IbRiskAversion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        from_py_object,
        rename_all = "SCREAMING_SNAKE_CASE"
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
pub enum IbLegAction {
    Buy,
    Sell,
}

impl IbLegAction {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Buy => "BUY",
            Self::Sell => "SELL",
        }
    }
}

impl Display for IbLegAction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        from_py_object,
        rename_all = "SCREAMING_SNAKE_CASE"
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
pub enum IbFundDistributionPolicyIndicator {
    None,
    AccumulationFund,
    IncomeFund,
}

impl IbFundDistributionPolicyIndicator {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::None => "",
            Self::AccumulationFund => "N",
            Self::IncomeFund => "Y",
        }
    }
}

impl Display for IbFundDistributionPolicyIndicator {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        from_py_object,
        rename_all = "SCREAMING_SNAKE_CASE"
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
pub enum IbFundAssetType {
    None,
    Others,
    MoneyMarket,
    FixedIncome,
    MultiAsset,
    Equity,
    Sector,
    Guaranteed,
    Alternative,
}

impl IbFundAssetType {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::None => "",
            Self::Others => "000",
            Self::MoneyMarket => "001",
            Self::FixedIncome => "002",
            Self::MultiAsset => "003",
            Self::Equity => "004",
            Self::Sector => "005",
            Self::Guaranteed => "006",
            Self::Alternative => "007",
        }
    }
}

impl Display for IbFundAssetType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

/// Bond identifier discriminator for the rust-ibapi payload enum.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(
        module = "nautilus_trader.adapters.interactive_brokers",
        from_py_object,
        rename_all = "SCREAMING_SNAKE_CASE"
    )
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass_enum(
        module = "nautilus_trader.adapters.interactive_brokers"
    )
)]
pub enum IbBondIdentifierKind {
    Cusip,
    Isin,
}

impl IbBondIdentifierKind {
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Cusip => "CUSIP",
            Self::Isin => "ISIN",
        }
    }
}

impl Display for IbBondIdentifierKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}