robosystems-client 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

robosystems_client/models/graph_tier_instance.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="GraphTierInstance")
+
+
+@_attrs_define
+class GraphTierInstance:
+  """Instance specifications for a tier.
+
+  Attributes:
+      type_ (str): Instance type identifier
+      memory_mb (int): Memory in megabytes
+      databases_per_instance (int): Databases per instance
+  """
+
+  type_: str
+  memory_mb: int
+  databases_per_instance: int
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    type_ = self.type_
+
+    memory_mb = self.memory_mb
+
+    databases_per_instance = self.databases_per_instance
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "type": type_,
+        "memory_mb": memory_mb,
+        "databases_per_instance": databases_per_instance,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    type_ = d.pop("type")
+
+    memory_mb = d.pop("memory_mb")
+
+    databases_per_instance = d.pop("databases_per_instance")
+
+    graph_tier_instance = cls(
+      type_=type_,
+      memory_mb=memory_mb,
+      databases_per_instance=databases_per_instance,
+    )
+
+    graph_tier_instance.additional_properties = d
+    return graph_tier_instance
+
+  @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/graph_tier_limits.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
+
+if TYPE_CHECKING:
+  from ..models.graph_tier_backup import GraphTierBackup
+  from ..models.graph_tier_copy_operations import GraphTierCopyOperations
+
+
+T = TypeVar("T", bound="GraphTierLimits")
+
+
+@_attrs_define
+class GraphTierLimits:
+  """Resource limits for a tier.
+
+  Attributes:
+      storage_gb (int): Storage limit in GB
+      monthly_credits (int): Monthly credit allocation
+      max_subgraphs (Union[None, int]): Maximum subgraphs (null for unlimited)
+      copy_operations (GraphTierCopyOperations): Copy operation limits for a tier.
+      backup (GraphTierBackup): Backup configuration for a tier.
+  """
+
+  storage_gb: int
+  monthly_credits: int
+  max_subgraphs: Union[None, int]
+  copy_operations: "GraphTierCopyOperations"
+  backup: "GraphTierBackup"
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    storage_gb = self.storage_gb
+
+    monthly_credits = self.monthly_credits
+
+    max_subgraphs: Union[None, int]
+    max_subgraphs = self.max_subgraphs
+
+    copy_operations = self.copy_operations.to_dict()
+
+    backup = self.backup.to_dict()
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "storage_gb": storage_gb,
+        "monthly_credits": monthly_credits,
+        "max_subgraphs": max_subgraphs,
+        "copy_operations": copy_operations,
+        "backup": backup,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.graph_tier_backup import GraphTierBackup
+    from ..models.graph_tier_copy_operations import GraphTierCopyOperations
+
+    d = dict(src_dict)
+    storage_gb = d.pop("storage_gb")
+
+    monthly_credits = d.pop("monthly_credits")
+
+    def _parse_max_subgraphs(data: object) -> Union[None, int]:
+      if data is None:
+        return data
+      return cast(Union[None, int], data)
+
+    max_subgraphs = _parse_max_subgraphs(d.pop("max_subgraphs"))
+
+    copy_operations = GraphTierCopyOperations.from_dict(d.pop("copy_operations"))
+
+    backup = GraphTierBackup.from_dict(d.pop("backup"))
+
+    graph_tier_limits = cls(
+      storage_gb=storage_gb,
+      monthly_credits=monthly_credits,
+      max_subgraphs=max_subgraphs,
+      copy_operations=copy_operations,
+      backup=backup,
+    )
+
+    graph_tier_limits.additional_properties = d
+    return graph_tier_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/offering_repository_plan.py

@@ -0,0 +1,148 @@
+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.offering_repository_plan_rate_limits_type_0 import (
+    OfferingRepositoryPlanRateLimitsType0,
+  )
+
+
+T = TypeVar("T", bound="OfferingRepositoryPlan")
+
+
+@_attrs_define
+class OfferingRepositoryPlan:
+  """Information about a repository plan.
+
+  Attributes:
+      plan (str): Plan identifier
+      name (str): Plan name
+      monthly_price (float): Monthly price in USD
+      monthly_credits (int): Monthly credit allocation
+      access_level (str): Access level
+      features (list[str]): List of features
+      rate_limits (Union['OfferingRepositoryPlanRateLimitsType0', None, Unset]): Rate limits for this plan
+  """
+
+  plan: str
+  name: str
+  monthly_price: float
+  monthly_credits: int
+  access_level: str
+  features: list[str]
+  rate_limits: Union["OfferingRepositoryPlanRateLimitsType0", None, Unset] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    from ..models.offering_repository_plan_rate_limits_type_0 import (
+      OfferingRepositoryPlanRateLimitsType0,
+    )
+
+    plan = self.plan
+
+    name = self.name
+
+    monthly_price = self.monthly_price
+
+    monthly_credits = self.monthly_credits
+
+    access_level = self.access_level
+
+    features = self.features
+
+    rate_limits: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.rate_limits, Unset):
+      rate_limits = UNSET
+    elif isinstance(self.rate_limits, OfferingRepositoryPlanRateLimitsType0):
+      rate_limits = self.rate_limits.to_dict()
+    else:
+      rate_limits = self.rate_limits
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "plan": plan,
+        "name": name,
+        "monthly_price": monthly_price,
+        "monthly_credits": monthly_credits,
+        "access_level": access_level,
+        "features": features,
+      }
+    )
+    if rate_limits is not UNSET:
+      field_dict["rate_limits"] = rate_limits
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.offering_repository_plan_rate_limits_type_0 import (
+      OfferingRepositoryPlanRateLimitsType0,
+    )
+
+    d = dict(src_dict)
+    plan = d.pop("plan")
+
+    name = d.pop("name")
+
+    monthly_price = d.pop("monthly_price")
+
+    monthly_credits = d.pop("monthly_credits")
+
+    access_level = d.pop("access_level")
+
+    features = cast(list[str], d.pop("features"))
+
+    def _parse_rate_limits(
+      data: object,
+    ) -> Union["OfferingRepositoryPlanRateLimitsType0", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        rate_limits_type_0 = OfferingRepositoryPlanRateLimitsType0.from_dict(data)
+
+        return rate_limits_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["OfferingRepositoryPlanRateLimitsType0", None, Unset], data)
+
+    rate_limits = _parse_rate_limits(d.pop("rate_limits", UNSET))
+
+    offering_repository_plan = cls(
+      plan=plan,
+      name=name,
+      monthly_price=monthly_price,
+      monthly_credits=monthly_credits,
+      access_level=access_level,
+      features=features,
+      rate_limits=rate_limits,
+    )
+
+    offering_repository_plan.additional_properties = d
+    return offering_repository_plan
+
+  @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/offering_repository_plan_rate_limits_type_0.py

@@ -0,0 +1,61 @@
+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
+
+T = TypeVar("T", bound="OfferingRepositoryPlanRateLimitsType0")
+
+
+@_attrs_define
+class OfferingRepositoryPlanRateLimitsType0:
+  """ """
+
+  additional_properties: dict[str, Union[None, int]] = _attrs_field(
+    init=False, factory=dict
+  )
+
+  def to_dict(self) -> dict[str, Any]:
+    field_dict: dict[str, Any] = {}
+    for prop_name, prop in self.additional_properties.items():
+      field_dict[prop_name] = prop
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    offering_repository_plan_rate_limits_type_0 = cls()
+
+    additional_properties = {}
+    for prop_name, prop_dict in d.items():
+
+      def _parse_additional_property(data: object) -> Union[None, int]:
+        if data is None:
+          return data
+        return cast(Union[None, int], data)
+
+      additional_property = _parse_additional_property(prop_dict)
+
+      additional_properties[prop_name] = additional_property
+
+    offering_repository_plan_rate_limits_type_0.additional_properties = (
+      additional_properties
+    )
+    return offering_repository_plan_rate_limits_type_0
+
+  @property
+  def additional_keys(self) -> list[str]:
+    return list(self.additional_properties.keys())
+
+  def __getitem__(self, key: str) -> Union[None, int]:
+    return self.additional_properties[key]
+
+  def __setitem__(self, key: str, value: Union[None, 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/operation_costs.py

@@ -0,0 +1,100 @@
+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
+
+if TYPE_CHECKING:
+  from ..models.operation_costs_ai_operations import OperationCostsAiOperations
+  from ..models.operation_costs_token_pricing import OperationCostsTokenPricing
+
+
+T = TypeVar("T", bound="OperationCosts")
+
+
+@_attrs_define
+class OperationCosts:
+  """Operation cost information.
+
+  Attributes:
+      description (str): Description of operation costs
+      ai_operations (OperationCostsAiOperations): Base costs for AI operations
+      token_pricing (OperationCostsTokenPricing): Token pricing by model
+      included_operations (list[str]): Operations that don't consume credits
+      notes (list[str]): Important notes about costs
+  """
+
+  description: str
+  ai_operations: "OperationCostsAiOperations"
+  token_pricing: "OperationCostsTokenPricing"
+  included_operations: list[str]
+  notes: list[str]
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    description = self.description
+
+    ai_operations = self.ai_operations.to_dict()
+
+    token_pricing = self.token_pricing.to_dict()
+
+    included_operations = self.included_operations
+
+    notes = self.notes
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "description": description,
+        "ai_operations": ai_operations,
+        "token_pricing": token_pricing,
+        "included_operations": included_operations,
+        "notes": notes,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.operation_costs_ai_operations import OperationCostsAiOperations
+    from ..models.operation_costs_token_pricing import OperationCostsTokenPricing
+
+    d = dict(src_dict)
+    description = d.pop("description")
+
+    ai_operations = OperationCostsAiOperations.from_dict(d.pop("ai_operations"))
+
+    token_pricing = OperationCostsTokenPricing.from_dict(d.pop("token_pricing"))
+
+    included_operations = cast(list[str], d.pop("included_operations"))
+
+    notes = cast(list[str], d.pop("notes"))
+
+    operation_costs = cls(
+      description=description,
+      ai_operations=ai_operations,
+      token_pricing=token_pricing,
+      included_operations=included_operations,
+      notes=notes,
+    )
+
+    operation_costs.additional_properties = d
+    return operation_costs
+
+  @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/operation_costs_ai_operations.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="OperationCostsAiOperations")
+
+
+@_attrs_define
+class OperationCostsAiOperations:
+  """Base costs for AI operations"""
+
+  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)
+    operation_costs_ai_operations = cls()
+
+    operation_costs_ai_operations.additional_properties = d
+    return operation_costs_ai_operations
+
+  @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/operation_costs_token_pricing.py

@@ -0,0 +1,59 @@
+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.token_pricing import TokenPricing
+
+
+T = TypeVar("T", bound="OperationCostsTokenPricing")
+
+
+@_attrs_define
+class OperationCostsTokenPricing:
+  """Token pricing by model"""
+
+  additional_properties: dict[str, "TokenPricing"] = _attrs_field(
+    init=False, factory=dict
+  )
+
+  def to_dict(self) -> dict[str, Any]:
+    field_dict: dict[str, Any] = {}
+    for prop_name, prop in self.additional_properties.items():
+      field_dict[prop_name] = prop.to_dict()
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.token_pricing import TokenPricing
+
+    d = dict(src_dict)
+    operation_costs_token_pricing = cls()
+
+    additional_properties = {}
+    for prop_name, prop_dict in d.items():
+      additional_property = TokenPricing.from_dict(prop_dict)
+
+      additional_properties[prop_name] = additional_property
+
+    operation_costs_token_pricing.additional_properties = additional_properties
+    return operation_costs_token_pricing
+
+  @property
+  def additional_keys(self) -> list[str]:
+    return list(self.additional_properties.keys())
+
+  def __getitem__(self, key: str) -> "TokenPricing":
+    return self.additional_properties[key]
+
+  def __setitem__(self, key: str, value: "TokenPricing") -> 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/repository_info.py

@@ -0,0 +1,114 @@
+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.offering_repository_plan import OfferingRepositoryPlan
+
+
+T = TypeVar("T", bound="RepositoryInfo")
+
+
+@_attrs_define
+class RepositoryInfo:
+  """Information about a shared repository.
+
+  Attributes:
+      type_ (str): Repository type identifier
+      name (str): Repository name
+      description (str): Repository description
+      enabled (bool): Whether repository is enabled
+      coming_soon (bool): Whether repository is coming soon
+      plans (list['OfferingRepositoryPlan']): Available plans
+  """
+
+  type_: str
+  name: str
+  description: str
+  enabled: bool
+  coming_soon: bool
+  plans: list["OfferingRepositoryPlan"]
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    type_ = self.type_
+
+    name = self.name
+
+    description = self.description
+
+    enabled = self.enabled
+
+    coming_soon = self.coming_soon
+
+    plans = []
+    for plans_item_data in self.plans:
+      plans_item = plans_item_data.to_dict()
+      plans.append(plans_item)
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "type": type_,
+        "name": name,
+        "description": description,
+        "enabled": enabled,
+        "coming_soon": coming_soon,
+        "plans": plans,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.offering_repository_plan import OfferingRepositoryPlan
+
+    d = dict(src_dict)
+    type_ = d.pop("type")
+
+    name = d.pop("name")
+
+    description = d.pop("description")
+
+    enabled = d.pop("enabled")
+
+    coming_soon = d.pop("coming_soon")
+
+    plans = []
+    _plans = d.pop("plans")
+    for plans_item_data in _plans:
+      plans_item = OfferingRepositoryPlan.from_dict(plans_item_data)
+
+      plans.append(plans_item)
+
+    repository_info = cls(
+      type_=type_,
+      name=name,
+      description=description,
+      enabled=enabled,
+      coming_soon=coming_soon,
+      plans=plans,
+    )
+
+    repository_info.additional_properties = d
+    return repository_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