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

robosystems_client/models/create_checkout_request.py

@@ -0,0 +1,88 @@
+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.create_checkout_request_resource_config import (
+    CreateCheckoutRequestResourceConfig,
+  )
+
+
+T = TypeVar("T", bound="CreateCheckoutRequest")
+
+
+@_attrs_define
+class CreateCheckoutRequest:
+  """Request to create a checkout session for payment collection.
+
+  Attributes:
+      plan_name (str): Billing plan name (e.g., 'kuzu-standard')
+      resource_type (str): Resource type ('graph' or 'repository')
+      resource_config (CreateCheckoutRequestResourceConfig): Configuration for the resource to be provisioned
+  """
+
+  plan_name: str
+  resource_type: str
+  resource_config: "CreateCheckoutRequestResourceConfig"
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    plan_name = self.plan_name
+
+    resource_type = self.resource_type
+
+    resource_config = self.resource_config.to_dict()
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "plan_name": plan_name,
+        "resource_type": resource_type,
+        "resource_config": resource_config,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.create_checkout_request_resource_config import (
+      CreateCheckoutRequestResourceConfig,
+    )
+
+    d = dict(src_dict)
+    plan_name = d.pop("plan_name")
+
+    resource_type = d.pop("resource_type")
+
+    resource_config = CreateCheckoutRequestResourceConfig.from_dict(
+      d.pop("resource_config")
+    )
+
+    create_checkout_request = cls(
+      plan_name=plan_name,
+      resource_type=resource_type,
+      resource_config=resource_config,
+    )
+
+    create_checkout_request.additional_properties = d
+    return create_checkout_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_usage_response_query_statistics.py → create_checkout_request_resource_config.py}

@@ -4,12 +4,12 @@ from typing import Any, TypeVar
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="GraphUsageResponseQueryStatistics")
+T = TypeVar("T", bound="CreateCheckoutRequestResourceConfig")
 
 
 @_attrs_define
-class GraphUsageResponseQueryStatistics:
-  """Query statistics"""
+class CreateCheckoutRequestResourceConfig:
+  """Configuration for the resource to be provisioned"""
 
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -22,10 +22,10 @@ class GraphUsageResponseQueryStatistics:
   @classmethod
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
     d = dict(src_dict)
-    graph_usage_response_query_statistics = cls()
+    create_checkout_request_resource_config = cls()
 
-    graph_usage_response_query_statistics.additional_properties = d
-    return graph_usage_response_query_statistics
+    create_checkout_request_resource_config.additional_properties = d
+    return create_checkout_request_resource_config
 
   @property
   def additional_keys(self) -> list[str]:

robosystems_client/models/{credits_summary_response_credits_by_addon_type_0_item.py → create_repository_subscription_request.py}

@@ -4,28 +4,44 @@ from typing import Any, TypeVar
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="CreditsSummaryResponseCreditsByAddonType0Item")
+T = TypeVar("T", bound="CreateRepositorySubscriptionRequest")
 
 
 @_attrs_define
-class CreditsSummaryResponseCreditsByAddonType0Item:
-  """ """
+class CreateRepositorySubscriptionRequest:
+  """Request to create a repository subscription.
 
+  Attributes:
+      plan_name (str): Plan name for the repository subscription
+  """
+
+  plan_name: str
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
+    plan_name = self.plan_name
+
     field_dict: dict[str, Any] = {}
     field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "plan_name": plan_name,
+      }
+    )
 
     return field_dict
 
   @classmethod
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
     d = dict(src_dict)
-    credits_summary_response_credits_by_addon_type_0_item = cls()
+    plan_name = d.pop("plan_name")
+
+    create_repository_subscription_request = cls(
+      plan_name=plan_name,
+    )
 
-    credits_summary_response_credits_by_addon_type_0_item.additional_properties = d
-    return credits_summary_response_credits_by_addon_type_0_item
+    create_repository_subscription_request.additional_properties = d
+    return create_repository_subscription_request
 
   @property
   def additional_keys(self) -> list[str]:

robosystems_client/models/credit_summary.py

@@ -1,137 +1,103 @@
 from collections.abc import Mapping
-from typing import Any, TypeVar, Union, cast
+from typing import TYPE_CHECKING, Any, TypeVar
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-from ..types import UNSET, Unset
+if TYPE_CHECKING:
+  from ..models.credit_summary_operation_breakdown import (
+    CreditSummaryOperationBreakdown,
+  )
+
 
 T = TypeVar("T", bound="CreditSummary")
 
 
 @_attrs_define
 class CreditSummary:
-  """Credit balance summary.
+  """Credit consumption summary.
 
   Attributes:
-      current_balance (float): Current credit balance
-      monthly_allocation (float): Monthly credit allocation
-      consumed_this_month (float): Credits consumed this month
-      usage_percentage (float): Usage percentage of monthly allocation
-      rollover_credits (float): Credits rolled over from previous month
-      allows_rollover (bool): Whether rollover is allowed
-      is_active (bool): Whether credit pool is active
-      last_allocation_date (Union[None, Unset, str]): Last allocation date (ISO format)
-      next_allocation_date (Union[None, Unset, str]): Next allocation date (ISO format)
+      graph_tier (str): Subscription tier
+      total_credits_consumed (float): Total credits consumed
+      total_base_cost (float): Total base cost before multipliers
+      operation_breakdown (CreditSummaryOperationBreakdown): Credit usage by operation type
+      cached_operations (int): Number of cached operations
+      billable_operations (int): Number of billable operations
+      transaction_count (int): Total transaction count
   """
 
-  current_balance: float
-  monthly_allocation: float
-  consumed_this_month: float
-  usage_percentage: float
-  rollover_credits: float
-  allows_rollover: bool
-  is_active: bool
-  last_allocation_date: Union[None, Unset, str] = UNSET
-  next_allocation_date: Union[None, Unset, str] = UNSET
+  graph_tier: str
+  total_credits_consumed: float
+  total_base_cost: float
+  operation_breakdown: "CreditSummaryOperationBreakdown"
+  cached_operations: int
+  billable_operations: int
+  transaction_count: int
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
-    current_balance = self.current_balance
-
-    monthly_allocation = self.monthly_allocation
-
-    consumed_this_month = self.consumed_this_month
+    graph_tier = self.graph_tier
 
-    usage_percentage = self.usage_percentage
+    total_credits_consumed = self.total_credits_consumed
 
-    rollover_credits = self.rollover_credits
+    total_base_cost = self.total_base_cost
 
-    allows_rollover = self.allows_rollover
+    operation_breakdown = self.operation_breakdown.to_dict()
 
-    is_active = self.is_active
+    cached_operations = self.cached_operations
 
-    last_allocation_date: Union[None, Unset, str]
-    if isinstance(self.last_allocation_date, Unset):
-      last_allocation_date = UNSET
-    else:
-      last_allocation_date = self.last_allocation_date
+    billable_operations = self.billable_operations
 
-    next_allocation_date: Union[None, Unset, str]
-    if isinstance(self.next_allocation_date, Unset):
-      next_allocation_date = UNSET
-    else:
-      next_allocation_date = self.next_allocation_date
+    transaction_count = self.transaction_count
 
     field_dict: dict[str, Any] = {}
     field_dict.update(self.additional_properties)
     field_dict.update(
       {
-        "current_balance": current_balance,
-        "monthly_allocation": monthly_allocation,
-        "consumed_this_month": consumed_this_month,
-        "usage_percentage": usage_percentage,
-        "rollover_credits": rollover_credits,
-        "allows_rollover": allows_rollover,
-        "is_active": is_active,
+        "graph_tier": graph_tier,
+        "total_credits_consumed": total_credits_consumed,
+        "total_base_cost": total_base_cost,
+        "operation_breakdown": operation_breakdown,
+        "cached_operations": cached_operations,
+        "billable_operations": billable_operations,
+        "transaction_count": transaction_count,
       }
     )
-    if last_allocation_date is not UNSET:
-      field_dict["last_allocation_date"] = last_allocation_date
-    if next_allocation_date is not UNSET:
-      field_dict["next_allocation_date"] = next_allocation_date
 
     return field_dict
 
   @classmethod
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
-    d = dict(src_dict)
-    current_balance = d.pop("current_balance")
-
-    monthly_allocation = d.pop("monthly_allocation")
-
-    consumed_this_month = d.pop("consumed_this_month")
-
-    usage_percentage = d.pop("usage_percentage")
-
-    rollover_credits = d.pop("rollover_credits")
+    from ..models.credit_summary_operation_breakdown import (
+      CreditSummaryOperationBreakdown,
+    )
 
-    allows_rollover = d.pop("allows_rollover")
+    d = dict(src_dict)
+    graph_tier = d.pop("graph_tier")
 
-    is_active = d.pop("is_active")
+    total_credits_consumed = d.pop("total_credits_consumed")
 
-    def _parse_last_allocation_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)
+    total_base_cost = d.pop("total_base_cost")
 
-    last_allocation_date = _parse_last_allocation_date(
-      d.pop("last_allocation_date", UNSET)
+    operation_breakdown = CreditSummaryOperationBreakdown.from_dict(
+      d.pop("operation_breakdown")
     )
 
-    def _parse_next_allocation_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)
+    cached_operations = d.pop("cached_operations")
 
-    next_allocation_date = _parse_next_allocation_date(
-      d.pop("next_allocation_date", UNSET)
-    )
+    billable_operations = d.pop("billable_operations")
+
+    transaction_count = d.pop("transaction_count")
 
     credit_summary = cls(
-      current_balance=current_balance,
-      monthly_allocation=monthly_allocation,
-      consumed_this_month=consumed_this_month,
-      usage_percentage=usage_percentage,
-      rollover_credits=rollover_credits,
-      allows_rollover=allows_rollover,
-      is_active=is_active,
-      last_allocation_date=last_allocation_date,
-      next_allocation_date=next_allocation_date,
+      graph_tier=graph_tier,
+      total_credits_consumed=total_credits_consumed,
+      total_base_cost=total_base_cost,
+      operation_breakdown=operation_breakdown,
+      cached_operations=cached_operations,
+      billable_operations=billable_operations,
+      transaction_count=transaction_count,
     )
 
     credit_summary.additional_properties = d

robosystems_client/models/{graph_usage_response_storage_usage.py → credit_summary_operation_breakdown.py}

@@ -4,12 +4,12 @@ from typing import Any, TypeVar
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="GraphUsageResponseStorageUsage")
+T = TypeVar("T", bound="CreditSummaryOperationBreakdown")
 
 
 @_attrs_define
-class GraphUsageResponseStorageUsage:
-  """Storage usage information"""
+class CreditSummaryOperationBreakdown:
+  """Credit usage by operation type"""
 
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -22,10 +22,10 @@ class GraphUsageResponseStorageUsage:
   @classmethod
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
     d = dict(src_dict)
-    graph_usage_response_storage_usage = cls()
+    credit_summary_operation_breakdown = cls()
 
-    graph_usage_response_storage_usage.additional_properties = d
-    return graph_usage_response_storage_usage
+    credit_summary_operation_breakdown.additional_properties = d
+    return credit_summary_operation_breakdown
 
   @property
   def additional_keys(self) -> list[str]:

robosystems_client/models/graph_subscription_response.py

@@ -0,0 +1,200 @@
+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="GraphSubscriptionResponse")
+
+
+@_attrs_define
+class GraphSubscriptionResponse:
+  """Response for graph or repository subscription details.
+
+  Attributes:
+      id (str): Subscription ID
+      resource_type (str): Resource type (graph or repository)
+      resource_id (str): Resource identifier
+      plan_name (str): Current plan name
+      billing_interval (str): Billing interval
+      status (str): Subscription status
+      base_price_cents (int): Base price in cents
+      created_at (str): Creation timestamp
+      current_period_start (Union[None, Unset, str]): Current billing period start
+      current_period_end (Union[None, Unset, str]): Current billing period end
+      started_at (Union[None, Unset, str]): Subscription start date
+      canceled_at (Union[None, Unset, str]): Cancellation date
+  """
+
+  id: str
+  resource_type: str
+  resource_id: str
+  plan_name: str
+  billing_interval: str
+  status: str
+  base_price_cents: int
+  created_at: str
+  current_period_start: Union[None, Unset, str] = UNSET
+  current_period_end: Union[None, Unset, str] = UNSET
+  started_at: Union[None, Unset, str] = UNSET
+  canceled_at: 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
+
+    resource_type = self.resource_type
+
+    resource_id = self.resource_id
+
+    plan_name = self.plan_name
+
+    billing_interval = self.billing_interval
+
+    status = self.status
+
+    base_price_cents = self.base_price_cents
+
+    created_at = self.created_at
+
+    current_period_start: Union[None, Unset, str]
+    if isinstance(self.current_period_start, Unset):
+      current_period_start = UNSET
+    else:
+      current_period_start = self.current_period_start
+
+    current_period_end: Union[None, Unset, str]
+    if isinstance(self.current_period_end, Unset):
+      current_period_end = UNSET
+    else:
+      current_period_end = self.current_period_end
+
+    started_at: Union[None, Unset, str]
+    if isinstance(self.started_at, Unset):
+      started_at = UNSET
+    else:
+      started_at = self.started_at
+
+    canceled_at: Union[None, Unset, str]
+    if isinstance(self.canceled_at, Unset):
+      canceled_at = UNSET
+    else:
+      canceled_at = self.canceled_at
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "id": id,
+        "resource_type": resource_type,
+        "resource_id": resource_id,
+        "plan_name": plan_name,
+        "billing_interval": billing_interval,
+        "status": status,
+        "base_price_cents": base_price_cents,
+        "created_at": created_at,
+      }
+    )
+    if current_period_start is not UNSET:
+      field_dict["current_period_start"] = current_period_start
+    if current_period_end is not UNSET:
+      field_dict["current_period_end"] = current_period_end
+    if started_at is not UNSET:
+      field_dict["started_at"] = started_at
+    if canceled_at is not UNSET:
+      field_dict["canceled_at"] = canceled_at
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    id = d.pop("id")
+
+    resource_type = d.pop("resource_type")
+
+    resource_id = d.pop("resource_id")
+
+    plan_name = d.pop("plan_name")
+
+    billing_interval = d.pop("billing_interval")
+
+    status = d.pop("status")
+
+    base_price_cents = d.pop("base_price_cents")
+
+    created_at = d.pop("created_at")
+
+    def _parse_current_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)
+
+    current_period_start = _parse_current_period_start(
+      d.pop("current_period_start", UNSET)
+    )
+
+    def _parse_current_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)
+
+    current_period_end = _parse_current_period_end(d.pop("current_period_end", UNSET))
+
+    def _parse_started_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)
+
+    started_at = _parse_started_at(d.pop("started_at", UNSET))
+
+    def _parse_canceled_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)
+
+    canceled_at = _parse_canceled_at(d.pop("canceled_at", UNSET))
+
+    graph_subscription_response = cls(
+      id=id,
+      resource_type=resource_type,
+      resource_id=resource_id,
+      plan_name=plan_name,
+      billing_interval=billing_interval,
+      status=status,
+      base_price_cents=base_price_cents,
+      created_at=created_at,
+      current_period_start=current_period_start,
+      current_period_end=current_period_end,
+      started_at=started_at,
+      canceled_at=canceled_at,
+    )
+
+    graph_subscription_response.additional_properties = d
+    return graph_subscription_response
+
+  @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