robosystems-client 0.1.9__py3-none-any.whl

robosystems_client/models/subscription_info.py

@@ -0,0 +1,180 @@
+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 ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+  from ..models.subscription_info_metadata import SubscriptionInfoMetadata
+
+
+T = TypeVar("T", bound="SubscriptionInfo")
+
+
+@_attrs_define
+class SubscriptionInfo:
+  """User subscription information.
+
+  Attributes:
+      id (str): Subscription ID
+      user_id (str): User ID
+      addon_type (str): Add-on type
+      addon_tier (str): Subscription tier
+      is_active (bool): Whether subscription is active
+      is_trial (bool): Whether this is a trial subscription
+      activated_at (str): Activation date (ISO format)
+      monthly_price_cents (int): Monthly price in cents
+      features (list[str]): List of features
+      metadata (SubscriptionInfoMetadata): Additional metadata
+      trial_ends_at (Union[None, Unset, str]): Trial expiration date (ISO format)
+      expires_at (Union[None, Unset, str]): Expiration date (ISO format)
+  """
+
+  id: str
+  user_id: str
+  addon_type: str
+  addon_tier: str
+  is_active: bool
+  is_trial: bool
+  activated_at: str
+  monthly_price_cents: int
+  features: list[str]
+  metadata: "SubscriptionInfoMetadata"
+  trial_ends_at: Union[None, Unset, str] = UNSET
+  expires_at: Union[None, Unset, str] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    id = self.id
+
+    user_id = self.user_id
+
+    addon_type = self.addon_type
+
+    addon_tier = self.addon_tier
+
+    is_active = self.is_active
+
+    is_trial = self.is_trial
+
+    activated_at = self.activated_at
+
+    monthly_price_cents = self.monthly_price_cents
+
+    features = self.features
+
+    metadata = self.metadata.to_dict()
+
+    trial_ends_at: Union[None, Unset, str]
+    if isinstance(self.trial_ends_at, Unset):
+      trial_ends_at = UNSET
+    else:
+      trial_ends_at = self.trial_ends_at
+
+    expires_at: Union[None, Unset, str]
+    if isinstance(self.expires_at, Unset):
+      expires_at = UNSET
+    else:
+      expires_at = self.expires_at
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "id": id,
+        "user_id": user_id,
+        "addon_type": addon_type,
+        "addon_tier": addon_tier,
+        "is_active": is_active,
+        "is_trial": is_trial,
+        "activated_at": activated_at,
+        "monthly_price_cents": monthly_price_cents,
+        "features": features,
+        "metadata": metadata,
+      }
+    )
+    if trial_ends_at is not UNSET:
+      field_dict["trial_ends_at"] = trial_ends_at
+    if expires_at is not UNSET:
+      field_dict["expires_at"] = expires_at
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.subscription_info_metadata import SubscriptionInfoMetadata
+
+    d = dict(src_dict)
+    id = d.pop("id")
+
+    user_id = d.pop("user_id")
+
+    addon_type = d.pop("addon_type")
+
+    addon_tier = d.pop("addon_tier")
+
+    is_active = d.pop("is_active")
+
+    is_trial = d.pop("is_trial")
+
+    activated_at = d.pop("activated_at")
+
+    monthly_price_cents = d.pop("monthly_price_cents")
+
+    features = cast(list[str], d.pop("features"))
+
+    metadata = SubscriptionInfoMetadata.from_dict(d.pop("metadata"))
+
+    def _parse_trial_ends_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)
+
+    trial_ends_at = _parse_trial_ends_at(d.pop("trial_ends_at", UNSET))
+
+    def _parse_expires_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)
+
+    expires_at = _parse_expires_at(d.pop("expires_at", UNSET))
+
+    subscription_info = cls(
+      id=id,
+      user_id=user_id,
+      addon_type=addon_type,
+      addon_tier=addon_tier,
+      is_active=is_active,
+      is_trial=is_trial,
+      activated_at=activated_at,
+      monthly_price_cents=monthly_price_cents,
+      features=features,
+      metadata=metadata,
+      trial_ends_at=trial_ends_at,
+      expires_at=expires_at,
+    )
+
+    subscription_info.additional_properties = d
+    return subscription_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/subscription_info_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="SubscriptionInfoMetadata")
+
+
+@_attrs_define
+class SubscriptionInfoMetadata:
+  """Additional 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)
+    subscription_info_metadata = cls()
+
+    subscription_info_metadata.additional_properties = d
+    return subscription_info_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/subscription_request.py

@@ -0,0 +1,89 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.repository_plan import RepositoryPlan
+from ..models.repository_type import RepositoryType
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="SubscriptionRequest")
+
+
+@_attrs_define
+class SubscriptionRequest:
+  """Request to create a new subscription.
+
+  Attributes:
+      repository_type (RepositoryType): Types of shared repositories.
+      repository_plan (Union[Unset, RepositoryPlan]): Repository access plans for shared data.
+      is_trial (Union[Unset, bool]): Start with trial period Default: False.
+  """
+
+  repository_type: RepositoryType
+  repository_plan: Union[Unset, RepositoryPlan] = UNSET
+  is_trial: Union[Unset, bool] = False
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    repository_type = self.repository_type.value
+
+    repository_plan: Union[Unset, str] = UNSET
+    if not isinstance(self.repository_plan, Unset):
+      repository_plan = self.repository_plan.value
+
+    is_trial = self.is_trial
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "repository_type": repository_type,
+      }
+    )
+    if repository_plan is not UNSET:
+      field_dict["repository_plan"] = repository_plan
+    if is_trial is not UNSET:
+      field_dict["is_trial"] = is_trial
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    repository_type = RepositoryType(d.pop("repository_type"))
+
+    _repository_plan = d.pop("repository_plan", UNSET)
+    repository_plan: Union[Unset, RepositoryPlan]
+    if isinstance(_repository_plan, Unset):
+      repository_plan = UNSET
+    else:
+      repository_plan = RepositoryPlan(_repository_plan)
+
+    is_trial = d.pop("is_trial", UNSET)
+
+    subscription_request = cls(
+      repository_type=repository_type,
+      repository_plan=repository_plan,
+      is_trial=is_trial,
+    )
+
+    subscription_request.additional_properties = d
+    return subscription_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/subscription_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.subscription_info import SubscriptionInfo
+
+
+T = TypeVar("T", bound="SubscriptionResponse")
+
+
+@_attrs_define
+class SubscriptionResponse:
+  """Response for subscription creation.
+
+  Attributes:
+      message (str): Success message
+      subscription (SubscriptionInfo): User subscription information.
+      trial_period (int): Trial period in days
+  """
+
+  message: str
+  subscription: "SubscriptionInfo"
+  trial_period: int
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    message = self.message
+
+    subscription = self.subscription.to_dict()
+
+    trial_period = self.trial_period
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "message": message,
+        "subscription": subscription,
+        "trial_period": trial_period,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.subscription_info import SubscriptionInfo
+
+    d = dict(src_dict)
+    message = d.pop("message")
+
+    subscription = SubscriptionInfo.from_dict(d.pop("subscription"))
+
+    trial_period = d.pop("trial_period")
+
+    subscription_response = cls(
+      message=message,
+      subscription=subscription,
+      trial_period=trial_period,
+    )
+
+    subscription_response.additional_properties = d
+    return subscription_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/success_response.py

@@ -0,0 +1,112 @@
+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 ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+  from ..models.success_response_data_type_0 import SuccessResponseDataType0
+
+
+T = TypeVar("T", bound="SuccessResponse")
+
+
+@_attrs_define
+class SuccessResponse:
+  """Standard success response for operations without specific return data.
+
+  Example:
+      {'data': {'deleted_count': 1}, 'message': 'Resource deleted successfully', 'success': True}
+
+  Attributes:
+      message (str): Human-readable success message Example: Operation completed successfully.
+      success (Union[Unset, bool]): Indicates the operation completed successfully Default: True.
+      data (Union['SuccessResponseDataType0', None, Unset]): Optional additional data related to the operation
+  """
+
+  message: str
+  success: Union[Unset, bool] = True
+  data: Union["SuccessResponseDataType0", None, Unset] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    from ..models.success_response_data_type_0 import SuccessResponseDataType0
+
+    message = self.message
+
+    success = self.success
+
+    data: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.data, Unset):
+      data = UNSET
+    elif isinstance(self.data, SuccessResponseDataType0):
+      data = self.data.to_dict()
+    else:
+      data = self.data
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "message": message,
+      }
+    )
+    if success is not UNSET:
+      field_dict["success"] = success
+    if data is not UNSET:
+      field_dict["data"] = data
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.success_response_data_type_0 import SuccessResponseDataType0
+
+    d = dict(src_dict)
+    message = d.pop("message")
+
+    success = d.pop("success", UNSET)
+
+    def _parse_data(data: object) -> Union["SuccessResponseDataType0", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        data_type_0 = SuccessResponseDataType0.from_dict(data)
+
+        return data_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["SuccessResponseDataType0", None, Unset], data)
+
+    data = _parse_data(d.pop("data", UNSET))
+
+    success_response = cls(
+      message=message,
+      success=success,
+      data=data,
+    )
+
+    success_response.additional_properties = d
+    return success_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/success_response_data_type_0.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="SuccessResponseDataType0")
+
+
+@_attrs_define
+class SuccessResponseDataType0:
+  """ """
+
+  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)
+    success_response_data_type_0 = cls()
+
+    success_response_data_type_0.additional_properties = d
+    return success_response_data_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

robosystems_client/models/sync_connection_request.py

@@ -0,0 +1,106 @@
+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 ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+  from ..models.sync_connection_request_sync_options_type_0 import (
+    SyncConnectionRequestSyncOptionsType0,
+  )
+
+
+T = TypeVar("T", bound="SyncConnectionRequest")
+
+
+@_attrs_define
+class SyncConnectionRequest:
+  """Request to sync a connection.
+
+  Attributes:
+      full_sync (Union[Unset, bool]): Perform full sync vs incremental Default: False.
+      sync_options (Union['SyncConnectionRequestSyncOptionsType0', None, Unset]): Provider-specific sync options
+  """
+
+  full_sync: Union[Unset, bool] = False
+  sync_options: Union["SyncConnectionRequestSyncOptionsType0", None, Unset] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    from ..models.sync_connection_request_sync_options_type_0 import (
+      SyncConnectionRequestSyncOptionsType0,
+    )
+
+    full_sync = self.full_sync
+
+    sync_options: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.sync_options, Unset):
+      sync_options = UNSET
+    elif isinstance(self.sync_options, SyncConnectionRequestSyncOptionsType0):
+      sync_options = self.sync_options.to_dict()
+    else:
+      sync_options = self.sync_options
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update({})
+    if full_sync is not UNSET:
+      field_dict["full_sync"] = full_sync
+    if sync_options is not UNSET:
+      field_dict["sync_options"] = sync_options
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.sync_connection_request_sync_options_type_0 import (
+      SyncConnectionRequestSyncOptionsType0,
+    )
+
+    d = dict(src_dict)
+    full_sync = d.pop("full_sync", UNSET)
+
+    def _parse_sync_options(
+      data: object,
+    ) -> Union["SyncConnectionRequestSyncOptionsType0", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        sync_options_type_0 = SyncConnectionRequestSyncOptionsType0.from_dict(data)
+
+        return sync_options_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["SyncConnectionRequestSyncOptionsType0", None, Unset], data)
+
+    sync_options = _parse_sync_options(d.pop("sync_options", UNSET))
+
+    sync_connection_request = cls(
+      full_sync=full_sync,
+      sync_options=sync_options,
+    )
+
+    sync_connection_request.additional_properties = d
+    return sync_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/sync_connection_request_sync_options_type_0.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="SyncConnectionRequestSyncOptionsType0")
+
+
+@_attrs_define
+class SyncConnectionRequestSyncOptionsType0:
+  """ """
+
+  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)
+    sync_connection_request_sync_options_type_0 = cls()
+
+    sync_connection_request_sync_options_type_0.additional_properties = d
+    return sync_connection_request_sync_options_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