robosystems-client 0.2.11__py3-none-any.whl → 0.2.12__py3-none-any.whl

robosystems_client/models/checkout_response.py

@@ -1,5 +1,5 @@
 from collections.abc import Mapping
-from typing import Any, TypeVar, Union
+from typing import Any, TypeVar, Union, cast
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -14,57 +14,100 @@ class CheckoutResponse:
   """Response from checkout session creation.
 
   Attributes:
-      checkout_url (str): URL to redirect user to for payment
-      session_id (str): Checkout session ID for status polling
-      subscription_id (str): Internal subscription ID
+      checkout_url (Union[None, Unset, str]): URL to redirect user to for payment
+      session_id (Union[None, Unset, str]): Checkout session ID for status polling
+      subscription_id (Union[None, Unset, str]): Internal subscription ID
       requires_checkout (Union[Unset, bool]): Whether checkout is required Default: True.
+      billing_disabled (Union[Unset, bool]): Whether billing is disabled on this instance Default: False.
   """
 
-  checkout_url: str
-  session_id: str
-  subscription_id: str
+  checkout_url: Union[None, Unset, str] = UNSET
+  session_id: Union[None, Unset, str] = UNSET
+  subscription_id: Union[None, Unset, str] = UNSET
   requires_checkout: Union[Unset, bool] = True
+  billing_disabled: Union[Unset, bool] = False
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
-    checkout_url = self.checkout_url
-
-    session_id = self.session_id
-
-    subscription_id = self.subscription_id
+    checkout_url: Union[None, Unset, str]
+    if isinstance(self.checkout_url, Unset):
+      checkout_url = UNSET
+    else:
+      checkout_url = self.checkout_url
+
+    session_id: Union[None, Unset, str]
+    if isinstance(self.session_id, Unset):
+      session_id = UNSET
+    else:
+      session_id = self.session_id
+
+    subscription_id: Union[None, Unset, str]
+    if isinstance(self.subscription_id, Unset):
+      subscription_id = UNSET
+    else:
+      subscription_id = self.subscription_id
 
     requires_checkout = self.requires_checkout
 
+    billing_disabled = self.billing_disabled
+
     field_dict: dict[str, Any] = {}
     field_dict.update(self.additional_properties)
-    field_dict.update(
-      {
-        "checkout_url": checkout_url,
-        "session_id": session_id,
-        "subscription_id": subscription_id,
-      }
-    )
+    field_dict.update({})
+    if checkout_url is not UNSET:
+      field_dict["checkout_url"] = checkout_url
+    if session_id is not UNSET:
+      field_dict["session_id"] = session_id
+    if subscription_id is not UNSET:
+      field_dict["subscription_id"] = subscription_id
     if requires_checkout is not UNSET:
       field_dict["requires_checkout"] = requires_checkout
+    if billing_disabled is not UNSET:
+      field_dict["billing_disabled"] = billing_disabled
 
     return field_dict
 
   @classmethod
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
     d = dict(src_dict)
-    checkout_url = d.pop("checkout_url")
 
-    session_id = d.pop("session_id")
+    def _parse_checkout_url(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)
+
+    checkout_url = _parse_checkout_url(d.pop("checkout_url", UNSET))
 
-    subscription_id = d.pop("subscription_id")
+    def _parse_session_id(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)
+
+    session_id = _parse_session_id(d.pop("session_id", UNSET))
+
+    def _parse_subscription_id(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)
+
+    subscription_id = _parse_subscription_id(d.pop("subscription_id", UNSET))
 
     requires_checkout = d.pop("requires_checkout", UNSET)
 
+    billing_disabled = d.pop("billing_disabled", UNSET)
+
     checkout_response = cls(
       checkout_url=checkout_url,
       session_id=session_id,
       subscription_id=subscription_id,
       requires_checkout=requires_checkout,
+      billing_disabled=billing_disabled,
     )
 
     checkout_response.additional_properties = d

robosystems_client/models/create_org_request.py

@@ -0,0 +1,79 @@
+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.org_type import OrgType
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="CreateOrgRequest")
+
+
+@_attrs_define
+class CreateOrgRequest:
+  """Request to create an organization.
+
+  Attributes:
+      name (str):
+      org_type (Union[Unset, OrgType]):
+  """
+
+  name: str
+  org_type: Union[Unset, OrgType] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    name = self.name
+
+    org_type: Union[Unset, str] = UNSET
+    if not isinstance(self.org_type, Unset):
+      org_type = self.org_type.value
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "name": name,
+      }
+    )
+    if org_type is not UNSET:
+      field_dict["org_type"] = org_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")
+
+    _org_type = d.pop("org_type", UNSET)
+    org_type: Union[Unset, OrgType]
+    if isinstance(_org_type, Unset):
+      org_type = UNSET
+    else:
+      org_type = OrgType(_org_type)
+
+    create_org_request = cls(
+      name=name,
+      org_type=org_type,
+    )
+
+    create_org_request.additional_properties = d
+    return create_org_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/graph_subscription_tier.py

@@ -11,42 +11,45 @@ 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
+  """Information about a graph infrastructure tier.
+
+  Each tier represents a per-graph subscription option with specific
+  infrastructure, performance, and pricing characteristics.
+
+      Attributes:
+          name (str): Infrastructure tier identifier (e.g., kuzu-standard)
+          display_name (str): Display name for UI
+          description (str): Tier description
+          monthly_price_per_graph (float): Monthly price in USD per graph
+          monthly_credits_per_graph (int): Monthly AI credits per graph
+          storage_included_gb (int): Storage included in GB
+          storage_overage_per_gb (float): Overage cost per GB per month
+          infrastructure (str): Infrastructure description
+          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[Unset, int]): Maximum subgraphs supported Default: 0.
+          instance_type (Union[None, Unset, str]): Instance type
   """
 
   name: str
   display_name: str
   description: str
-  monthly_price: float
-  monthly_credits: int
+  monthly_price_per_graph: float
+  monthly_credits_per_graph: int
   storage_included_gb: int
   storage_overage_per_gb: float
-  allowed_graph_tiers: list[str]
+  infrastructure: 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
+  max_subgraphs: Union[Unset, int] = 0
   instance_type: Union[None, Unset, str] = UNSET
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -57,15 +60,15 @@ class GraphSubscriptionTier:
 
     description = self.description
 
-    monthly_price = self.monthly_price
+    monthly_price_per_graph = self.monthly_price_per_graph
 
-    monthly_credits = self.monthly_credits
+    monthly_credits_per_graph = self.monthly_credits_per_graph
 
     storage_included_gb = self.storage_included_gb
 
     storage_overage_per_gb = self.storage_overage_per_gb
 
-    allowed_graph_tiers = self.allowed_graph_tiers
+    infrastructure = self.infrastructure
 
     features = self.features
 
@@ -83,11 +86,7 @@ class GraphSubscriptionTier:
     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
+    max_subgraphs = self.max_subgraphs
 
     instance_type: Union[None, Unset, str]
     if isinstance(self.instance_type, Unset):
@@ -102,11 +101,11 @@ class GraphSubscriptionTier:
         "name": name,
         "display_name": display_name,
         "description": description,
-        "monthly_price": monthly_price,
-        "monthly_credits": monthly_credits,
+        "monthly_price_per_graph": monthly_price_per_graph,
+        "monthly_credits_per_graph": monthly_credits_per_graph,
         "storage_included_gb": storage_included_gb,
         "storage_overage_per_gb": storage_overage_per_gb,
-        "allowed_graph_tiers": allowed_graph_tiers,
+        "infrastructure": infrastructure,
         "features": features,
         "backup_retention_days": backup_retention_days,
         "priority_support": priority_support,
@@ -132,15 +131,15 @@ class GraphSubscriptionTier:
 
     description = d.pop("description")
 
-    monthly_price = d.pop("monthly_price")
+    monthly_price_per_graph = d.pop("monthly_price_per_graph")
 
-    monthly_credits = d.pop("monthly_credits")
+    monthly_credits_per_graph = d.pop("monthly_credits_per_graph")
 
     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"))
+    infrastructure = d.pop("infrastructure")
 
     features = cast(list[str], d.pop("features"))
 
@@ -163,14 +162,7 @@ class GraphSubscriptionTier:
       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))
+    max_subgraphs = d.pop("max_subgraphs", UNSET)
 
     def _parse_instance_type(data: object) -> Union[None, Unset, str]:
       if data is None:
@@ -185,11 +177,11 @@ class GraphSubscriptionTier:
       name=name,
       display_name=display_name,
       description=description,
-      monthly_price=monthly_price,
-      monthly_credits=monthly_credits,
+      monthly_price_per_graph=monthly_price_per_graph,
+      monthly_credits_per_graph=monthly_credits_per_graph,
       storage_included_gb=storage_included_gb,
       storage_overage_per_gb=storage_overage_per_gb,
-      allowed_graph_tiers=allowed_graph_tiers,
+      infrastructure=infrastructure,
       features=features,
       backup_retention_days=backup_retention_days,
       priority_support=priority_support,

robosystems_client/models/graph_subscriptions.py

@@ -16,14 +16,20 @@ T = TypeVar("T", bound="GraphSubscriptions")
 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
+  Graph subscriptions are per-graph, not per-organization. Each graph
+  created by an organization has its own subscription with its own
+  infrastructure tier, pricing, and credit allocation.
+
+      Attributes:
+          description (str): Description of graph subscriptions
+          pricing_model (str): Pricing model type (per_graph or per_organization)
+          tiers (list['GraphSubscriptionTier']): Available infrastructure tiers
+          storage (StorageInfo): Storage pricing information.
+          notes (list[str]): Important notes
   """
 
   description: str
+  pricing_model: str
   tiers: list["GraphSubscriptionTier"]
   storage: "StorageInfo"
   notes: list[str]
@@ -32,6 +38,8 @@ class GraphSubscriptions:
   def to_dict(self) -> dict[str, Any]:
     description = self.description
 
+    pricing_model = self.pricing_model
+
     tiers = []
     for tiers_item_data in self.tiers:
       tiers_item = tiers_item_data.to_dict()
@@ -46,6 +54,7 @@ class GraphSubscriptions:
     field_dict.update(
       {
         "description": description,
+        "pricing_model": pricing_model,
         "tiers": tiers,
         "storage": storage,
         "notes": notes,
@@ -62,6 +71,8 @@ class GraphSubscriptions:
     d = dict(src_dict)
     description = d.pop("description")
 
+    pricing_model = d.pop("pricing_model")
+
     tiers = []
     _tiers = d.pop("tiers")
     for tiers_item_data in _tiers:
@@ -75,6 +86,7 @@ class GraphSubscriptions:
 
     graph_subscriptions = cls(
       description=description,
+      pricing_model=pricing_model,
       tiers=tiers,
       storage=storage,
       notes=notes,

robosystems_client/models/invite_member_request.py

@@ -0,0 +1,93 @@
+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 ..models.org_role import OrgRole
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="InviteMemberRequest")
+
+
+@_attrs_define
+class InviteMemberRequest:
+  """Request to invite a member to an organization.
+
+  Attributes:
+      email (str):
+      role (Union[None, OrgRole, Unset]):  Default: OrgRole.MEMBER.
+  """
+
+  email: str
+  role: Union[None, OrgRole, Unset] = OrgRole.MEMBER
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    email = self.email
+
+    role: Union[None, Unset, str]
+    if isinstance(self.role, Unset):
+      role = UNSET
+    elif isinstance(self.role, OrgRole):
+      role = self.role.value
+    else:
+      role = self.role
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "email": email,
+      }
+    )
+    if role is not UNSET:
+      field_dict["role"] = role
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    email = d.pop("email")
+
+    def _parse_role(data: object) -> Union[None, OrgRole, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, str):
+          raise TypeError()
+        role_type_0 = OrgRole(data)
+
+        return role_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union[None, OrgRole, Unset], data)
+
+    role = _parse_role(d.pop("role", UNSET))
+
+    invite_member_request = cls(
+      email=email,
+      role=role,
+    )
+
+    invite_member_request.additional_properties = d
+    return invite_member_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/list_org_graphs_response_200_item.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="ListOrgGraphsResponse200Item")
+
+
+@_attrs_define
+class ListOrgGraphsResponse200Item:
+  """ """
+
+  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)
+    list_org_graphs_response_200_item = cls()
+
+    list_org_graphs_response_200_item.additional_properties = d
+    return list_org_graphs_response_200_item
+
+  @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