publicdotcom-cli 1.0.0__py3-none-any.whl

publicdotcom_cli/_generated/models/com_hellopublic_userapiauthservice_domain_error_error_body.py

@@ -0,0 +1,70 @@
+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="ComHellopublicUserapiauthserviceDomainErrorErrorBody")
+
+
+@_attrs_define
+class ComHellopublicUserapiauthserviceDomainErrorErrorBody:
+    """
+    Attributes:
+        error_code (str | Unset):
+        message (str | Unset):
+    """
+
+    error_code: str | Unset = UNSET
+    message: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        error_code = self.error_code
+
+        message = self.message
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if error_code is not UNSET:
+            field_dict["errorCode"] = error_code
+        if message is not UNSET:
+            field_dict["message"] = message
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        error_code = d.pop("errorCode", UNSET)
+
+        message = d.pop("message", UNSET)
+
+        com_hellopublic_userapiauthservice_domain_error_error_body = cls(
+            error_code=error_code,
+            message=message,
+        )
+
+        com_hellopublic_userapiauthservice_domain_error_error_body.additional_properties = d
+        return com_hellopublic_userapiauthservice_domain_error_error_body
+
+    @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_account_account_settings.py

@@ -0,0 +1,161 @@
+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_account_account_settings_account_type import (
+    ComHellopublicUserapigatewayApiRestAccountAccountSettingsAccountType,
+)
+from ..models.com_hellopublic_userapigateway_api_rest_account_account_settings_brokerage_account_type import (
+    ComHellopublicUserapigatewayApiRestAccountAccountSettingsBrokerageAccountType,
+)
+from ..models.com_hellopublic_userapigateway_api_rest_account_account_settings_options_level import (
+    ComHellopublicUserapigatewayApiRestAccountAccountSettingsOptionsLevel,
+)
+from ..models.com_hellopublic_userapigateway_api_rest_account_account_settings_trade_permissions import (
+    ComHellopublicUserapigatewayApiRestAccountAccountSettingsTradePermissions,
+)
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ComHellopublicUserapigatewayApiRestAccountAccountSettings")
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestAccountAccountSettings:
+    """
+    Attributes:
+        account_id (str | Unset):
+        account_type (ComHellopublicUserapigatewayApiRestAccountAccountSettingsAccountType | Unset):
+        options_level (ComHellopublicUserapigatewayApiRestAccountAccountSettingsOptionsLevel | Unset):
+        brokerage_account_type (ComHellopublicUserapigatewayApiRestAccountAccountSettingsBrokerageAccountType | Unset):
+        trade_permissions (ComHellopublicUserapigatewayApiRestAccountAccountSettingsTradePermissions | Unset):
+    """
+
+    account_id: str | Unset = UNSET
+    account_type: ComHellopublicUserapigatewayApiRestAccountAccountSettingsAccountType | Unset = (
+        UNSET
+    )
+    options_level: ComHellopublicUserapigatewayApiRestAccountAccountSettingsOptionsLevel | Unset = (
+        UNSET
+    )
+    brokerage_account_type: (
+        ComHellopublicUserapigatewayApiRestAccountAccountSettingsBrokerageAccountType | Unset
+    ) = UNSET
+    trade_permissions: (
+        ComHellopublicUserapigatewayApiRestAccountAccountSettingsTradePermissions | 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: str | Unset = UNSET
+        if not isinstance(self.account_type, Unset):
+            account_type = self.account_type.value
+
+        options_level: str | Unset = UNSET
+        if not isinstance(self.options_level, Unset):
+            options_level = self.options_level.value
+
+        brokerage_account_type: str | Unset = UNSET
+        if not isinstance(self.brokerage_account_type, Unset):
+            brokerage_account_type = self.brokerage_account_type.value
+
+        trade_permissions: str | Unset = UNSET
+        if not isinstance(self.trade_permissions, Unset):
+            trade_permissions = self.trade_permissions.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if account_id is not UNSET:
+            field_dict["accountId"] = account_id
+        if account_type is not UNSET:
+            field_dict["accountType"] = account_type
+        if options_level is not UNSET:
+            field_dict["optionsLevel"] = options_level
+        if brokerage_account_type is not UNSET:
+            field_dict["brokerageAccountType"] = brokerage_account_type
+        if trade_permissions is not UNSET:
+            field_dict["tradePermissions"] = trade_permissions
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        account_id = d.pop("accountId", UNSET)
+
+        _account_type = d.pop("accountType", UNSET)
+        account_type: ComHellopublicUserapigatewayApiRestAccountAccountSettingsAccountType | Unset
+        if isinstance(_account_type, Unset):
+            account_type = UNSET
+        else:
+            account_type = ComHellopublicUserapigatewayApiRestAccountAccountSettingsAccountType(
+                _account_type
+            )
+
+        _options_level = d.pop("optionsLevel", UNSET)
+        options_level: ComHellopublicUserapigatewayApiRestAccountAccountSettingsOptionsLevel | Unset
+        if isinstance(_options_level, Unset):
+            options_level = UNSET
+        else:
+            options_level = ComHellopublicUserapigatewayApiRestAccountAccountSettingsOptionsLevel(
+                _options_level
+            )
+
+        _brokerage_account_type = d.pop("brokerageAccountType", UNSET)
+        brokerage_account_type: (
+            ComHellopublicUserapigatewayApiRestAccountAccountSettingsBrokerageAccountType | Unset
+        )
+        if isinstance(_brokerage_account_type, Unset):
+            brokerage_account_type = UNSET
+        else:
+            brokerage_account_type = (
+                ComHellopublicUserapigatewayApiRestAccountAccountSettingsBrokerageAccountType(
+                    _brokerage_account_type
+                )
+            )
+
+        _trade_permissions = d.pop("tradePermissions", UNSET)
+        trade_permissions: (
+            ComHellopublicUserapigatewayApiRestAccountAccountSettingsTradePermissions | Unset
+        )
+        if isinstance(_trade_permissions, Unset):
+            trade_permissions = UNSET
+        else:
+            trade_permissions = (
+                ComHellopublicUserapigatewayApiRestAccountAccountSettingsTradePermissions(
+                    _trade_permissions
+                )
+            )
+
+        com_hellopublic_userapigateway_api_rest_account_account_settings = cls(
+            account_id=account_id,
+            account_type=account_type,
+            options_level=options_level,
+            brokerage_account_type=brokerage_account_type,
+            trade_permissions=trade_permissions,
+        )
+
+        com_hellopublic_userapigateway_api_rest_account_account_settings.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_account_account_settings
+
+    @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_account_account_settings_account_type.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+
+class ComHellopublicUserapigatewayApiRestAccountAccountSettingsAccountType(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_account_account_settings_brokerage_account_type.py

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

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_account_account_settings_options_level.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class ComHellopublicUserapigatewayApiRestAccountAccountSettingsOptionsLevel(str, Enum):
+    LEVEL_1 = "LEVEL_1"
+    LEVEL_2 = "LEVEL_2"
+    LEVEL_3 = "LEVEL_3"
+    LEVEL_4 = "LEVEL_4"
+    NONE = "NONE"
+
+    def __str__(self) -> str:
+        return str(self.value)

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_account_account_settings_response.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.com_hellopublic_userapigateway_api_rest_account_account_settings import (
+        ComHellopublicUserapigatewayApiRestAccountAccountSettings,
+    )
+
+
+T = TypeVar("T", bound="ComHellopublicUserapigatewayApiRestAccountAccountSettingsResponse")
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestAccountAccountSettingsResponse:
+    """
+    Attributes:
+        accounts (list[ComHellopublicUserapigatewayApiRestAccountAccountSettings] | Unset):
+    """
+
+    accounts: list[ComHellopublicUserapigatewayApiRestAccountAccountSettings] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        accounts: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.accounts, Unset):
+            accounts = []
+            for accounts_item_data in self.accounts:
+                accounts_item = accounts_item_data.to_dict()
+                accounts.append(accounts_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if accounts is not UNSET:
+            field_dict["accounts"] = accounts
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.com_hellopublic_userapigateway_api_rest_account_account_settings import (
+            ComHellopublicUserapigatewayApiRestAccountAccountSettings,
+        )
+
+        d = dict(src_dict)
+        _accounts = d.pop("accounts", UNSET)
+        accounts: list[ComHellopublicUserapigatewayApiRestAccountAccountSettings] | Unset = UNSET
+        if _accounts is not UNSET:
+            accounts = []
+            for accounts_item_data in _accounts:
+                accounts_item = ComHellopublicUserapigatewayApiRestAccountAccountSettings.from_dict(
+                    accounts_item_data
+                )
+
+                accounts.append(accounts_item)
+
+        com_hellopublic_userapigateway_api_rest_account_account_settings_response = cls(
+            accounts=accounts,
+        )
+
+        com_hellopublic_userapigateway_api_rest_account_account_settings_response.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_account_account_settings_response
+
+    @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_account_account_settings_trade_permissions.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class ComHellopublicUserapigatewayApiRestAccountAccountSettingsTradePermissions(str, Enum):
+    BUY_AND_SELL = "BUY_AND_SELL"
+    RESTRICTED_CLOSE_ONLY = "RESTRICTED_CLOSE_ONLY"
+    RESTRICTED_NO_TRADING = "RESTRICTED_NO_TRADING"
+    RESTRICTED_SETTLED_FUNDS_ONLY = "RESTRICTED_SETTLED_FUNDS_ONLY"
+
+    def __str__(self) -> str:
+        return str(self.value)

publicdotcom_cli/_generated/models/com_hellopublic_userapigateway_api_rest_history_gateway_history_response_page.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+import datetime
+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 dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.com_hellopublic_userapigateway_api_rest_history_gateway_history_transaction import (
+        ComHellopublicUserapigatewayApiRestHistoryGatewayHistoryTransaction,
+    )
+
+
+T = TypeVar("T", bound="ComHellopublicUserapigatewayApiRestHistoryGatewayHistoryResponsePage")
+
+
+@_attrs_define
+class ComHellopublicUserapigatewayApiRestHistoryGatewayHistoryResponsePage:
+    """Gateway history response page
+
+    Attributes:
+        transactions (list[ComHellopublicUserapigatewayApiRestHistoryGatewayHistoryTransaction] | Unset): List of
+            transactions
+        next_token (None | str | Unset): Token to retrieve the next page of results
+        start (datetime.datetime | None | Unset): Start timestamp of the history query
+        end (datetime.datetime | None | Unset): End timestamp of the history query
+        page_size (int | None | Unset): Number of items to return
+    """
+
+    transactions: (
+        list[ComHellopublicUserapigatewayApiRestHistoryGatewayHistoryTransaction] | Unset
+    ) = UNSET
+    next_token: None | str | Unset = UNSET
+    start: datetime.datetime | None | Unset = UNSET
+    end: datetime.datetime | None | Unset = UNSET
+    page_size: int | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        transactions: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.transactions, Unset):
+            transactions = []
+            for transactions_item_data in self.transactions:
+                transactions_item = transactions_item_data.to_dict()
+                transactions.append(transactions_item)
+
+        next_token: None | str | Unset
+        if isinstance(self.next_token, Unset):
+            next_token = UNSET
+        else:
+            next_token = self.next_token
+
+        start: None | str | Unset
+        if isinstance(self.start, Unset):
+            start = UNSET
+        elif isinstance(self.start, datetime.datetime):
+            start = self.start.isoformat()
+        else:
+            start = self.start
+
+        end: None | str | Unset
+        if isinstance(self.end, Unset):
+            end = UNSET
+        elif isinstance(self.end, datetime.datetime):
+            end = self.end.isoformat()
+        else:
+            end = self.end
+
+        page_size: int | None | Unset
+        if isinstance(self.page_size, Unset):
+            page_size = UNSET
+        else:
+            page_size = self.page_size
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if transactions is not UNSET:
+            field_dict["transactions"] = transactions
+        if next_token is not UNSET:
+            field_dict["nextToken"] = next_token
+        if start is not UNSET:
+            field_dict["start"] = start
+        if end is not UNSET:
+            field_dict["end"] = end
+        if page_size is not UNSET:
+            field_dict["pageSize"] = page_size
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.com_hellopublic_userapigateway_api_rest_history_gateway_history_transaction import (
+            ComHellopublicUserapigatewayApiRestHistoryGatewayHistoryTransaction,
+        )
+
+        d = dict(src_dict)
+        _transactions = d.pop("transactions", UNSET)
+        transactions: (
+            list[ComHellopublicUserapigatewayApiRestHistoryGatewayHistoryTransaction] | Unset
+        ) = UNSET
+        if _transactions is not UNSET:
+            transactions = []
+            for transactions_item_data in _transactions:
+                transactions_item = (
+                    ComHellopublicUserapigatewayApiRestHistoryGatewayHistoryTransaction.from_dict(
+                        transactions_item_data
+                    )
+                )
+
+                transactions.append(transactions_item)
+
+        def _parse_next_token(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        next_token = _parse_next_token(d.pop("nextToken", UNSET))
+
+        def _parse_start(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()
+                start_type_0 = isoparse(data)
+
+                return start_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        start = _parse_start(d.pop("start", UNSET))
+
+        def _parse_end(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()
+                end_type_0 = isoparse(data)
+
+                return end_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        end = _parse_end(d.pop("end", UNSET))
+
+        def _parse_page_size(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        page_size = _parse_page_size(d.pop("pageSize", UNSET))
+
+        com_hellopublic_userapigateway_api_rest_history_gateway_history_response_page = cls(
+            transactions=transactions,
+            next_token=next_token,
+            start=start,
+            end=end,
+            page_size=page_size,
+        )
+
+        com_hellopublic_userapigateway_api_rest_history_gateway_history_response_page.additional_properties = d
+        return com_hellopublic_userapigateway_api_rest_history_gateway_history_response_page
+
+    @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