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

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/query_limits.py

@@ -0,0 +1,84 @@
+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="QueryLimits")
+
+
+@_attrs_define
+class QueryLimits:
+  """Query operation limits.
+
+  Attributes:
+      max_timeout_seconds (int): Maximum query timeout in seconds
+      chunk_size (int): Maximum chunk size for result streaming
+      max_rows_per_query (int): Maximum rows returned per query
+      concurrent_queries (int): Maximum concurrent queries allowed
+  """
+
+  max_timeout_seconds: int
+  chunk_size: int
+  max_rows_per_query: int
+  concurrent_queries: int
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    max_timeout_seconds = self.max_timeout_seconds
+
+    chunk_size = self.chunk_size
+
+    max_rows_per_query = self.max_rows_per_query
+
+    concurrent_queries = self.concurrent_queries
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "max_timeout_seconds": max_timeout_seconds,
+        "chunk_size": chunk_size,
+        "max_rows_per_query": max_rows_per_query,
+        "concurrent_queries": concurrent_queries,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    max_timeout_seconds = d.pop("max_timeout_seconds")
+
+    chunk_size = d.pop("chunk_size")
+
+    max_rows_per_query = d.pop("max_rows_per_query")
+
+    concurrent_queries = d.pop("concurrent_queries")
+
+    query_limits = cls(
+      max_timeout_seconds=max_timeout_seconds,
+      chunk_size=chunk_size,
+      max_rows_per_query=max_rows_per_query,
+      concurrent_queries=concurrent_queries,
+    )
+
+    query_limits.additional_properties = d
+    return query_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/rate_limits.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="RateLimits")
+
+
+@_attrs_define
+class RateLimits:
+  """API rate limits.
+
+  Attributes:
+      requests_per_minute (int): Requests per minute limit
+      requests_per_hour (int): Requests per hour limit
+      burst_capacity (int): Burst capacity for short spikes
+  """
+
+  requests_per_minute: int
+  requests_per_hour: int
+  burst_capacity: int
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    requests_per_minute = self.requests_per_minute
+
+    requests_per_hour = self.requests_per_hour
+
+    burst_capacity = self.burst_capacity
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "requests_per_minute": requests_per_minute,
+        "requests_per_hour": requests_per_hour,
+        "burst_capacity": burst_capacity,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    requests_per_minute = d.pop("requests_per_minute")
+
+    requests_per_hour = d.pop("requests_per_hour")
+
+    burst_capacity = d.pop("burst_capacity")
+
+    rate_limits = cls(
+      requests_per_minute=requests_per_minute,
+      requests_per_hour=requests_per_hour,
+      burst_capacity=burst_capacity,
+    )
+
+    rate_limits.additional_properties = d
+    return rate_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/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

robosystems_client/models/repository_subscriptions.py

@@ -0,0 +1,90 @@
+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.repository_info import RepositoryInfo
+
+
+T = TypeVar("T", bound="RepositorySubscriptions")
+
+
+@_attrs_define
+class RepositorySubscriptions:
+  """Repository subscription offerings.
+
+  Attributes:
+      description (str): Description of repository subscriptions
+      repositories (list['RepositoryInfo']): Available repositories
+      notes (list[str]): Important notes
+  """
+
+  description: str
+  repositories: list["RepositoryInfo"]
+  notes: list[str]
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    description = self.description
+
+    repositories = []
+    for repositories_item_data in self.repositories:
+      repositories_item = repositories_item_data.to_dict()
+      repositories.append(repositories_item)
+
+    notes = self.notes
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "description": description,
+        "repositories": repositories,
+        "notes": notes,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.repository_info import RepositoryInfo
+
+    d = dict(src_dict)
+    description = d.pop("description")
+
+    repositories = []
+    _repositories = d.pop("repositories")
+    for repositories_item_data in _repositories:
+      repositories_item = RepositoryInfo.from_dict(repositories_item_data)
+
+      repositories.append(repositories_item)
+
+    notes = cast(list[str], d.pop("notes"))
+
+    repository_subscriptions = cls(
+      description=description,
+      repositories=repositories,
+      notes=notes,
+    )
+
+    repository_subscriptions.additional_properties = d
+    return repository_subscriptions
+
+  @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/service_offering_summary.py

@@ -0,0 +1,84 @@
+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="ServiceOfferingSummary")
+
+
+@_attrs_define
+class ServiceOfferingSummary:
+  """Summary of service offerings.
+
+  Attributes:
+      total_graph_tiers (int): Total number of graph tiers
+      total_repositories (int): Total number of repositories
+      enabled_repositories (int): Number of enabled repositories
+      coming_soon_repositories (int): Number of coming soon repositories
+  """
+
+  total_graph_tiers: int
+  total_repositories: int
+  enabled_repositories: int
+  coming_soon_repositories: int
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    total_graph_tiers = self.total_graph_tiers
+
+    total_repositories = self.total_repositories
+
+    enabled_repositories = self.enabled_repositories
+
+    coming_soon_repositories = self.coming_soon_repositories
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "total_graph_tiers": total_graph_tiers,
+        "total_repositories": total_repositories,
+        "enabled_repositories": enabled_repositories,
+        "coming_soon_repositories": coming_soon_repositories,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    total_graph_tiers = d.pop("total_graph_tiers")
+
+    total_repositories = d.pop("total_repositories")
+
+    enabled_repositories = d.pop("enabled_repositories")
+
+    coming_soon_repositories = d.pop("coming_soon_repositories")
+
+    service_offering_summary = cls(
+      total_graph_tiers=total_graph_tiers,
+      total_repositories=total_repositories,
+      enabled_repositories=enabled_repositories,
+      coming_soon_repositories=coming_soon_repositories,
+    )
+
+    service_offering_summary.additional_properties = d
+    return service_offering_summary
+
+  @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