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

robosystems_client/models/graph_subscription_tier.py

@@ -0,0 +1,220 @@
+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="GraphSubscriptionTier")
+
+
+@_attrs_define
+class GraphSubscriptionTier:
+  """Information about a graph subscription tier.
+
+  Attributes:
+      name (str): Tier name
+      display_name (str): Display name for UI
+      description (str): Tier description
+      monthly_price (float): Monthly price in USD
+      monthly_credits (int): Monthly AI credits
+      storage_included_gb (int): Storage included in GB
+      storage_overage_per_gb (float): Overage cost per GB per month
+      allowed_graph_tiers (list[str]): Allowed graph tier identifiers
+      features (list[str]): List of features
+      backup_retention_days (int): Backup retention in days
+      priority_support (bool): Whether priority support is included
+      api_rate_multiplier (float): API rate multiplier
+      backend (str): Database backend (kuzu or neo4j)
+      max_queries_per_hour (Union[None, Unset, int]): Maximum queries per hour
+      max_subgraphs (Union[None, Unset, int]): Maximum subgraphs
+      instance_type (Union[None, Unset, str]): Instance type
+  """
+
+  name: str
+  display_name: str
+  description: str
+  monthly_price: float
+  monthly_credits: int
+  storage_included_gb: int
+  storage_overage_per_gb: float
+  allowed_graph_tiers: list[str]
+  features: list[str]
+  backup_retention_days: int
+  priority_support: bool
+  api_rate_multiplier: float
+  backend: str
+  max_queries_per_hour: Union[None, Unset, int] = UNSET
+  max_subgraphs: Union[None, Unset, int] = UNSET
+  instance_type: Union[None, Unset, str] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    name = self.name
+
+    display_name = self.display_name
+
+    description = self.description
+
+    monthly_price = self.monthly_price
+
+    monthly_credits = self.monthly_credits
+
+    storage_included_gb = self.storage_included_gb
+
+    storage_overage_per_gb = self.storage_overage_per_gb
+
+    allowed_graph_tiers = self.allowed_graph_tiers
+
+    features = self.features
+
+    backup_retention_days = self.backup_retention_days
+
+    priority_support = self.priority_support
+
+    api_rate_multiplier = self.api_rate_multiplier
+
+    backend = self.backend
+
+    max_queries_per_hour: Union[None, Unset, int]
+    if isinstance(self.max_queries_per_hour, Unset):
+      max_queries_per_hour = UNSET
+    else:
+      max_queries_per_hour = self.max_queries_per_hour
+
+    max_subgraphs: Union[None, Unset, int]
+    if isinstance(self.max_subgraphs, Unset):
+      max_subgraphs = UNSET
+    else:
+      max_subgraphs = self.max_subgraphs
+
+    instance_type: Union[None, Unset, str]
+    if isinstance(self.instance_type, Unset):
+      instance_type = UNSET
+    else:
+      instance_type = self.instance_type
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "name": name,
+        "display_name": display_name,
+        "description": description,
+        "monthly_price": monthly_price,
+        "monthly_credits": monthly_credits,
+        "storage_included_gb": storage_included_gb,
+        "storage_overage_per_gb": storage_overage_per_gb,
+        "allowed_graph_tiers": allowed_graph_tiers,
+        "features": features,
+        "backup_retention_days": backup_retention_days,
+        "priority_support": priority_support,
+        "api_rate_multiplier": api_rate_multiplier,
+        "backend": backend,
+      }
+    )
+    if max_queries_per_hour is not UNSET:
+      field_dict["max_queries_per_hour"] = max_queries_per_hour
+    if max_subgraphs is not UNSET:
+      field_dict["max_subgraphs"] = max_subgraphs
+    if instance_type is not UNSET:
+      field_dict["instance_type"] = instance_type
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    name = d.pop("name")
+
+    display_name = d.pop("display_name")
+
+    description = d.pop("description")
+
+    monthly_price = d.pop("monthly_price")
+
+    monthly_credits = d.pop("monthly_credits")
+
+    storage_included_gb = d.pop("storage_included_gb")
+
+    storage_overage_per_gb = d.pop("storage_overage_per_gb")
+
+    allowed_graph_tiers = cast(list[str], d.pop("allowed_graph_tiers"))
+
+    features = cast(list[str], d.pop("features"))
+
+    backup_retention_days = d.pop("backup_retention_days")
+
+    priority_support = d.pop("priority_support")
+
+    api_rate_multiplier = d.pop("api_rate_multiplier")
+
+    backend = d.pop("backend")
+
+    def _parse_max_queries_per_hour(data: object) -> Union[None, Unset, int]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, int], data)
+
+    max_queries_per_hour = _parse_max_queries_per_hour(
+      d.pop("max_queries_per_hour", UNSET)
+    )
+
+    def _parse_max_subgraphs(data: object) -> Union[None, Unset, int]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, int], data)
+
+    max_subgraphs = _parse_max_subgraphs(d.pop("max_subgraphs", UNSET))
+
+    def _parse_instance_type(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)
+
+    instance_type = _parse_instance_type(d.pop("instance_type", UNSET))
+
+    graph_subscription_tier = cls(
+      name=name,
+      display_name=display_name,
+      description=description,
+      monthly_price=monthly_price,
+      monthly_credits=monthly_credits,
+      storage_included_gb=storage_included_gb,
+      storage_overage_per_gb=storage_overage_per_gb,
+      allowed_graph_tiers=allowed_graph_tiers,
+      features=features,
+      backup_retention_days=backup_retention_days,
+      priority_support=priority_support,
+      api_rate_multiplier=api_rate_multiplier,
+      backend=backend,
+      max_queries_per_hour=max_queries_per_hour,
+      max_subgraphs=max_subgraphs,
+      instance_type=instance_type,
+    )
+
+    graph_subscription_tier.additional_properties = d
+    return graph_subscription_tier
+
+  @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_subscriptions.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.graph_subscription_tier import GraphSubscriptionTier
+  from ..models.storage_info import StorageInfo
+
+
+T = TypeVar("T", bound="GraphSubscriptions")
+
+
+@_attrs_define
+class GraphSubscriptions:
+  """Graph subscription offerings.
+
+  Attributes:
+      description (str): Description of graph subscriptions
+      tiers (list['GraphSubscriptionTier']): Available tiers
+      storage (StorageInfo): Storage pricing information.
+      notes (list[str]): Important notes
+  """
+
+  description: str
+  tiers: list["GraphSubscriptionTier"]
+  storage: "StorageInfo"
+  notes: list[str]
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    description = self.description
+
+    tiers = []
+    for tiers_item_data in self.tiers:
+      tiers_item = tiers_item_data.to_dict()
+      tiers.append(tiers_item)
+
+    storage = self.storage.to_dict()
+
+    notes = self.notes
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "description": description,
+        "tiers": tiers,
+        "storage": storage,
+        "notes": notes,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.graph_subscription_tier import GraphSubscriptionTier
+    from ..models.storage_info import StorageInfo
+
+    d = dict(src_dict)
+    description = d.pop("description")
+
+    tiers = []
+    _tiers = d.pop("tiers")
+    for tiers_item_data in _tiers:
+      tiers_item = GraphSubscriptionTier.from_dict(tiers_item_data)
+
+      tiers.append(tiers_item)
+
+    storage = StorageInfo.from_dict(d.pop("storage"))
+
+    notes = cast(list[str], d.pop("notes"))
+
+    graph_subscriptions = cls(
+      description=description,
+      tiers=tiers,
+      storage=storage,
+      notes=notes,
+    )
+
+    graph_subscriptions.additional_properties = d
+    return graph_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/graph_tier_backup.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="GraphTierBackup")
+
+
+@_attrs_define
+class GraphTierBackup:
+  """Backup configuration for a tier.
+
+  Attributes:
+      max_backup_size_gb (int): Maximum backup size in GB
+      backup_retention_days (int): Backup retention period in days
+      max_backups_per_day (int): Maximum backups per day
+  """
+
+  max_backup_size_gb: int
+  backup_retention_days: int
+  max_backups_per_day: int
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    max_backup_size_gb = self.max_backup_size_gb
+
+    backup_retention_days = self.backup_retention_days
+
+    max_backups_per_day = self.max_backups_per_day
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "max_backup_size_gb": max_backup_size_gb,
+        "backup_retention_days": backup_retention_days,
+        "max_backups_per_day": max_backups_per_day,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    max_backup_size_gb = d.pop("max_backup_size_gb")
+
+    backup_retention_days = d.pop("backup_retention_days")
+
+    max_backups_per_day = d.pop("max_backups_per_day")
+
+    graph_tier_backup = cls(
+      max_backup_size_gb=max_backup_size_gb,
+      backup_retention_days=backup_retention_days,
+      max_backups_per_day=max_backups_per_day,
+    )
+
+    graph_tier_backup.additional_properties = d
+    return graph_tier_backup
+
+  @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_copy_operations.py

@@ -0,0 +1,92 @@
+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="GraphTierCopyOperations")
+
+
+@_attrs_define
+class GraphTierCopyOperations:
+  """Copy operation limits for a tier.
+
+  Attributes:
+      max_file_size_gb (float): Maximum file size in GB
+      timeout_seconds (int): Operation timeout in seconds
+      concurrent_operations (int): Maximum concurrent operations
+      max_files_per_operation (int): Maximum files per operation
+      daily_copy_operations (int): Daily operation limit
+  """
+
+  max_file_size_gb: float
+  timeout_seconds: int
+  concurrent_operations: int
+  max_files_per_operation: int
+  daily_copy_operations: int
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    max_file_size_gb = self.max_file_size_gb
+
+    timeout_seconds = self.timeout_seconds
+
+    concurrent_operations = self.concurrent_operations
+
+    max_files_per_operation = self.max_files_per_operation
+
+    daily_copy_operations = self.daily_copy_operations
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "max_file_size_gb": max_file_size_gb,
+        "timeout_seconds": timeout_seconds,
+        "concurrent_operations": concurrent_operations,
+        "max_files_per_operation": max_files_per_operation,
+        "daily_copy_operations": daily_copy_operations,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    max_file_size_gb = d.pop("max_file_size_gb")
+
+    timeout_seconds = d.pop("timeout_seconds")
+
+    concurrent_operations = d.pop("concurrent_operations")
+
+    max_files_per_operation = d.pop("max_files_per_operation")
+
+    daily_copy_operations = d.pop("daily_copy_operations")
+
+    graph_tier_copy_operations = cls(
+      max_file_size_gb=max_file_size_gb,
+      timeout_seconds=timeout_seconds,
+      concurrent_operations=concurrent_operations,
+      max_files_per_operation=max_files_per_operation,
+      daily_copy_operations=daily_copy_operations,
+    )
+
+    graph_tier_copy_operations.additional_properties = d
+    return graph_tier_copy_operations
+
+  @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_info.py

@@ -0,0 +1,192 @@
+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.graph_tier_instance import GraphTierInstance
+  from ..models.graph_tier_limits import GraphTierLimits
+
+
+T = TypeVar("T", bound="GraphTierInfo")
+
+
+@_attrs_define
+class GraphTierInfo:
+  """Complete information about a graph database tier.
+
+  Attributes:
+      tier (str): Tier identifier
+      name (str): Tier name
+      display_name (str): Display name for UI
+      description (str): Tier description
+      backend (str): Database backend (kuzu or neo4j)
+      enabled (bool): Whether tier is available
+      max_subgraphs (Union[None, int]): Maximum subgraphs allowed
+      storage_limit_gb (int): Storage limit in GB
+      monthly_credits (int): Monthly AI credits
+      api_rate_multiplier (float): API rate limit multiplier
+      features (list[str]): List of tier features
+      instance (GraphTierInstance): Instance specifications for a tier.
+      limits (GraphTierLimits): Resource limits for a tier.
+      monthly_price (Union[None, Unset, float]): Monthly price in USD
+  """
+
+  tier: str
+  name: str
+  display_name: str
+  description: str
+  backend: str
+  enabled: bool
+  max_subgraphs: Union[None, int]
+  storage_limit_gb: int
+  monthly_credits: int
+  api_rate_multiplier: float
+  features: list[str]
+  instance: "GraphTierInstance"
+  limits: "GraphTierLimits"
+  monthly_price: Union[None, Unset, float] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    tier = self.tier
+
+    name = self.name
+
+    display_name = self.display_name
+
+    description = self.description
+
+    backend = self.backend
+
+    enabled = self.enabled
+
+    max_subgraphs: Union[None, int]
+    max_subgraphs = self.max_subgraphs
+
+    storage_limit_gb = self.storage_limit_gb
+
+    monthly_credits = self.monthly_credits
+
+    api_rate_multiplier = self.api_rate_multiplier
+
+    features = self.features
+
+    instance = self.instance.to_dict()
+
+    limits = self.limits.to_dict()
+
+    monthly_price: Union[None, Unset, float]
+    if isinstance(self.monthly_price, Unset):
+      monthly_price = UNSET
+    else:
+      monthly_price = self.monthly_price
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "tier": tier,
+        "name": name,
+        "display_name": display_name,
+        "description": description,
+        "backend": backend,
+        "enabled": enabled,
+        "max_subgraphs": max_subgraphs,
+        "storage_limit_gb": storage_limit_gb,
+        "monthly_credits": monthly_credits,
+        "api_rate_multiplier": api_rate_multiplier,
+        "features": features,
+        "instance": instance,
+        "limits": limits,
+      }
+    )
+    if monthly_price is not UNSET:
+      field_dict["monthly_price"] = monthly_price
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.graph_tier_instance import GraphTierInstance
+    from ..models.graph_tier_limits import GraphTierLimits
+
+    d = dict(src_dict)
+    tier = d.pop("tier")
+
+    name = d.pop("name")
+
+    display_name = d.pop("display_name")
+
+    description = d.pop("description")
+
+    backend = d.pop("backend")
+
+    enabled = d.pop("enabled")
+
+    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"))
+
+    storage_limit_gb = d.pop("storage_limit_gb")
+
+    monthly_credits = d.pop("monthly_credits")
+
+    api_rate_multiplier = d.pop("api_rate_multiplier")
+
+    features = cast(list[str], d.pop("features"))
+
+    instance = GraphTierInstance.from_dict(d.pop("instance"))
+
+    limits = GraphTierLimits.from_dict(d.pop("limits"))
+
+    def _parse_monthly_price(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)
+
+    monthly_price = _parse_monthly_price(d.pop("monthly_price", UNSET))
+
+    graph_tier_info = cls(
+      tier=tier,
+      name=name,
+      display_name=display_name,
+      description=description,
+      backend=backend,
+      enabled=enabled,
+      max_subgraphs=max_subgraphs,
+      storage_limit_gb=storage_limit_gb,
+      monthly_credits=monthly_credits,
+      api_rate_multiplier=api_rate_multiplier,
+      features=features,
+      instance=instance,
+      limits=limits,
+      monthly_price=monthly_price,
+    )
+
+    graph_tier_info.additional_properties = d
+    return graph_tier_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