robosystems-client 0.1.9__py3-none-any.whl

robosystems_client/models/backup_stats_response.py

@@ -0,0 +1,156 @@
+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
+
+if TYPE_CHECKING:
+  from ..models.backup_stats_response_backup_formats import (
+    BackupStatsResponseBackupFormats,
+  )
+
+
+T = TypeVar("T", bound="BackupStatsResponse")
+
+
+@_attrs_define
+class BackupStatsResponse:
+  """Response model for backup statistics.
+
+  Attributes:
+      graph_id (str):
+      total_backups (int):
+      successful_backups (int):
+      failed_backups (int):
+      success_rate (float):
+      total_original_size_bytes (int):
+      total_compressed_size_bytes (int):
+      storage_saved_bytes (int):
+      average_compression_ratio (float):
+      latest_backup_date (Union[None, str]):
+      backup_formats (BackupStatsResponseBackupFormats):
+  """
+
+  graph_id: str
+  total_backups: int
+  successful_backups: int
+  failed_backups: int
+  success_rate: float
+  total_original_size_bytes: int
+  total_compressed_size_bytes: int
+  storage_saved_bytes: int
+  average_compression_ratio: float
+  latest_backup_date: Union[None, str]
+  backup_formats: "BackupStatsResponseBackupFormats"
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    graph_id = self.graph_id
+
+    total_backups = self.total_backups
+
+    successful_backups = self.successful_backups
+
+    failed_backups = self.failed_backups
+
+    success_rate = self.success_rate
+
+    total_original_size_bytes = self.total_original_size_bytes
+
+    total_compressed_size_bytes = self.total_compressed_size_bytes
+
+    storage_saved_bytes = self.storage_saved_bytes
+
+    average_compression_ratio = self.average_compression_ratio
+
+    latest_backup_date: Union[None, str]
+    latest_backup_date = self.latest_backup_date
+
+    backup_formats = self.backup_formats.to_dict()
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "graph_id": graph_id,
+        "total_backups": total_backups,
+        "successful_backups": successful_backups,
+        "failed_backups": failed_backups,
+        "success_rate": success_rate,
+        "total_original_size_bytes": total_original_size_bytes,
+        "total_compressed_size_bytes": total_compressed_size_bytes,
+        "storage_saved_bytes": storage_saved_bytes,
+        "average_compression_ratio": average_compression_ratio,
+        "latest_backup_date": latest_backup_date,
+        "backup_formats": backup_formats,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.backup_stats_response_backup_formats import (
+      BackupStatsResponseBackupFormats,
+    )
+
+    d = dict(src_dict)
+    graph_id = d.pop("graph_id")
+
+    total_backups = d.pop("total_backups")
+
+    successful_backups = d.pop("successful_backups")
+
+    failed_backups = d.pop("failed_backups")
+
+    success_rate = d.pop("success_rate")
+
+    total_original_size_bytes = d.pop("total_original_size_bytes")
+
+    total_compressed_size_bytes = d.pop("total_compressed_size_bytes")
+
+    storage_saved_bytes = d.pop("storage_saved_bytes")
+
+    average_compression_ratio = d.pop("average_compression_ratio")
+
+    def _parse_latest_backup_date(data: object) -> Union[None, str]:
+      if data is None:
+        return data
+      return cast(Union[None, str], data)
+
+    latest_backup_date = _parse_latest_backup_date(d.pop("latest_backup_date"))
+
+    backup_formats = BackupStatsResponseBackupFormats.from_dict(d.pop("backup_formats"))
+
+    backup_stats_response = cls(
+      graph_id=graph_id,
+      total_backups=total_backups,
+      successful_backups=successful_backups,
+      failed_backups=failed_backups,
+      success_rate=success_rate,
+      total_original_size_bytes=total_original_size_bytes,
+      total_compressed_size_bytes=total_compressed_size_bytes,
+      storage_saved_bytes=storage_saved_bytes,
+      average_compression_ratio=average_compression_ratio,
+      latest_backup_date=latest_backup_date,
+      backup_formats=backup_formats,
+    )
+
+    backup_stats_response.additional_properties = d
+    return backup_stats_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/backup_stats_response_backup_formats.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="BackupStatsResponseBackupFormats")
+
+
+@_attrs_define
+class BackupStatsResponseBackupFormats:
+  """ """
+
+  additional_properties: dict[str, int] = _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)
+    backup_stats_response_backup_formats = cls()
+
+    backup_stats_response_backup_formats.additional_properties = d
+    return backup_stats_response_backup_formats
+
+  @property
+  def additional_keys(self) -> list[str]:
+    return list(self.additional_properties.keys())
+
+  def __getitem__(self, key: str) -> int:
+    return self.additional_properties[key]
+
+  def __setitem__(self, key: str, value: int) -> 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/cancel_operation_response_canceloperation.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="CancelOperationResponseCanceloperation")
+
+
+@_attrs_define
+class CancelOperationResponseCanceloperation:
+  """ """
+
+  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)
+    cancel_operation_response_canceloperation = cls()
+
+    cancel_operation_response_canceloperation.additional_properties = d
+    return cancel_operation_response_canceloperation
+
+  @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/cancellation_response.py

@@ -0,0 +1,76 @@
+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="CancellationResponse")
+
+
+@_attrs_define
+class CancellationResponse:
+  """Response for subscription cancellation.
+
+  Attributes:
+      message (str): Cancellation confirmation message
+      subscription_id (str): ID of the cancelled subscription
+      cancelled_at (str): Cancellation timestamp (ISO format)
+  """
+
+  message: str
+  subscription_id: str
+  cancelled_at: str
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    message = self.message
+
+    subscription_id = self.subscription_id
+
+    cancelled_at = self.cancelled_at
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "message": message,
+        "subscription_id": subscription_id,
+        "cancelled_at": cancelled_at,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    message = d.pop("message")
+
+    subscription_id = d.pop("subscription_id")
+
+    cancelled_at = d.pop("cancelled_at")
+
+    cancellation_response = cls(
+      message=message,
+      subscription_id=subscription_id,
+      cancelled_at=cancelled_at,
+    )
+
+    cancellation_response.additional_properties = d
+    return cancellation_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/check_credit_balance_response_checkcreditbalance.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="CheckCreditBalanceResponseCheckcreditbalance")
+
+
+@_attrs_define
+class CheckCreditBalanceResponseCheckcreditbalance:
+  """ """
+
+  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)
+    check_credit_balance_response_checkcreditbalance = cls()
+
+    check_credit_balance_response_checkcreditbalance.additional_properties = d
+    return check_credit_balance_response_checkcreditbalance
+
+  @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_options_response.py

@@ -0,0 +1,82 @@
+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.connection_provider_info import ConnectionProviderInfo
+
+
+T = TypeVar("T", bound="ConnectionOptionsResponse")
+
+
+@_attrs_define
+class ConnectionOptionsResponse:
+  """Response with all available connection options.
+
+  Attributes:
+      providers (list['ConnectionProviderInfo']): Available connection providers
+      total_providers (int): Total number of providers
+  """
+
+  providers: list["ConnectionProviderInfo"]
+  total_providers: int
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    providers = []
+    for providers_item_data in self.providers:
+      providers_item = providers_item_data.to_dict()
+      providers.append(providers_item)
+
+    total_providers = self.total_providers
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "providers": providers,
+        "total_providers": total_providers,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.connection_provider_info import ConnectionProviderInfo
+
+    d = dict(src_dict)
+    providers = []
+    _providers = d.pop("providers")
+    for providers_item_data in _providers:
+      providers_item = ConnectionProviderInfo.from_dict(providers_item_data)
+
+      providers.append(providers_item)
+
+    total_providers = d.pop("total_providers")
+
+    connection_options_response = cls(
+      providers=providers,
+      total_providers=total_providers,
+    )
+
+    connection_options_response.additional_properties = d
+    return connection_options_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_provider_info.py

@@ -0,0 +1,203 @@
+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 ..models.connection_provider_info_auth_type import ConnectionProviderInfoAuthType
+from ..models.connection_provider_info_provider import ConnectionProviderInfoProvider
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ConnectionProviderInfo")
+
+
+@_attrs_define
+class ConnectionProviderInfo:
+  """Information about a connection provider.
+
+  Attributes:
+      provider (ConnectionProviderInfoProvider): Provider identifier
+      display_name (str): Human-readable provider name
+      description (str): Provider description
+      auth_type (ConnectionProviderInfoAuthType): Authentication type
+      required_config (list[str]): Required configuration fields
+      features (list[str]): Supported features
+      data_types (list[str]): Types of data available
+      auth_flow (Union[None, Unset, str]): Description of authentication flow
+      optional_config (Union[Unset, list[str]]): Optional configuration fields
+      sync_frequency (Union[None, Unset, str]): Typical sync frequency
+      setup_instructions (Union[None, Unset, str]): Setup instructions
+      documentation_url (Union[None, Unset, str]): Link to documentation
+  """
+
+  provider: ConnectionProviderInfoProvider
+  display_name: str
+  description: str
+  auth_type: ConnectionProviderInfoAuthType
+  required_config: list[str]
+  features: list[str]
+  data_types: list[str]
+  auth_flow: Union[None, Unset, str] = UNSET
+  optional_config: Union[Unset, list[str]] = UNSET
+  sync_frequency: Union[None, Unset, str] = UNSET
+  setup_instructions: Union[None, Unset, str] = UNSET
+  documentation_url: Union[None, Unset, str] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    provider = self.provider.value
+
+    display_name = self.display_name
+
+    description = self.description
+
+    auth_type = self.auth_type.value
+
+    required_config = self.required_config
+
+    features = self.features
+
+    data_types = self.data_types
+
+    auth_flow: Union[None, Unset, str]
+    if isinstance(self.auth_flow, Unset):
+      auth_flow = UNSET
+    else:
+      auth_flow = self.auth_flow
+
+    optional_config: Union[Unset, list[str]] = UNSET
+    if not isinstance(self.optional_config, Unset):
+      optional_config = self.optional_config
+
+    sync_frequency: Union[None, Unset, str]
+    if isinstance(self.sync_frequency, Unset):
+      sync_frequency = UNSET
+    else:
+      sync_frequency = self.sync_frequency
+
+    setup_instructions: Union[None, Unset, str]
+    if isinstance(self.setup_instructions, Unset):
+      setup_instructions = UNSET
+    else:
+      setup_instructions = self.setup_instructions
+
+    documentation_url: Union[None, Unset, str]
+    if isinstance(self.documentation_url, Unset):
+      documentation_url = UNSET
+    else:
+      documentation_url = self.documentation_url
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "provider": provider,
+        "display_name": display_name,
+        "description": description,
+        "auth_type": auth_type,
+        "required_config": required_config,
+        "features": features,
+        "data_types": data_types,
+      }
+    )
+    if auth_flow is not UNSET:
+      field_dict["auth_flow"] = auth_flow
+    if optional_config is not UNSET:
+      field_dict["optional_config"] = optional_config
+    if sync_frequency is not UNSET:
+      field_dict["sync_frequency"] = sync_frequency
+    if setup_instructions is not UNSET:
+      field_dict["setup_instructions"] = setup_instructions
+    if documentation_url is not UNSET:
+      field_dict["documentation_url"] = documentation_url
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    provider = ConnectionProviderInfoProvider(d.pop("provider"))
+
+    display_name = d.pop("display_name")
+
+    description = d.pop("description")
+
+    auth_type = ConnectionProviderInfoAuthType(d.pop("auth_type"))
+
+    required_config = cast(list[str], d.pop("required_config"))
+
+    features = cast(list[str], d.pop("features"))
+
+    data_types = cast(list[str], d.pop("data_types"))
+
+    def _parse_auth_flow(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)
+
+    auth_flow = _parse_auth_flow(d.pop("auth_flow", UNSET))
+
+    optional_config = cast(list[str], d.pop("optional_config", UNSET))
+
+    def _parse_sync_frequency(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)
+
+    sync_frequency = _parse_sync_frequency(d.pop("sync_frequency", UNSET))
+
+    def _parse_setup_instructions(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)
+
+    setup_instructions = _parse_setup_instructions(d.pop("setup_instructions", UNSET))
+
+    def _parse_documentation_url(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)
+
+    documentation_url = _parse_documentation_url(d.pop("documentation_url", UNSET))
+
+    connection_provider_info = cls(
+      provider=provider,
+      display_name=display_name,
+      description=description,
+      auth_type=auth_type,
+      required_config=required_config,
+      features=features,
+      data_types=data_types,
+      auth_flow=auth_flow,
+      optional_config=optional_config,
+      sync_frequency=sync_frequency,
+      setup_instructions=setup_instructions,
+      documentation_url=documentation_url,
+    )
+
+    connection_provider_info.additional_properties = d
+    return connection_provider_info
+
+  @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_provider_info_auth_type.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class ConnectionProviderInfoAuthType(str, Enum):
+  API_KEY = "api_key"
+  LINK = "link"
+  NONE = "none"
+  OAUTH = "oauth"
+
+  def __str__(self) -> str:
+    return str(self.value)

robosystems_client/models/connection_provider_info_provider.py

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