publicdotcom-cli 1.0.0__py3-none-any.whl

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_portfolio_gateway_cost_basis_type_0.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ComHellopublicUserapigatewayApiRestPortfolioGatewayCostBasisType0")
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestPortfolioGatewayCostBasisType0:
+    """Cost basis of a position. What the member paid for entering the position. The cost basis is
+    based on tax lots and will factor in wash sales.
+
+       Attributes:
+           total_cost (None | str | Unset): What is the dollars paid for entering this position
+           unit_cost (None | str | Unset): Totalcost divided by the quantity.
+           gain_value (None | str | Unset): Amount of dollars this position gained or lost. Current value - total cost
+           gain_percentage (None | str | Unset): 100*gainValue/totalcost
+           last_update (datetime.datetime | None | Unset): When was the cost cases last updated.
+    """
+
+    total_cost: None | str | Unset = UNSET
+    unit_cost: None | str | Unset = UNSET
+    gain_value: None | str | Unset = UNSET
+    gain_percentage: None | str | Unset = UNSET
+    last_update: datetime.datetime | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        total_cost: None | str | Unset
+        if isinstance(self.total_cost, Unset):
+            total_cost = UNSET
+        else:
+            total_cost = self.total_cost
+
+        unit_cost: None | str | Unset
+        if isinstance(self.unit_cost, Unset):
+            unit_cost = UNSET
+        else:
+            unit_cost = self.unit_cost
+
+        gain_value: None | str | Unset
+        if isinstance(self.gain_value, Unset):
+            gain_value = UNSET
+        else:
+            gain_value = self.gain_value
+
+        gain_percentage: None | str | Unset
+        if isinstance(self.gain_percentage, Unset):
+            gain_percentage = UNSET
+        else:
+            gain_percentage = self.gain_percentage
+
+        last_update: None | str | Unset
+        if isinstance(self.last_update, Unset):
+            last_update = UNSET
+        elif isinstance(self.last_update, datetime.datetime):
+            last_update = self.last_update.isoformat()
+        else:
+            last_update = self.last_update
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if total_cost is not UNSET:
+            field_dict["totalCost"] = total_cost
+        if unit_cost is not UNSET:
+            field_dict["unitCost"] = unit_cost
+        if gain_value is not UNSET:
+            field_dict["gainValue"] = gain_value
+        if gain_percentage is not UNSET:
+            field_dict["gainPercentage"] = gain_percentage
+        if last_update is not UNSET:
+            field_dict["lastUpdate"] = last_update
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+
+        def _parse_total_cost(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        total_cost = _parse_total_cost(d.pop("totalCost", UNSET))
+
+        def _parse_unit_cost(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        unit_cost = _parse_unit_cost(d.pop("unitCost", UNSET))
+
+        def _parse_gain_value(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        gain_value = _parse_gain_value(d.pop("gainValue", UNSET))
+
+        def _parse_gain_percentage(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        gain_percentage = _parse_gain_percentage(d.pop("gainPercentage", UNSET))
+
+        def _parse_last_update(data: object) -> datetime.datetime | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                last_update_type_0 = isoparse(data)
+
+                return last_update_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        last_update = _parse_last_update(d.pop("lastUpdate", UNSET))
+
+        com_hellopublic_userapigateway_api_rest_portfolio_gateway_cost_basis_type_0 = cls(
+            total_cost=total_cost,
+            unit_cost=unit_cost,
+            gain_value=gain_value,
+            gain_percentage=gain_percentage,
+            last_update=last_update,
+        )
+
+        com_hellopublic_userapigateway_api_rest_portfolio_gateway_cost_basis_type_0.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_portfolio_gateway_cost_basis_type_0
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_portfolio_gateway_portfolio_account_v2.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.com_hellopublic_userapigateway_api_rest_portfolio_gateway_portfolio_account_v2_account_type import (
+    ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioAccountV2AccountType,
+)
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.com_hellopublic_userapigateway_api_rest_order_gateway_order import (
+        ComHellopublicUserapigatewayApiRestOrderGatewayOrder,
+    )
+    from ..models.com_hellopublic_userapigateway_api_rest_portfolio_gateway_buying_power import (
+        ComHellopublicUserapigatewayApiRestPortfolioGatewayBuyingPower,
+    )
+    from ..models.com_hellopublic_userapigateway_api_rest_portfolio_gateway_portfolio_equity_v2 import (
+        ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioEquityV2,
+    )
+    from ..models.com_hellopublic_userapigateway_api_rest_portfolio_gateway_portfolio_position import (
+        ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioPosition,
+    )
+    from ..models.com_hellopublic_userapigateway_api_rest_portfolio_gateway_strategy import (
+        ComHellopublicUserapigatewayApiRestPortfolioGatewayStrategy,
+    )
+
+
+T = TypeVar("T", bound="ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioAccountV2")
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioAccountV2:
+    """Portfolio for the account
+
+    Attributes:
+        account_id (str): Id of the account
+        account_type (ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioAccountV2AccountType): Type of the
+            account
+        buying_power (ComHellopublicUserapigatewayApiRestPortfolioGatewayBuyingPower):
+        equity (list[ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioEquityV2]): List of equity summaries
+        positions (list[ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioPosition]): List of positions
+        orders (list[ComHellopublicUserapigatewayApiRestOrderGatewayOrder]):
+        strategies (list[ComHellopublicUserapigatewayApiRestPortfolioGatewayStrategy] | None | Unset): List of multi-leg
+            option strategies. Null if backend doesn't support strategies.
+    """
+
+    account_id: str
+    account_type: ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioAccountV2AccountType
+    buying_power: ComHellopublicUserapigatewayApiRestPortfolioGatewayBuyingPower
+    equity: list[ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioEquityV2]
+    positions: list[ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioPosition]
+    orders: list[ComHellopublicUserapigatewayApiRestOrderGatewayOrder]
+    strategies: list[ComHellopublicUserapigatewayApiRestPortfolioGatewayStrategy] | None | Unset = (
+        UNSET
+    )
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        account_id = self.account_id
+
+        account_type = self.account_type.value
+
+        buying_power = self.buying_power.to_dict()
+
+        equity = []
+        for equity_item_data in self.equity:
+            equity_item = equity_item_data.to_dict()
+            equity.append(equity_item)
+
+        positions = []
+        for positions_item_data in self.positions:
+            positions_item = positions_item_data.to_dict()
+            positions.append(positions_item)
+
+        orders = []
+        for orders_item_data in self.orders:
+            orders_item = orders_item_data.to_dict()
+            orders.append(orders_item)
+
+        strategies: list[dict[str, Any]] | None | Unset
+        if isinstance(self.strategies, Unset):
+            strategies = UNSET
+        elif isinstance(self.strategies, list):
+            strategies = []
+            for strategies_type_0_item_data in self.strategies:
+                strategies_type_0_item = strategies_type_0_item_data.to_dict()
+                strategies.append(strategies_type_0_item)
+
+        else:
+            strategies = self.strategies
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "accountId": account_id,
+                "accountType": account_type,
+                "buyingPower": buying_power,
+                "equity": equity,
+                "positions": positions,
+                "orders": orders,
+            }
+        )
+        if strategies is not UNSET:
+            field_dict["strategies"] = strategies
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.com_hellopublic_userapigateway_api_rest_order_gateway_order import (
+            ComHellopublicUserapigatewayApiRestOrderGatewayOrder,
+        )
+        from ..models.com_hellopublic_userapigateway_api_rest_portfolio_gateway_buying_power import (
+            ComHellopublicUserapigatewayApiRestPortfolioGatewayBuyingPower,
+        )
+        from ..models.com_hellopublic_userapigateway_api_rest_portfolio_gateway_portfolio_equity_v2 import (
+            ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioEquityV2,
+        )
+        from ..models.com_hellopublic_userapigateway_api_rest_portfolio_gateway_portfolio_position import (
+            ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioPosition,
+        )
+        from ..models.com_hellopublic_userapigateway_api_rest_portfolio_gateway_strategy import (
+            ComHellopublicUserapigatewayApiRestPortfolioGatewayStrategy,
+        )
+
+        d = dict(src_dict)
+        account_id = d.pop("accountId")
+
+        account_type = (
+            ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioAccountV2AccountType(
+                d.pop("accountType")
+            )
+        )
+
+        buying_power = ComHellopublicUserapigatewayApiRestPortfolioGatewayBuyingPower.from_dict(
+            d.pop("buyingPower")
+        )
+
+        equity = []
+        _equity = d.pop("equity")
+        for equity_item_data in _equity:
+            equity_item = (
+                ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioEquityV2.from_dict(
+                    equity_item_data
+                )
+            )
+
+            equity.append(equity_item)
+
+        positions = []
+        _positions = d.pop("positions")
+        for positions_item_data in _positions:
+            positions_item = (
+                ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioPosition.from_dict(
+                    positions_item_data
+                )
+            )
+
+            positions.append(positions_item)
+
+        orders = []
+        _orders = d.pop("orders")
+        for orders_item_data in _orders:
+            orders_item = ComHellopublicUserapigatewayApiRestOrderGatewayOrder.from_dict(
+                orders_item_data
+            )
+
+            orders.append(orders_item)
+
+        def _parse_strategies(
+            data: object,
+        ) -> list[ComHellopublicUserapigatewayApiRestPortfolioGatewayStrategy] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                strategies_type_0 = []
+                _strategies_type_0 = data
+                for strategies_type_0_item_data in _strategies_type_0:
+                    strategies_type_0_item = (
+                        ComHellopublicUserapigatewayApiRestPortfolioGatewayStrategy.from_dict(
+                            strategies_type_0_item_data
+                        )
+                    )
+
+                    strategies_type_0.append(strategies_type_0_item)
+
+                return strategies_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(
+                list[ComHellopublicUserapigatewayApiRestPortfolioGatewayStrategy] | None | Unset,
+                data,
+            )
+
+        strategies = _parse_strategies(d.pop("strategies", UNSET))
+
+        com_hellopublic_userapigateway_api_rest_portfolio_gateway_portfolio_account_v2 = cls(
+            account_id=account_id,
+            account_type=account_type,
+            buying_power=buying_power,
+            equity=equity,
+            positions=positions,
+            orders=orders,
+            strategies=strategies,
+        )
+
+        com_hellopublic_userapigateway_api_rest_portfolio_gateway_portfolio_account_v2.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_portfolio_gateway_portfolio_account_v2
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_portfolio_gateway_portfolio_account_v2_account_type.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+
+class ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioAccountV2AccountType(str, Enum):
+    BOND_ACCOUNT = "BOND_ACCOUNT"
+    BROKERAGE = "BROKERAGE"
+    HIGH_YIELD = "HIGH_YIELD"
+    RIA_ASSET = "RIA_ASSET"
+    ROTH_IRA = "ROTH_IRA"
+    TRADITIONAL_IRA = "TRADITIONAL_IRA"
+    TREASURY = "TREASURY"
+
+    def __str__(self) -> str:
+        return str(self.value)

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_portfolio_gateway_portfolio_equity_v2.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.com_hellopublic_userapigateway_api_rest_portfolio_gateway_portfolio_equity_v2_type import (
+    ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioEquityV2Type,
+)
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioEquityV2")
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioEquityV2:
+    """Portfolio equity summary
+
+    Attributes:
+        type_ (ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioEquityV2Type): Type of asset.
+        value (str): Total value for the given asset type.
+        percentage_of_portfolio (None | str | Unset): The percentage of the portfolio this asset type constitutes.
+                                          The percentage number is given with 2 decimals.
+    """
+
+    type_: ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioEquityV2Type
+    value: str
+    percentage_of_portfolio: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_.value
+
+        value = self.value
+
+        percentage_of_portfolio: None | str | Unset
+        if isinstance(self.percentage_of_portfolio, Unset):
+            percentage_of_portfolio = UNSET
+        else:
+            percentage_of_portfolio = self.percentage_of_portfolio
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "type": type_,
+                "value": value,
+            }
+        )
+        if percentage_of_portfolio is not UNSET:
+            field_dict["percentageOfPortfolio"] = percentage_of_portfolio
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        type_ = ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioEquityV2Type(
+            d.pop("type")
+        )
+
+        value = d.pop("value")
+
+        def _parse_percentage_of_portfolio(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        percentage_of_portfolio = _parse_percentage_of_portfolio(
+            d.pop("percentageOfPortfolio", UNSET)
+        )
+
+        com_hellopublic_userapigateway_api_rest_portfolio_gateway_portfolio_equity_v2 = cls(
+            type_=type_,
+            value=value,
+            percentage_of_portfolio=percentage_of_portfolio,
+        )
+
+        com_hellopublic_userapigateway_api_rest_portfolio_gateway_portfolio_equity_v2.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_portfolio_gateway_portfolio_equity_v2
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_portfolio_gateway_portfolio_equity_v2_type.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+
+class ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioEquityV2Type(str, Enum):
+    BONDS = "BONDS"
+    CASH = "CASH"
+    CRYPTO = "CRYPTO"
+    JIKO_ACCOUNT = "JIKO_ACCOUNT"
+    OPTIONS_LONG = "OPTIONS_LONG"
+    OPTIONS_SHORT = "OPTIONS_SHORT"
+    STOCK = "STOCK"
+
+    def __str__(self) -> str:
+        return str(self.value)

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_portfolio_gateway_portfolio_instrument.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.com_hellopublic_userapigateway_api_rest_portfolio_gateway_portfolio_instrument_type import (
+    ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioInstrumentType,
+)
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioInstrument")
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioInstrument:
+    """
+    Attributes:
+        symbol (str | Unset):
+        name (str | Unset):
+        type_ (ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioInstrumentType | Unset):
+    """
+
+    symbol: str | Unset = UNSET
+    name: str | Unset = UNSET
+    type_: ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioInstrumentType | Unset = (
+        UNSET
+    )
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        symbol = self.symbol
+
+        name = self.name
+
+        type_: str | Unset = UNSET
+        if not isinstance(self.type_, Unset):
+            type_ = self.type_.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if symbol is not UNSET:
+            field_dict["symbol"] = symbol
+        if name is not UNSET:
+            field_dict["name"] = name
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        symbol = d.pop("symbol", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        _type_ = d.pop("type", UNSET)
+        type_: ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioInstrumentType | Unset
+        if isinstance(_type_, Unset):
+            type_ = UNSET
+        else:
+            type_ = ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioInstrumentType(
+                _type_
+            )
+
+        com_hellopublic_userapigateway_api_rest_portfolio_gateway_portfolio_instrument = cls(
+            symbol=symbol,
+            name=name,
+            type_=type_,
+        )
+
+        com_hellopublic_userapigateway_api_rest_portfolio_gateway_portfolio_instrument.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_portfolio_gateway_portfolio_instrument
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_portfolio_gateway_portfolio_instrument_type.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+
+class ComHellopublicUserapigatewayApiRestPortfolioGatewayPortfolioInstrumentType(str, Enum):
+    ALT = "ALT"
+    BOND = "BOND"
+    CRYPTO = "CRYPTO"
+    EQUITY = "EQUITY"
+    INDEX = "INDEX"
+    OPTION = "OPTION"
+    TREASURY = "TREASURY"
+
+    def __str__(self) -> str:
+        return str(self.value)