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

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

@@ -0,0 +1,244 @@
+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.invoice_line_item import InvoiceLineItem
+
+
+T = TypeVar("T", bound="Invoice")
+
+
+@_attrs_define
+class Invoice:
+  """Invoice information.
+
+  Attributes:
+      id (str): Invoice ID
+      status (str): Invoice status (paid, open, void, uncollectible)
+      amount_due (int): Amount due in cents
+      amount_paid (int): Amount paid in cents
+      currency (str): Currency code (usd)
+      created (str): Invoice creation date (ISO format)
+      line_items (list['InvoiceLineItem']): Invoice line items
+      number (Union[None, Unset, str]): Invoice number
+      due_date (Union[None, Unset, str]): Invoice due date (ISO format)
+      paid_at (Union[None, Unset, str]): Payment date (ISO format)
+      invoice_pdf (Union[None, Unset, str]): PDF download URL
+      hosted_invoice_url (Union[None, Unset, str]): Hosted invoice URL
+      subscription_id (Union[None, Unset, str]): Associated subscription ID
+  """
+
+  id: str
+  status: str
+  amount_due: int
+  amount_paid: int
+  currency: str
+  created: str
+  line_items: list["InvoiceLineItem"]
+  number: Union[None, Unset, str] = UNSET
+  due_date: Union[None, Unset, str] = UNSET
+  paid_at: Union[None, Unset, str] = UNSET
+  invoice_pdf: Union[None, Unset, str] = UNSET
+  hosted_invoice_url: Union[None, Unset, str] = UNSET
+  subscription_id: Union[None, Unset, str] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    id = self.id
+
+    status = self.status
+
+    amount_due = self.amount_due
+
+    amount_paid = self.amount_paid
+
+    currency = self.currency
+
+    created = self.created
+
+    line_items = []
+    for line_items_item_data in self.line_items:
+      line_items_item = line_items_item_data.to_dict()
+      line_items.append(line_items_item)
+
+    number: Union[None, Unset, str]
+    if isinstance(self.number, Unset):
+      number = UNSET
+    else:
+      number = self.number
+
+    due_date: Union[None, Unset, str]
+    if isinstance(self.due_date, Unset):
+      due_date = UNSET
+    else:
+      due_date = self.due_date
+
+    paid_at: Union[None, Unset, str]
+    if isinstance(self.paid_at, Unset):
+      paid_at = UNSET
+    else:
+      paid_at = self.paid_at
+
+    invoice_pdf: Union[None, Unset, str]
+    if isinstance(self.invoice_pdf, Unset):
+      invoice_pdf = UNSET
+    else:
+      invoice_pdf = self.invoice_pdf
+
+    hosted_invoice_url: Union[None, Unset, str]
+    if isinstance(self.hosted_invoice_url, Unset):
+      hosted_invoice_url = UNSET
+    else:
+      hosted_invoice_url = self.hosted_invoice_url
+
+    subscription_id: Union[None, Unset, str]
+    if isinstance(self.subscription_id, Unset):
+      subscription_id = UNSET
+    else:
+      subscription_id = self.subscription_id
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "id": id,
+        "status": status,
+        "amount_due": amount_due,
+        "amount_paid": amount_paid,
+        "currency": currency,
+        "created": created,
+        "line_items": line_items,
+      }
+    )
+    if number is not UNSET:
+      field_dict["number"] = number
+    if due_date is not UNSET:
+      field_dict["due_date"] = due_date
+    if paid_at is not UNSET:
+      field_dict["paid_at"] = paid_at
+    if invoice_pdf is not UNSET:
+      field_dict["invoice_pdf"] = invoice_pdf
+    if hosted_invoice_url is not UNSET:
+      field_dict["hosted_invoice_url"] = hosted_invoice_url
+    if subscription_id is not UNSET:
+      field_dict["subscription_id"] = subscription_id
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.invoice_line_item import InvoiceLineItem
+
+    d = dict(src_dict)
+    id = d.pop("id")
+
+    status = d.pop("status")
+
+    amount_due = d.pop("amount_due")
+
+    amount_paid = d.pop("amount_paid")
+
+    currency = d.pop("currency")
+
+    created = d.pop("created")
+
+    line_items = []
+    _line_items = d.pop("line_items")
+    for line_items_item_data in _line_items:
+      line_items_item = InvoiceLineItem.from_dict(line_items_item_data)
+
+      line_items.append(line_items_item)
+
+    def _parse_number(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)
+
+    number = _parse_number(d.pop("number", UNSET))
+
+    def _parse_due_date(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)
+
+    due_date = _parse_due_date(d.pop("due_date", UNSET))
+
+    def _parse_paid_at(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)
+
+    paid_at = _parse_paid_at(d.pop("paid_at", UNSET))
+
+    def _parse_invoice_pdf(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)
+
+    invoice_pdf = _parse_invoice_pdf(d.pop("invoice_pdf", UNSET))
+
+    def _parse_hosted_invoice_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)
+
+    hosted_invoice_url = _parse_hosted_invoice_url(d.pop("hosted_invoice_url", 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))
+
+    invoice = cls(
+      id=id,
+      status=status,
+      amount_due=amount_due,
+      amount_paid=amount_paid,
+      currency=currency,
+      created=created,
+      line_items=line_items,
+      number=number,
+      due_date=due_date,
+      paid_at=paid_at,
+      invoice_pdf=invoice_pdf,
+      hosted_invoice_url=hosted_invoice_url,
+      subscription_id=subscription_id,
+    )
+
+    invoice.additional_properties = d
+    return invoice
+
+  @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/invoice_line_item.py

@@ -0,0 +1,118 @@
+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="InvoiceLineItem")
+
+
+@_attrs_define
+class InvoiceLineItem:
+  """Invoice line item.
+
+  Attributes:
+      description (str): Line item description
+      amount (int): Amount in cents
+      quantity (int): Quantity
+      period_start (Union[None, Unset, str]): Billing period start
+      period_end (Union[None, Unset, str]): Billing period end
+  """
+
+  description: str
+  amount: int
+  quantity: int
+  period_start: Union[None, Unset, str] = UNSET
+  period_end: Union[None, Unset, str] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    description = self.description
+
+    amount = self.amount
+
+    quantity = self.quantity
+
+    period_start: Union[None, Unset, str]
+    if isinstance(self.period_start, Unset):
+      period_start = UNSET
+    else:
+      period_start = self.period_start
+
+    period_end: Union[None, Unset, str]
+    if isinstance(self.period_end, Unset):
+      period_end = UNSET
+    else:
+      period_end = self.period_end
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "description": description,
+        "amount": amount,
+        "quantity": quantity,
+      }
+    )
+    if period_start is not UNSET:
+      field_dict["period_start"] = period_start
+    if period_end is not UNSET:
+      field_dict["period_end"] = period_end
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    description = d.pop("description")
+
+    amount = d.pop("amount")
+
+    quantity = d.pop("quantity")
+
+    def _parse_period_start(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)
+
+    period_start = _parse_period_start(d.pop("period_start", UNSET))
+
+    def _parse_period_end(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)
+
+    period_end = _parse_period_end(d.pop("period_end", UNSET))
+
+    invoice_line_item = cls(
+      description=description,
+      amount=amount,
+      quantity=quantity,
+      period_start=period_start,
+      period_end=period_end,
+    )
+
+    invoice_line_item.additional_properties = d
+    return invoice_line_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