robosystems-client 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

robosystems_client/models/service_offerings_response.py

@@ -0,0 +1,98 @@
+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.graph_subscriptions import GraphSubscriptions
+  from ..models.operation_costs import OperationCosts
+  from ..models.repository_subscriptions import RepositorySubscriptions
+  from ..models.service_offering_summary import ServiceOfferingSummary
+
+
+T = TypeVar("T", bound="ServiceOfferingsResponse")
+
+
+@_attrs_define
+class ServiceOfferingsResponse:
+  """Complete service offerings response.
+
+  Attributes:
+      graph_subscriptions (GraphSubscriptions): Graph subscription offerings.
+      repository_subscriptions (RepositorySubscriptions): Repository subscription offerings.
+      operation_costs (OperationCosts): Operation cost information.
+      summary (ServiceOfferingSummary): Summary of service offerings.
+  """
+
+  graph_subscriptions: "GraphSubscriptions"
+  repository_subscriptions: "RepositorySubscriptions"
+  operation_costs: "OperationCosts"
+  summary: "ServiceOfferingSummary"
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    graph_subscriptions = self.graph_subscriptions.to_dict()
+
+    repository_subscriptions = self.repository_subscriptions.to_dict()
+
+    operation_costs = self.operation_costs.to_dict()
+
+    summary = self.summary.to_dict()
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "graph_subscriptions": graph_subscriptions,
+        "repository_subscriptions": repository_subscriptions,
+        "operation_costs": operation_costs,
+        "summary": summary,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.graph_subscriptions import GraphSubscriptions
+    from ..models.operation_costs import OperationCosts
+    from ..models.repository_subscriptions import RepositorySubscriptions
+    from ..models.service_offering_summary import ServiceOfferingSummary
+
+    d = dict(src_dict)
+    graph_subscriptions = GraphSubscriptions.from_dict(d.pop("graph_subscriptions"))
+
+    repository_subscriptions = RepositorySubscriptions.from_dict(
+      d.pop("repository_subscriptions")
+    )
+
+    operation_costs = OperationCosts.from_dict(d.pop("operation_costs"))
+
+    summary = ServiceOfferingSummary.from_dict(d.pop("summary"))
+
+    service_offerings_response = cls(
+      graph_subscriptions=graph_subscriptions,
+      repository_subscriptions=repository_subscriptions,
+      operation_costs=operation_costs,
+      summary=summary,
+    )
+
+    service_offerings_response.additional_properties = d
+    return service_offerings_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/storage_info.py

@@ -0,0 +1,76 @@
+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.storage_info_included_per_tier import StorageInfoIncludedPerTier
+  from ..models.storage_info_overage_pricing import StorageInfoOveragePricing
+
+
+T = TypeVar("T", bound="StorageInfo")
+
+
+@_attrs_define
+class StorageInfo:
+  """Storage pricing information.
+
+  Attributes:
+      included_per_tier (StorageInfoIncludedPerTier): Storage included per tier in GB
+      overage_pricing (StorageInfoOveragePricing): Overage pricing per GB per tier
+  """
+
+  included_per_tier: "StorageInfoIncludedPerTier"
+  overage_pricing: "StorageInfoOveragePricing"
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    included_per_tier = self.included_per_tier.to_dict()
+
+    overage_pricing = self.overage_pricing.to_dict()
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "included_per_tier": included_per_tier,
+        "overage_pricing": overage_pricing,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.storage_info_included_per_tier import StorageInfoIncludedPerTier
+    from ..models.storage_info_overage_pricing import StorageInfoOveragePricing
+
+    d = dict(src_dict)
+    included_per_tier = StorageInfoIncludedPerTier.from_dict(d.pop("included_per_tier"))
+
+    overage_pricing = StorageInfoOveragePricing.from_dict(d.pop("overage_pricing"))
+
+    storage_info = cls(
+      included_per_tier=included_per_tier,
+      overage_pricing=overage_pricing,
+    )
+
+    storage_info.additional_properties = d
+    return storage_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/{get_backup_download_url_response_getbackupdownloadurl.py → storage_info_included_per_tier.py}

@@ -4,14 +4,14 @@ from typing import Any, TypeVar
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="GetBackupDownloadUrlResponseGetbackupdownloadurl")
+T = TypeVar("T", bound="StorageInfoIncludedPerTier")
 
 
 @_attrs_define
-class GetBackupDownloadUrlResponseGetbackupdownloadurl:
-  """ """
+class StorageInfoIncludedPerTier:
+  """Storage included per tier in GB"""
 
-  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+  additional_properties: dict[str, int] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
     field_dict: dict[str, Any] = {}
@@ -22,19 +22,19 @@ class GetBackupDownloadUrlResponseGetbackupdownloadurl:
   @classmethod
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
     d = dict(src_dict)
-    get_backup_download_url_response_getbackupdownloadurl = cls()
+    storage_info_included_per_tier = cls()
 
-    get_backup_download_url_response_getbackupdownloadurl.additional_properties = d
-    return get_backup_download_url_response_getbackupdownloadurl
+    storage_info_included_per_tier.additional_properties = d
+    return storage_info_included_per_tier
 
   @property
   def additional_keys(self) -> list[str]:
     return list(self.additional_properties.keys())
 
-  def __getitem__(self, key: str) -> Any:
+  def __getitem__(self, key: str) -> int:
     return self.additional_properties[key]
 
-  def __setitem__(self, key: str, value: Any) -> None:
+  def __setitem__(self, key: str, value: int) -> None:
     self.additional_properties[key] = value
 
   def __delitem__(self, key: str) -> None:

robosystems_client/models/storage_info_overage_pricing.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="StorageInfoOveragePricing")
+
+
+@_attrs_define
+class StorageInfoOveragePricing:
+  """Overage pricing per GB per tier"""
+
+  additional_properties: dict[str, float] = _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)
+    storage_info_overage_pricing = cls()
+
+    storage_info_overage_pricing.additional_properties = d
+    return storage_info_overage_pricing
+
+  @property
+  def additional_keys(self) -> list[str]:
+    return list(self.additional_properties.keys())
+
+  def __getitem__(self, key: str) -> float:
+    return self.additional_properties[key]
+
+  def __setitem__(self, key: str, value: float) -> 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/storage_limits.py

@@ -0,0 +1,90 @@
+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="StorageLimits")
+
+
+@_attrs_define
+class StorageLimits:
+  """Storage limits information.
+
+  Attributes:
+      max_storage_gb (float): Maximum storage limit in GB
+      approaching_limit (bool): Whether approaching storage limit (>80%)
+      current_usage_gb (Union[None, Unset, float]): Current storage usage in GB
+  """
+
+  max_storage_gb: float
+  approaching_limit: bool
+  current_usage_gb: Union[None, Unset, float] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    max_storage_gb = self.max_storage_gb
+
+    approaching_limit = self.approaching_limit
+
+    current_usage_gb: Union[None, Unset, float]
+    if isinstance(self.current_usage_gb, Unset):
+      current_usage_gb = UNSET
+    else:
+      current_usage_gb = self.current_usage_gb
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "max_storage_gb": max_storage_gb,
+        "approaching_limit": approaching_limit,
+      }
+    )
+    if current_usage_gb is not UNSET:
+      field_dict["current_usage_gb"] = current_usage_gb
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    max_storage_gb = d.pop("max_storage_gb")
+
+    approaching_limit = d.pop("approaching_limit")
+
+    def _parse_current_usage_gb(data: object) -> Union[None, Unset, float]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, float], data)
+
+    current_usage_gb = _parse_current_usage_gb(d.pop("current_usage_gb", UNSET))
+
+    storage_limits = cls(
+      max_storage_gb=max_storage_gb,
+      approaching_limit=approaching_limit,
+      current_usage_gb=current_usage_gb,
+    )
+
+    storage_limits.additional_properties = d
+    return storage_limits
+
+  @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/token_pricing.py

@@ -0,0 +1,68 @@
+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="TokenPricing")
+
+
+@_attrs_define
+class TokenPricing:
+  """AI token pricing for a specific model.
+
+  Attributes:
+      input_per_1k_tokens (int): Credits per 1K input tokens
+      output_per_1k_tokens (int): Credits per 1K output tokens
+  """
+
+  input_per_1k_tokens: int
+  output_per_1k_tokens: int
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    input_per_1k_tokens = self.input_per_1k_tokens
+
+    output_per_1k_tokens = self.output_per_1k_tokens
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "input_per_1k_tokens": input_per_1k_tokens,
+        "output_per_1k_tokens": output_per_1k_tokens,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    input_per_1k_tokens = d.pop("input_per_1k_tokens")
+
+    output_per_1k_tokens = d.pop("output_per_1k_tokens")
+
+    token_pricing = cls(
+      input_per_1k_tokens=input_per_1k_tokens,
+      output_per_1k_tokens=output_per_1k_tokens,
+    )
+
+    token_pricing.additional_properties = d
+    return token_pricing
+
+  @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-0.2.5.dist-info → robosystems_client-0.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robosystems-client
-Version: 0.2.5
+Version: 0.2.7
 Summary: Python Client for RoboSystems financial graph database API
 Author: RFS LLC
 License: MIT