robosystems-client 0.1.9__py3-none-any.whl

robosystems_client/models/create_graph_request.py

@@ -0,0 +1,183 @@
+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.custom_schema_definition import CustomSchemaDefinition
+  from ..models.graph_metadata import GraphMetadata
+  from ..models.initial_entity_data import InitialEntityData
+
+
+T = TypeVar("T", bound="CreateGraphRequest")
+
+
+@_attrs_define
+class CreateGraphRequest:
+  """Request model for creating a new graph.
+
+  Example:
+      {'initial_entity': {'cik': '0001234567', 'name': 'Acme Corp', 'uri': 'https://acme.com'}, 'instance_tier':
+          'standard', 'metadata': {'description': 'Main production graph', 'graph_name': 'Production System',
+          'schema_extensions': ['roboledger']}, 'tags': ['production', 'finance']}
+
+  Attributes:
+      metadata (GraphMetadata): Metadata for graph creation.
+      instance_tier (Union[Unset, str]): Instance tier: standard, enterprise, or premium Default: 'standard'.
+      custom_schema (Union['CustomSchemaDefinition', None, Unset]): Custom schema definition to apply
+      initial_entity (Union['InitialEntityData', None, Unset]): Optional initial entity to create in the graph. If
+          provided, creates a entity-focused graph.
+      tags (Union[None, Unset, list[str]]): Optional tags for organization
+  """
+
+  metadata: "GraphMetadata"
+  instance_tier: Union[Unset, str] = "standard"
+  custom_schema: Union["CustomSchemaDefinition", None, Unset] = UNSET
+  initial_entity: Union["InitialEntityData", None, Unset] = UNSET
+  tags: Union[None, Unset, list[str]] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    from ..models.custom_schema_definition import CustomSchemaDefinition
+    from ..models.initial_entity_data import InitialEntityData
+
+    metadata = self.metadata.to_dict()
+
+    instance_tier = self.instance_tier
+
+    custom_schema: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.custom_schema, Unset):
+      custom_schema = UNSET
+    elif isinstance(self.custom_schema, CustomSchemaDefinition):
+      custom_schema = self.custom_schema.to_dict()
+    else:
+      custom_schema = self.custom_schema
+
+    initial_entity: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.initial_entity, Unset):
+      initial_entity = UNSET
+    elif isinstance(self.initial_entity, InitialEntityData):
+      initial_entity = self.initial_entity.to_dict()
+    else:
+      initial_entity = self.initial_entity
+
+    tags: Union[None, Unset, list[str]]
+    if isinstance(self.tags, Unset):
+      tags = UNSET
+    elif isinstance(self.tags, list):
+      tags = self.tags
+
+    else:
+      tags = self.tags
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "metadata": metadata,
+      }
+    )
+    if instance_tier is not UNSET:
+      field_dict["instance_tier"] = instance_tier
+    if custom_schema is not UNSET:
+      field_dict["custom_schema"] = custom_schema
+    if initial_entity is not UNSET:
+      field_dict["initial_entity"] = initial_entity
+    if tags is not UNSET:
+      field_dict["tags"] = tags
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.custom_schema_definition import CustomSchemaDefinition
+    from ..models.graph_metadata import GraphMetadata
+    from ..models.initial_entity_data import InitialEntityData
+
+    d = dict(src_dict)
+    metadata = GraphMetadata.from_dict(d.pop("metadata"))
+
+    instance_tier = d.pop("instance_tier", UNSET)
+
+    def _parse_custom_schema(
+      data: object,
+    ) -> Union["CustomSchemaDefinition", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        custom_schema_type_0 = CustomSchemaDefinition.from_dict(data)
+
+        return custom_schema_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["CustomSchemaDefinition", None, Unset], data)
+
+    custom_schema = _parse_custom_schema(d.pop("custom_schema", UNSET))
+
+    def _parse_initial_entity(data: object) -> Union["InitialEntityData", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        initial_entity_type_0 = InitialEntityData.from_dict(data)
+
+        return initial_entity_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["InitialEntityData", None, Unset], data)
+
+    initial_entity = _parse_initial_entity(d.pop("initial_entity", UNSET))
+
+    def _parse_tags(data: object) -> Union[None, Unset, list[str]]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, list):
+          raise TypeError()
+        tags_type_0 = cast(list[str], data)
+
+        return tags_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union[None, Unset, list[str]], data)
+
+    tags = _parse_tags(d.pop("tags", UNSET))
+
+    create_graph_request = cls(
+      metadata=metadata,
+      instance_tier=instance_tier,
+      custom_schema=custom_schema,
+      initial_entity=initial_entity,
+      tags=tags,
+    )
+
+    create_graph_request.additional_properties = d
+    return create_graph_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/credit_check_request.py

@@ -0,0 +1,82 @@
+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="CreditCheckRequest")
+
+
+@_attrs_define
+class CreditCheckRequest:
+  """Request to check credit balance.
+
+  Attributes:
+      operation_type (str): Type of operation to check
+      base_cost (Union[None, Unset, float]): Custom base cost (uses default if not provided)
+  """
+
+  operation_type: str
+  base_cost: Union[None, Unset, float] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    operation_type = self.operation_type
+
+    base_cost: Union[None, Unset, float]
+    if isinstance(self.base_cost, Unset):
+      base_cost = UNSET
+    else:
+      base_cost = self.base_cost
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "operation_type": operation_type,
+      }
+    )
+    if base_cost is not UNSET:
+      field_dict["base_cost"] = base_cost
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    operation_type = d.pop("operation_type")
+
+    def _parse_base_cost(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)
+
+    base_cost = _parse_base_cost(d.pop("base_cost", UNSET))
+
+    credit_check_request = cls(
+      operation_type=operation_type,
+      base_cost=base_cost,
+    )
+
+    credit_check_request.additional_properties = d
+    return credit_check_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/credit_summary.py

@@ -0,0 +1,128 @@
+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="CreditSummary")
+
+
+@_attrs_define
+class CreditSummary:
+  """Credit balance 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[Unset, str]): Last allocation date (ISO format)
+      next_allocation_date (Union[Unset, str]): Next allocation date (ISO format)
+  """
+
+  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[Unset, str] = UNSET
+  next_allocation_date: Union[Unset, str] = UNSET
+  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
+
+    usage_percentage = self.usage_percentage
+
+    rollover_credits = self.rollover_credits
+
+    allows_rollover = self.allows_rollover
+
+    is_active = self.is_active
+
+    last_allocation_date = self.last_allocation_date
+
+    next_allocation_date = self.next_allocation_date
+
+    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,
+      }
+    )
+    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")
+
+    allows_rollover = d.pop("allows_rollover")
+
+    is_active = d.pop("is_active")
+
+    last_allocation_date = d.pop("last_allocation_date", UNSET)
+
+    next_allocation_date = d.pop("next_allocation_date", UNSET)
+
+    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,
+    )
+
+    credit_summary.additional_properties = d
+    return credit_summary
+
+  @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/credit_summary_response.py

@@ -0,0 +1,140 @@
+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="CreditSummaryResponse")
+
+
+@_attrs_define
+class CreditSummaryResponse:
+  """Credit summary response model.
+
+  Attributes:
+      graph_id (str):
+      graph_tier (str):
+      credit_multiplier (float):
+      current_balance (float):
+      monthly_allocation (float):
+      consumed_this_month (float):
+      transaction_count (int):
+      usage_percentage (float):
+      last_allocation_date (Union[None, Unset, str]):
+  """
+
+  graph_id: str
+  graph_tier: str
+  credit_multiplier: float
+  current_balance: float
+  monthly_allocation: float
+  consumed_this_month: float
+  transaction_count: int
+  usage_percentage: float
+  last_allocation_date: Union[None, Unset, str] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    graph_id = self.graph_id
+
+    graph_tier = self.graph_tier
+
+    credit_multiplier = self.credit_multiplier
+
+    current_balance = self.current_balance
+
+    monthly_allocation = self.monthly_allocation
+
+    consumed_this_month = self.consumed_this_month
+
+    transaction_count = self.transaction_count
+
+    usage_percentage = self.usage_percentage
+
+    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
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "graph_id": graph_id,
+        "graph_tier": graph_tier,
+        "credit_multiplier": credit_multiplier,
+        "current_balance": current_balance,
+        "monthly_allocation": monthly_allocation,
+        "consumed_this_month": consumed_this_month,
+        "transaction_count": transaction_count,
+        "usage_percentage": usage_percentage,
+      }
+    )
+    if last_allocation_date is not UNSET:
+      field_dict["last_allocation_date"] = last_allocation_date
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    graph_id = d.pop("graph_id")
+
+    graph_tier = d.pop("graph_tier")
+
+    credit_multiplier = d.pop("credit_multiplier")
+
+    current_balance = d.pop("current_balance")
+
+    monthly_allocation = d.pop("monthly_allocation")
+
+    consumed_this_month = d.pop("consumed_this_month")
+
+    transaction_count = d.pop("transaction_count")
+
+    usage_percentage = d.pop("usage_percentage")
+
+    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)
+
+    last_allocation_date = _parse_last_allocation_date(
+      d.pop("last_allocation_date", UNSET)
+    )
+
+    credit_summary_response = cls(
+      graph_id=graph_id,
+      graph_tier=graph_tier,
+      credit_multiplier=credit_multiplier,
+      current_balance=current_balance,
+      monthly_allocation=monthly_allocation,
+      consumed_this_month=consumed_this_month,
+      transaction_count=transaction_count,
+      usage_percentage=usage_percentage,
+      last_allocation_date=last_allocation_date,
+    )
+
+    credit_summary_response.additional_properties = d
+    return credit_summary_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/credits_summary_response.py

@@ -0,0 +1,122 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+  from ..models.add_on_credit_info import AddOnCreditInfo
+  from ..models.credits_summary_response_credits_by_addon_item import (
+    CreditsSummaryResponseCreditsByAddonItem,
+  )
+
+
+T = TypeVar("T", bound="CreditsSummaryResponse")
+
+
+@_attrs_define
+class CreditsSummaryResponse:
+  """Response for credits summary.
+
+  Attributes:
+      add_ons (list['AddOnCreditInfo']): Credits breakdown by add-on
+      total_credits (float): Total credits remaining across all subscriptions
+      addon_count (int): Number of active add-ons
+      credits_by_addon (Union[Unset, list['CreditsSummaryResponseCreditsByAddonItem']]): Legacy field - Credits
+          breakdown by add-on
+  """
+
+  add_ons: list["AddOnCreditInfo"]
+  total_credits: float
+  addon_count: int
+  credits_by_addon: Union[Unset, list["CreditsSummaryResponseCreditsByAddonItem"]] = (
+    UNSET
+  )
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    add_ons = []
+    for add_ons_item_data in self.add_ons:
+      add_ons_item = add_ons_item_data.to_dict()
+      add_ons.append(add_ons_item)
+
+    total_credits = self.total_credits
+
+    addon_count = self.addon_count
+
+    credits_by_addon: Union[Unset, list[dict[str, Any]]] = UNSET
+    if not isinstance(self.credits_by_addon, Unset):
+      credits_by_addon = []
+      for credits_by_addon_item_data in self.credits_by_addon:
+        credits_by_addon_item = credits_by_addon_item_data.to_dict()
+        credits_by_addon.append(credits_by_addon_item)
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "add_ons": add_ons,
+        "total_credits": total_credits,
+        "addon_count": addon_count,
+      }
+    )
+    if credits_by_addon is not UNSET:
+      field_dict["credits_by_addon"] = credits_by_addon
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.add_on_credit_info import AddOnCreditInfo
+    from ..models.credits_summary_response_credits_by_addon_item import (
+      CreditsSummaryResponseCreditsByAddonItem,
+    )
+
+    d = dict(src_dict)
+    add_ons = []
+    _add_ons = d.pop("add_ons")
+    for add_ons_item_data in _add_ons:
+      add_ons_item = AddOnCreditInfo.from_dict(add_ons_item_data)
+
+      add_ons.append(add_ons_item)
+
+    total_credits = d.pop("total_credits")
+
+    addon_count = d.pop("addon_count")
+
+    credits_by_addon = []
+    _credits_by_addon = d.pop("credits_by_addon", UNSET)
+    for credits_by_addon_item_data in _credits_by_addon or []:
+      credits_by_addon_item = CreditsSummaryResponseCreditsByAddonItem.from_dict(
+        credits_by_addon_item_data
+      )
+
+      credits_by_addon.append(credits_by_addon_item)
+
+    credits_summary_response = cls(
+      add_ons=add_ons,
+      total_credits=total_credits,
+      addon_count=addon_count,
+      credits_by_addon=credits_by_addon,
+    )
+
+    credits_summary_response.additional_properties = d
+    return credits_summary_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/credits_summary_response_credits_by_addon_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="CreditsSummaryResponseCreditsByAddonItem")
+
+
+@_attrs_define
+class CreditsSummaryResponseCreditsByAddonItem:
+  """ """
+
+  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)
+    credits_summary_response_credits_by_addon_item = cls()
+
+    credits_summary_response_credits_by_addon_item.additional_properties = d
+    return credits_summary_response_credits_by_addon_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