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

robosystems_client/models/billing_customer.py

@@ -0,0 +1,128 @@
+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.payment_method import PaymentMethod
+
+
+T = TypeVar("T", bound="BillingCustomer")
+
+
+@_attrs_define
+class BillingCustomer:
+  """Billing customer information.
+
+  Attributes:
+      user_id (str): User ID
+      has_payment_method (bool): Whether customer has a payment method on file
+      invoice_billing_enabled (bool): Whether invoice billing is enabled (enterprise customers)
+      payment_methods (list['PaymentMethod']): List of payment methods on file
+      created_at (str): Customer creation timestamp (ISO format)
+      stripe_customer_id (Union[None, Unset, str]): Stripe customer ID if applicable
+  """
+
+  user_id: str
+  has_payment_method: bool
+  invoice_billing_enabled: bool
+  payment_methods: list["PaymentMethod"]
+  created_at: str
+  stripe_customer_id: Union[None, Unset, str] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    user_id = self.user_id
+
+    has_payment_method = self.has_payment_method
+
+    invoice_billing_enabled = self.invoice_billing_enabled
+
+    payment_methods = []
+    for payment_methods_item_data in self.payment_methods:
+      payment_methods_item = payment_methods_item_data.to_dict()
+      payment_methods.append(payment_methods_item)
+
+    created_at = self.created_at
+
+    stripe_customer_id: Union[None, Unset, str]
+    if isinstance(self.stripe_customer_id, Unset):
+      stripe_customer_id = UNSET
+    else:
+      stripe_customer_id = self.stripe_customer_id
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "user_id": user_id,
+        "has_payment_method": has_payment_method,
+        "invoice_billing_enabled": invoice_billing_enabled,
+        "payment_methods": payment_methods,
+        "created_at": created_at,
+      }
+    )
+    if stripe_customer_id is not UNSET:
+      field_dict["stripe_customer_id"] = stripe_customer_id
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.payment_method import PaymentMethod
+
+    d = dict(src_dict)
+    user_id = d.pop("user_id")
+
+    has_payment_method = d.pop("has_payment_method")
+
+    invoice_billing_enabled = d.pop("invoice_billing_enabled")
+
+    payment_methods = []
+    _payment_methods = d.pop("payment_methods")
+    for payment_methods_item_data in _payment_methods:
+      payment_methods_item = PaymentMethod.from_dict(payment_methods_item_data)
+
+      payment_methods.append(payment_methods_item)
+
+    created_at = d.pop("created_at")
+
+    def _parse_stripe_customer_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)
+
+    stripe_customer_id = _parse_stripe_customer_id(d.pop("stripe_customer_id", UNSET))
+
+    billing_customer = cls(
+      user_id=user_id,
+      has_payment_method=has_payment_method,
+      invoice_billing_enabled=invoice_billing_enabled,
+      payment_methods=payment_methods,
+      created_at=created_at,
+      stripe_customer_id=stripe_customer_id,
+    )
+
+    billing_customer.additional_properties = d
+    return billing_customer
+
+  @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/checkout_response.py

@@ -0,0 +1,87 @@
+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 ..types import UNSET, Unset
+
+T = TypeVar("T", bound="CheckoutResponse")
+
+
+@_attrs_define
+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
+      requires_checkout (Union[Unset, bool]): Whether checkout is required Default: True.
+  """
+
+  checkout_url: str
+  session_id: str
+  subscription_id: str
+  requires_checkout: Union[Unset, bool] = True
+  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
+
+    requires_checkout = self.requires_checkout
+
+    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,
+      }
+    )
+    if requires_checkout is not UNSET:
+      field_dict["requires_checkout"] = requires_checkout
+
+    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")
+
+    subscription_id = d.pop("subscription_id")
+
+    requires_checkout = d.pop("requires_checkout", UNSET)
+
+    checkout_response = cls(
+      checkout_url=checkout_url,
+      session_id=session_id,
+      subscription_id=subscription_id,
+      requires_checkout=requires_checkout,
+    )
+
+    checkout_response.additional_properties = d
+    return checkout_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

robosystems_client/models/checkout_status_response.py

@@ -0,0 +1,130 @@
+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="CheckoutStatusResponse")
+
+
+@_attrs_define
+class CheckoutStatusResponse:
+  """Status of a checkout session.
+
+  Attributes:
+      status (str): Checkout status: 'pending_payment', 'provisioning', 'completed', 'failed'
+      subscription_id (str): Internal subscription ID
+      resource_id (Union[None, Unset, str]): Resource ID (graph_id or repository name) once provisioned
+      operation_id (Union[None, Unset, str]): SSE operation ID for monitoring provisioning progress
+      error (Union[None, Unset, str]): Error message if checkout failed
+  """
+
+  status: str
+  subscription_id: str
+  resource_id: Union[None, Unset, str] = UNSET
+  operation_id: Union[None, Unset, str] = UNSET
+  error: Union[None, Unset, str] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    status = self.status
+
+    subscription_id = self.subscription_id
+
+    resource_id: Union[None, Unset, str]
+    if isinstance(self.resource_id, Unset):
+      resource_id = UNSET
+    else:
+      resource_id = self.resource_id
+
+    operation_id: Union[None, Unset, str]
+    if isinstance(self.operation_id, Unset):
+      operation_id = UNSET
+    else:
+      operation_id = self.operation_id
+
+    error: Union[None, Unset, str]
+    if isinstance(self.error, Unset):
+      error = UNSET
+    else:
+      error = self.error
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "status": status,
+        "subscription_id": subscription_id,
+      }
+    )
+    if resource_id is not UNSET:
+      field_dict["resource_id"] = resource_id
+    if operation_id is not UNSET:
+      field_dict["operation_id"] = operation_id
+    if error is not UNSET:
+      field_dict["error"] = error
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    status = d.pop("status")
+
+    subscription_id = d.pop("subscription_id")
+
+    def _parse_resource_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)
+
+    resource_id = _parse_resource_id(d.pop("resource_id", UNSET))
+
+    def _parse_operation_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)
+
+    operation_id = _parse_operation_id(d.pop("operation_id", UNSET))
+
+    def _parse_error(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)
+
+    error = _parse_error(d.pop("error", UNSET))
+
+    checkout_status_response = cls(
+      status=status,
+      subscription_id=subscription_id,
+      resource_id=resource_id,
+      operation_id=operation_id,
+      error=error,
+    )
+
+    checkout_status_response.additional_properties = d
+    return checkout_status_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

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/create_checkout_request_resource_config.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="CreateCheckoutRequestResourceConfig")
+
+
+@_attrs_define
+class CreateCheckoutRequestResourceConfig:
+  """Configuration for the resource to be provisioned"""
+
+  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)
+    create_checkout_request_resource_config = cls()
+
+    create_checkout_request_resource_config.additional_properties = d
+    return create_checkout_request_resource_config
+
+  @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