robosystems-client 0.1.9__py3-none-any.whl

robosystems_client/models/connection_response.py

@@ -0,0 +1,149 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.connection_response_provider import ConnectionResponseProvider
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+  from ..models.connection_response_metadata import ConnectionResponseMetadata
+
+
+T = TypeVar("T", bound="ConnectionResponse")
+
+
+@_attrs_define
+class ConnectionResponse:
+  """Connection response model.
+
+  Attributes:
+      connection_id (str): Unique connection identifier
+      provider (ConnectionResponseProvider): Connection provider type
+      entity_id (str): Entity identifier
+      status (str): Connection status
+      created_at (str): Creation timestamp
+      metadata (ConnectionResponseMetadata): Provider-specific metadata
+      updated_at (Union[None, Unset, str]): Last update timestamp
+      last_sync (Union[None, Unset, str]): Last sync timestamp
+  """
+
+  connection_id: str
+  provider: ConnectionResponseProvider
+  entity_id: str
+  status: str
+  created_at: str
+  metadata: "ConnectionResponseMetadata"
+  updated_at: Union[None, Unset, str] = UNSET
+  last_sync: Union[None, Unset, str] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    connection_id = self.connection_id
+
+    provider = self.provider.value
+
+    entity_id = self.entity_id
+
+    status = self.status
+
+    created_at = self.created_at
+
+    metadata = self.metadata.to_dict()
+
+    updated_at: Union[None, Unset, str]
+    if isinstance(self.updated_at, Unset):
+      updated_at = UNSET
+    else:
+      updated_at = self.updated_at
+
+    last_sync: Union[None, Unset, str]
+    if isinstance(self.last_sync, Unset):
+      last_sync = UNSET
+    else:
+      last_sync = self.last_sync
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "connection_id": connection_id,
+        "provider": provider,
+        "entity_id": entity_id,
+        "status": status,
+        "created_at": created_at,
+        "metadata": metadata,
+      }
+    )
+    if updated_at is not UNSET:
+      field_dict["updated_at"] = updated_at
+    if last_sync is not UNSET:
+      field_dict["last_sync"] = last_sync
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.connection_response_metadata import ConnectionResponseMetadata
+
+    d = dict(src_dict)
+    connection_id = d.pop("connection_id")
+
+    provider = ConnectionResponseProvider(d.pop("provider"))
+
+    entity_id = d.pop("entity_id")
+
+    status = d.pop("status")
+
+    created_at = d.pop("created_at")
+
+    metadata = ConnectionResponseMetadata.from_dict(d.pop("metadata"))
+
+    def _parse_updated_at(data: object) -> Union[None, Unset, str]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, str], data)
+
+    updated_at = _parse_updated_at(d.pop("updated_at", UNSET))
+
+    def _parse_last_sync(data: object) -> Union[None, Unset, str]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, str], data)
+
+    last_sync = _parse_last_sync(d.pop("last_sync", UNSET))
+
+    connection_response = cls(
+      connection_id=connection_id,
+      provider=provider,
+      entity_id=entity_id,
+      status=status,
+      created_at=created_at,
+      metadata=metadata,
+      updated_at=updated_at,
+      last_sync=last_sync,
+    )
+
+    connection_response.additional_properties = d
+    return connection_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

robosystems_client/models/connection_response_metadata.py

@@ -0,0 +1,44 @@
+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="ConnectionResponseMetadata")
+
+
+@_attrs_define
+class ConnectionResponseMetadata:
+  """Provider-specific metadata"""
+
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    connection_response_metadata = cls()
+
+    connection_response_metadata.additional_properties = d
+    return connection_response_metadata
+
+  @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

robosystems_client/models/connection_response_provider.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class ConnectionResponseProvider(str, Enum):
+  PLAID = "plaid"
+  QUICKBOOKS = "quickbooks"
+  SEC = "sec"
+
+  def __str__(self) -> str:
+    return str(self.value)

robosystems_client/models/create_api_key_request.py

@@ -0,0 +1,82 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="CreateAPIKeyRequest")
+
+
+@_attrs_define
+class CreateAPIKeyRequest:
+  """Request model for creating a new API key.
+
+  Attributes:
+      name (str): Name for the API key
+      description (Union[None, Unset, str]): Optional description
+  """
+
+  name: str
+  description: Union[None, Unset, str] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    name = self.name
+
+    description: Union[None, Unset, str]
+    if isinstance(self.description, Unset):
+      description = UNSET
+    else:
+      description = self.description
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "name": name,
+      }
+    )
+    if description is not UNSET:
+      field_dict["description"] = description
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    name = d.pop("name")
+
+    def _parse_description(data: object) -> Union[None, Unset, str]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, str], data)
+
+    description = _parse_description(d.pop("description", UNSET))
+
+    create_api_key_request = cls(
+      name=name,
+      description=description,
+    )
+
+    create_api_key_request.additional_properties = d
+    return create_api_key_request
+
+  @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

robosystems_client/models/create_api_key_response.py

@@ -0,0 +1,74 @@
+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
+
+if TYPE_CHECKING:
+  from ..models.api_key_info import APIKeyInfo
+
+
+T = TypeVar("T", bound="CreateAPIKeyResponse")
+
+
+@_attrs_define
+class CreateAPIKeyResponse:
+  """Response model for creating a new API key.
+
+  Attributes:
+      api_key (APIKeyInfo): API key information response model.
+      key (str): The actual API key (only shown once)
+  """
+
+  api_key: "APIKeyInfo"
+  key: str
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    api_key = self.api_key.to_dict()
+
+    key = self.key
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "api_key": api_key,
+        "key": key,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.api_key_info import APIKeyInfo
+
+    d = dict(src_dict)
+    api_key = APIKeyInfo.from_dict(d.pop("api_key"))
+
+    key = d.pop("key")
+
+    create_api_key_response = cls(
+      api_key=api_key,
+      key=key,
+    )
+
+    create_api_key_response.additional_properties = d
+    return create_api_key_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

robosystems_client/models/create_connection_request.py

@@ -0,0 +1,179 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.create_connection_request_provider import CreateConnectionRequestProvider
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+  from ..models.plaid_connection_config import PlaidConnectionConfig
+  from ..models.quick_books_connection_config import QuickBooksConnectionConfig
+  from ..models.sec_connection_config import SECConnectionConfig
+
+
+T = TypeVar("T", bound="CreateConnectionRequest")
+
+
+@_attrs_define
+class CreateConnectionRequest:
+  """Request to create a new connection.
+
+  Attributes:
+      provider (CreateConnectionRequestProvider): Connection provider type
+      entity_id (str): Entity identifier
+      sec_config (Union['SECConnectionConfig', None, Unset]):
+      quickbooks_config (Union['QuickBooksConnectionConfig', None, Unset]):
+      plaid_config (Union['PlaidConnectionConfig', None, Unset]):
+  """
+
+  provider: CreateConnectionRequestProvider
+  entity_id: str
+  sec_config: Union["SECConnectionConfig", None, Unset] = UNSET
+  quickbooks_config: Union["QuickBooksConnectionConfig", None, Unset] = UNSET
+  plaid_config: Union["PlaidConnectionConfig", None, Unset] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    from ..models.plaid_connection_config import PlaidConnectionConfig
+    from ..models.quick_books_connection_config import QuickBooksConnectionConfig
+    from ..models.sec_connection_config import SECConnectionConfig
+
+    provider = self.provider.value
+
+    entity_id = self.entity_id
+
+    sec_config: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.sec_config, Unset):
+      sec_config = UNSET
+    elif isinstance(self.sec_config, SECConnectionConfig):
+      sec_config = self.sec_config.to_dict()
+    else:
+      sec_config = self.sec_config
+
+    quickbooks_config: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.quickbooks_config, Unset):
+      quickbooks_config = UNSET
+    elif isinstance(self.quickbooks_config, QuickBooksConnectionConfig):
+      quickbooks_config = self.quickbooks_config.to_dict()
+    else:
+      quickbooks_config = self.quickbooks_config
+
+    plaid_config: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.plaid_config, Unset):
+      plaid_config = UNSET
+    elif isinstance(self.plaid_config, PlaidConnectionConfig):
+      plaid_config = self.plaid_config.to_dict()
+    else:
+      plaid_config = self.plaid_config
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "provider": provider,
+        "entity_id": entity_id,
+      }
+    )
+    if sec_config is not UNSET:
+      field_dict["sec_config"] = sec_config
+    if quickbooks_config is not UNSET:
+      field_dict["quickbooks_config"] = quickbooks_config
+    if plaid_config is not UNSET:
+      field_dict["plaid_config"] = plaid_config
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.plaid_connection_config import PlaidConnectionConfig
+    from ..models.quick_books_connection_config import QuickBooksConnectionConfig
+    from ..models.sec_connection_config import SECConnectionConfig
+
+    d = dict(src_dict)
+    provider = CreateConnectionRequestProvider(d.pop("provider"))
+
+    entity_id = d.pop("entity_id")
+
+    def _parse_sec_config(data: object) -> Union["SECConnectionConfig", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        sec_config_type_0 = SECConnectionConfig.from_dict(data)
+
+        return sec_config_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["SECConnectionConfig", None, Unset], data)
+
+    sec_config = _parse_sec_config(d.pop("sec_config", UNSET))
+
+    def _parse_quickbooks_config(
+      data: object,
+    ) -> Union["QuickBooksConnectionConfig", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        quickbooks_config_type_0 = QuickBooksConnectionConfig.from_dict(data)
+
+        return quickbooks_config_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["QuickBooksConnectionConfig", None, Unset], data)
+
+    quickbooks_config = _parse_quickbooks_config(d.pop("quickbooks_config", UNSET))
+
+    def _parse_plaid_config(
+      data: object,
+    ) -> Union["PlaidConnectionConfig", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        plaid_config_type_0 = PlaidConnectionConfig.from_dict(data)
+
+        return plaid_config_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["PlaidConnectionConfig", None, Unset], data)
+
+    plaid_config = _parse_plaid_config(d.pop("plaid_config", UNSET))
+
+    create_connection_request = cls(
+      provider=provider,
+      entity_id=entity_id,
+      sec_config=sec_config,
+      quickbooks_config=quickbooks_config,
+      plaid_config=plaid_config,
+    )
+
+    create_connection_request.additional_properties = d
+    return create_connection_request
+
+  @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

robosystems_client/models/create_connection_request_provider.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class CreateConnectionRequestProvider(str, Enum):
+  PLAID = "plaid"
+  QUICKBOOKS = "quickbooks"
+  SEC = "sec"
+
+  def __str__(self) -> str:
+    return str(self.value)