publicdotcom-cli 1.0.0__py3-none-any.whl

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_order_gateway_short_selling.py

@@ -0,0 +1,127 @@
+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_order_gateway_short_selling_availability import (
+    ComHellopublicUserapigatewayApiRestOrderGatewayShortSellingAvailability,
+)
+from ..models.com_hellopublic_userapigateway_api_rest_order_gateway_short_selling_uptick_rule import (
+    ComHellopublicUserapigatewayApiRestOrderGatewayShortSellingUptickRule,
+)
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ComHellopublicUserapigatewayApiRestOrderGatewayShortSelling")
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestOrderGatewayShortSelling:
+    """Short-selling information for the given instrument.
+
+    Attributes:
+        availability (ComHellopublicUserapigatewayApiRestOrderGatewayShortSellingAvailability): the availability of
+            short-selling for this instrument.
+        uptick_rule (ComHellopublicUserapigatewayApiRestOrderGatewayShortSellingUptickRule): the Uptick Rule is
+            triggered for equities when the price today or yesterday has dropped at least 10 percent since previous days'
+            closing price.
+        hard_to_borrow_percentage_rate (str | Unset): the hard to borrow rate as a percentage value.
+        initial_margin_requirement_percentage (str | Unset): the initial margin requirement as a percentage value.
+        maintenance_margin_requirement_percentage (str | Unset): the maintenance margin requirement as a percentage
+            value.
+        max_quantity_for_locate (int | Unset): the maximum quantity that we can request to locate for all hard-to-borrow
+            stocks. The actual number we can locate can be lower for concrete stocks.
+    """
+
+    availability: ComHellopublicUserapigatewayApiRestOrderGatewayShortSellingAvailability
+    uptick_rule: ComHellopublicUserapigatewayApiRestOrderGatewayShortSellingUptickRule
+    hard_to_borrow_percentage_rate: str | Unset = UNSET
+    initial_margin_requirement_percentage: str | Unset = UNSET
+    maintenance_margin_requirement_percentage: str | Unset = UNSET
+    max_quantity_for_locate: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        availability = self.availability.value
+
+        uptick_rule = self.uptick_rule.value
+
+        hard_to_borrow_percentage_rate = self.hard_to_borrow_percentage_rate
+
+        initial_margin_requirement_percentage = self.initial_margin_requirement_percentage
+
+        maintenance_margin_requirement_percentage = self.maintenance_margin_requirement_percentage
+
+        max_quantity_for_locate = self.max_quantity_for_locate
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "availability": availability,
+                "uptickRule": uptick_rule,
+            }
+        )
+        if hard_to_borrow_percentage_rate is not UNSET:
+            field_dict["hardToBorrowPercentageRate"] = hard_to_borrow_percentage_rate
+        if initial_margin_requirement_percentage is not UNSET:
+            field_dict["initialMarginRequirementPercentage"] = initial_margin_requirement_percentage
+        if maintenance_margin_requirement_percentage is not UNSET:
+            field_dict["maintenanceMarginRequirementPercentage"] = (
+                maintenance_margin_requirement_percentage
+            )
+        if max_quantity_for_locate is not UNSET:
+            field_dict["maxQuantityForLocate"] = max_quantity_for_locate
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        availability = ComHellopublicUserapigatewayApiRestOrderGatewayShortSellingAvailability(
+            d.pop("availability")
+        )
+
+        uptick_rule = ComHellopublicUserapigatewayApiRestOrderGatewayShortSellingUptickRule(
+            d.pop("uptickRule")
+        )
+
+        hard_to_borrow_percentage_rate = d.pop("hardToBorrowPercentageRate", UNSET)
+
+        initial_margin_requirement_percentage = d.pop("initialMarginRequirementPercentage", UNSET)
+
+        maintenance_margin_requirement_percentage = d.pop(
+            "maintenanceMarginRequirementPercentage", UNSET
+        )
+
+        max_quantity_for_locate = d.pop("maxQuantityForLocate", UNSET)
+
+        com_hellopublic_userapigateway_api_rest_order_gateway_short_selling = cls(
+            availability=availability,
+            uptick_rule=uptick_rule,
+            hard_to_borrow_percentage_rate=hard_to_borrow_percentage_rate,
+            initial_margin_requirement_percentage=initial_margin_requirement_percentage,
+            maintenance_margin_requirement_percentage=maintenance_margin_requirement_percentage,
+            max_quantity_for_locate=max_quantity_for_locate,
+        )
+
+        com_hellopublic_userapigateway_api_rest_order_gateway_short_selling.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_order_gateway_short_selling
+
+    @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_order_gateway_short_selling_availability.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class ComHellopublicUserapigatewayApiRestOrderGatewayShortSellingAvailability(str, Enum):
+    EASY_TO_BORROW = "EASY_TO_BORROW"
+    HARD_TO_BORROW = "HARD_TO_BORROW"
+    NOT_SHORTABLE = "NOT_SHORTABLE"
+
+    def __str__(self) -> str:
+        return str(self.value)

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_order_gateway_short_selling_uptick_rule.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class ComHellopublicUserapigatewayApiRestOrderGatewayShortSellingUptickRule(str, Enum):
+    NOT_TRIGGERED = "NOT_TRIGGERED"
+    TRIGGERED = "TRIGGERED"
+
+    def __str__(self) -> str:
+        return str(self.value)

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_order_instrumentdetails_api_instrument_details.py

@@ -0,0 +1,67 @@
+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
+
+T = TypeVar(
+    "T", bound="ComHellopublicUserapigatewayApiRestOrderInstrumentdetailsApiInstrumentDetails"
+)
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestOrderInstrumentdetailsApiInstrumentDetails:
+    """
+    Attributes:
+        payload_type (str):
+    """
+
+    payload_type: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        payload_type = self.payload_type
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "payloadType": payload_type,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        payload_type = d.pop("payloadType")
+
+        com_hellopublic_userapigateway_api_rest_order_instrumentdetails_api_instrument_details = (
+            cls(
+                payload_type=payload_type,
+            )
+        )
+
+        com_hellopublic_userapigateway_api_rest_order_instrumentdetails_api_instrument_details.additional_properties = d
+        return (
+            com_hellopublic_userapigateway_api_rest_order_instrumentdetails_api_instrument_details
+        )
+
+    @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_order_instrumentdetails_api_instrument_details_bond.py

@@ -0,0 +1,74 @@
+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 ..types import UNSET, Unset
+
+T = TypeVar(
+    "T", bound="ComHellopublicUserapigatewayApiRestOrderInstrumentdetailsApiInstrumentDetailsBond"
+)
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestOrderInstrumentdetailsApiInstrumentDetailsBond:
+    """
+    Attributes:
+        payload_type (str):
+        has_outstanding (bool | Unset):
+    """
+
+    payload_type: str
+    has_outstanding: bool | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        payload_type = self.payload_type
+
+        has_outstanding = self.has_outstanding
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "payloadType": payload_type,
+            }
+        )
+        if has_outstanding is not UNSET:
+            field_dict["hasOutstanding"] = has_outstanding
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        payload_type = d.pop("payloadType")
+
+        has_outstanding = d.pop("hasOutstanding", UNSET)
+
+        com_hellopublic_userapigateway_api_rest_order_instrumentdetails_api_instrument_details_bond = cls(
+            payload_type=payload_type,
+            has_outstanding=has_outstanding,
+        )
+
+        com_hellopublic_userapigateway_api_rest_order_instrumentdetails_api_instrument_details_bond.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_order_instrumentdetails_api_instrument_details_bond
+
+    @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_order_instrumentdetails_api_instrument_details_crypto.py

@@ -0,0 +1,92 @@
+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 ..types import UNSET, Unset
+
+T = TypeVar(
+    "T", bound="ComHellopublicUserapigatewayApiRestOrderInstrumentdetailsApiInstrumentDetailsCrypto"
+)
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestOrderInstrumentdetailsApiInstrumentDetailsCrypto:
+    """
+    Attributes:
+        payload_type (str):
+        crypto_quantity_precision (int | Unset):
+        crypto_price_precision (int | Unset):
+        tradable_in_new_york (bool | Unset):
+    """
+
+    payload_type: str
+    crypto_quantity_precision: int | Unset = UNSET
+    crypto_price_precision: int | Unset = UNSET
+    tradable_in_new_york: bool | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        payload_type = self.payload_type
+
+        crypto_quantity_precision = self.crypto_quantity_precision
+
+        crypto_price_precision = self.crypto_price_precision
+
+        tradable_in_new_york = self.tradable_in_new_york
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "payloadType": payload_type,
+            }
+        )
+        if crypto_quantity_precision is not UNSET:
+            field_dict["cryptoQuantityPrecision"] = crypto_quantity_precision
+        if crypto_price_precision is not UNSET:
+            field_dict["cryptoPricePrecision"] = crypto_price_precision
+        if tradable_in_new_york is not UNSET:
+            field_dict["tradableInNewYork"] = tradable_in_new_york
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        payload_type = d.pop("payloadType")
+
+        crypto_quantity_precision = d.pop("cryptoQuantityPrecision", UNSET)
+
+        crypto_price_precision = d.pop("cryptoPricePrecision", UNSET)
+
+        tradable_in_new_york = d.pop("tradableInNewYork", UNSET)
+
+        com_hellopublic_userapigateway_api_rest_order_instrumentdetails_api_instrument_details_crypto = cls(
+            payload_type=payload_type,
+            crypto_quantity_precision=crypto_quantity_precision,
+            crypto_price_precision=crypto_price_precision,
+            tradable_in_new_york=tradable_in_new_york,
+        )
+
+        com_hellopublic_userapigateway_api_rest_order_instrumentdetails_api_instrument_details_crypto.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_order_instrumentdetails_api_instrument_details_crypto
+
+    @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_order_order_expiration.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import datetime
+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 dateutil.parser import isoparse
+
+from ..models.com_hellopublic_userapigateway_api_rest_order_order_expiration_time_in_force import (
+    ComHellopublicUserapigatewayApiRestOrderOrderExpirationTimeInForce,
+)
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ComHellopublicUserapigatewayApiRestOrderOrderExpiration")
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestOrderOrderExpiration:
+    """
+    Attributes:
+        time_in_force (ComHellopublicUserapigatewayApiRestOrderOrderExpirationTimeInForce): The time in for the order
+        expiration_time (datetime.datetime | Unset): The expiration date. Only used when timeInForce is GTD, cannot be
+            more than 90 days in the future
+    """
+
+    time_in_force: ComHellopublicUserapigatewayApiRestOrderOrderExpirationTimeInForce
+    expiration_time: datetime.datetime | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        time_in_force = self.time_in_force.value
+
+        expiration_time: str | Unset = UNSET
+        if not isinstance(self.expiration_time, Unset):
+            expiration_time = self.expiration_time.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "timeInForce": time_in_force,
+            }
+        )
+        if expiration_time is not UNSET:
+            field_dict["expirationTime"] = expiration_time
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        time_in_force = ComHellopublicUserapigatewayApiRestOrderOrderExpirationTimeInForce(
+            d.pop("timeInForce")
+        )
+
+        _expiration_time = d.pop("expirationTime", UNSET)
+        expiration_time: datetime.datetime | Unset
+        if isinstance(_expiration_time, Unset):
+            expiration_time = UNSET
+        else:
+            expiration_time = isoparse(_expiration_time)
+
+        com_hellopublic_userapigateway_api_rest_order_order_expiration = cls(
+            time_in_force=time_in_force,
+            expiration_time=expiration_time,
+        )
+
+        com_hellopublic_userapigateway_api_rest_order_order_expiration.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_order_order_expiration
+
+    @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_order_order_expiration_time_in_force.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class ComHellopublicUserapigatewayApiRestOrderOrderExpirationTimeInForce(str, Enum):
+    DAY = "DAY"
+    GTD = "GTD"
+
+    def __str__(self) -> str:
+        return str(self.value)

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_portfolio_gain_type_0.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import datetime
+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 dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ComHellopublicUserapigatewayApiRestPortfolioGainType0")
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestPortfolioGainType0:
+    """
+    Attributes:
+        gain_value (str | Unset):
+        gain_percentage (str | Unset):
+        timestamp (datetime.datetime | Unset):
+    """
+
+    gain_value: str | Unset = UNSET
+    gain_percentage: str | Unset = UNSET
+    timestamp: datetime.datetime | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        gain_value = self.gain_value
+
+        gain_percentage = self.gain_percentage
+
+        timestamp: str | Unset = UNSET
+        if not isinstance(self.timestamp, Unset):
+            timestamp = self.timestamp.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if gain_value is not UNSET:
+            field_dict["gainValue"] = gain_value
+        if gain_percentage is not UNSET:
+            field_dict["gainPercentage"] = gain_percentage
+        if timestamp is not UNSET:
+            field_dict["timestamp"] = timestamp
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        gain_value = d.pop("gainValue", UNSET)
+
+        gain_percentage = d.pop("gainPercentage", UNSET)
+
+        _timestamp = d.pop("timestamp", UNSET)
+        timestamp: datetime.datetime | Unset
+        if isinstance(_timestamp, Unset):
+            timestamp = UNSET
+        else:
+            timestamp = isoparse(_timestamp)
+
+        com_hellopublic_userapigateway_api_rest_portfolio_gain_type_0 = cls(
+            gain_value=gain_value,
+            gain_percentage=gain_percentage,
+            timestamp=timestamp,
+        )
+
+        com_hellopublic_userapigateway_api_rest_portfolio_gain_type_0.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_portfolio_gain_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_buying_power.py

@@ -0,0 +1,77 @@
+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
+
+T = TypeVar("T", bound="ComHellopublicUserapigatewayApiRestPortfolioGatewayBuyingPower")
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestPortfolioGatewayBuyingPower:
+    """
+    Attributes:
+        cash_only_buying_power (str): Buying power available for trading on cash only without taking loans.
+        buying_power (str): Buying power available for trading marginable assets.
+        options_buying_power (str): Buying power available for trading options.
+    """
+
+    cash_only_buying_power: str
+    buying_power: str
+    options_buying_power: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        cash_only_buying_power = self.cash_only_buying_power
+
+        buying_power = self.buying_power
+
+        options_buying_power = self.options_buying_power
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "cashOnlyBuyingPower": cash_only_buying_power,
+                "buyingPower": buying_power,
+                "optionsBuyingPower": options_buying_power,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        cash_only_buying_power = d.pop("cashOnlyBuyingPower")
+
+        buying_power = d.pop("buyingPower")
+
+        options_buying_power = d.pop("optionsBuyingPower")
+
+        com_hellopublic_userapigateway_api_rest_portfolio_gateway_buying_power = cls(
+            cash_only_buying_power=cash_only_buying_power,
+            buying_power=buying_power,
+            options_buying_power=options_buying_power,
+        )
+
+        com_hellopublic_userapigateway_api_rest_portfolio_gateway_buying_power.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_portfolio_gateway_buying_power
+
+    @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