robosystems-client 0.1.9__py3-none-any.whl

robosystems_client/models/user_subscriptions_response.py

@@ -0,0 +1,90 @@
+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.subscription_info import SubscriptionInfo
+
+
+T = TypeVar("T", bound="UserSubscriptionsResponse")
+
+
+@_attrs_define
+class UserSubscriptionsResponse:
+  """Response for user subscriptions.
+
+  Attributes:
+      subscriptions (list['SubscriptionInfo']): List of user subscriptions
+      total_count (int): Total number of subscriptions
+      active_count (int): Number of active subscriptions
+  """
+
+  subscriptions: list["SubscriptionInfo"]
+  total_count: int
+  active_count: int
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    subscriptions = []
+    for subscriptions_item_data in self.subscriptions:
+      subscriptions_item = subscriptions_item_data.to_dict()
+      subscriptions.append(subscriptions_item)
+
+    total_count = self.total_count
+
+    active_count = self.active_count
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "subscriptions": subscriptions,
+        "total_count": total_count,
+        "active_count": active_count,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.subscription_info import SubscriptionInfo
+
+    d = dict(src_dict)
+    subscriptions = []
+    _subscriptions = d.pop("subscriptions")
+    for subscriptions_item_data in _subscriptions:
+      subscriptions_item = SubscriptionInfo.from_dict(subscriptions_item_data)
+
+      subscriptions.append(subscriptions_item)
+
+    total_count = d.pop("total_count")
+
+    active_count = d.pop("active_count")
+
+    user_subscriptions_response = cls(
+      subscriptions=subscriptions,
+      total_count=total_count,
+      active_count=active_count,
+    )
+
+    user_subscriptions_response.additional_properties = d
+    return user_subscriptions_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/user_usage_response.py

@@ -0,0 +1,90 @@
+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.user_limits_response import UserLimitsResponse
+  from ..models.user_usage_response_graphs import UserUsageResponseGraphs
+
+
+T = TypeVar("T", bound="UserUsageResponse")
+
+
+@_attrs_define
+class UserUsageResponse:
+  """Response model for user usage statistics.
+
+  Simplified to only show graph usage as UserLimits is now just a safety valve.
+  Other usage tracking (MCP, Agent calls) happens at the graph level.
+
+      Attributes:
+          user_id (str): User identifier
+          graphs (UserUsageResponseGraphs): Graph usage statistics (current/limit/remaining)
+          limits (UserLimitsResponse): Response model for user limits information.
+
+              UserLimits is now a simple safety valve to prevent runaway graph creation.
+              Subscription tiers and rate limits are handled at the graph level.
+  """
+
+  user_id: str
+  graphs: "UserUsageResponseGraphs"
+  limits: "UserLimitsResponse"
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    user_id = self.user_id
+
+    graphs = self.graphs.to_dict()
+
+    limits = self.limits.to_dict()
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "user_id": user_id,
+        "graphs": graphs,
+        "limits": limits,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.user_limits_response import UserLimitsResponse
+    from ..models.user_usage_response_graphs import UserUsageResponseGraphs
+
+    d = dict(src_dict)
+    user_id = d.pop("user_id")
+
+    graphs = UserUsageResponseGraphs.from_dict(d.pop("graphs"))
+
+    limits = UserLimitsResponse.from_dict(d.pop("limits"))
+
+    user_usage_response = cls(
+      user_id=user_id,
+      graphs=graphs,
+      limits=limits,
+    )
+
+    user_usage_response.additional_properties = d
+    return user_usage_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/user_usage_response_graphs.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="UserUsageResponseGraphs")
+
+
+@_attrs_define
+class UserUsageResponseGraphs:
+  """Graph usage statistics (current/limit/remaining)"""
+
+  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)
+    user_usage_response_graphs = cls()
+
+    user_usage_response_graphs.additional_properties = d
+    return user_usage_response_graphs
+
+  @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/user_usage_summary_response.py

@@ -0,0 +1,130 @@
+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.user_graph_summary import UserGraphSummary
+  from ..models.user_usage_summary_response_usage_vs_limits import (
+    UserUsageSummaryResponseUsageVsLimits,
+  )
+
+
+T = TypeVar("T", bound="UserUsageSummaryResponse")
+
+
+@_attrs_define
+class UserUsageSummaryResponse:
+  """Response model for user usage summary.
+
+  Attributes:
+      user_id (str): User identifier
+      graph_count (int): Number of accessible graphs
+      total_nodes (int): Total nodes across all graphs
+      total_relationships (int): Total relationships across all graphs
+      usage_vs_limits (UserUsageSummaryResponseUsageVsLimits): Usage compared to limits
+      graphs (list['UserGraphSummary']): Summary of each graph
+      timestamp (str): Summary generation timestamp
+  """
+
+  user_id: str
+  graph_count: int
+  total_nodes: int
+  total_relationships: int
+  usage_vs_limits: "UserUsageSummaryResponseUsageVsLimits"
+  graphs: list["UserGraphSummary"]
+  timestamp: str
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    user_id = self.user_id
+
+    graph_count = self.graph_count
+
+    total_nodes = self.total_nodes
+
+    total_relationships = self.total_relationships
+
+    usage_vs_limits = self.usage_vs_limits.to_dict()
+
+    graphs = []
+    for graphs_item_data in self.graphs:
+      graphs_item = graphs_item_data.to_dict()
+      graphs.append(graphs_item)
+
+    timestamp = self.timestamp
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "user_id": user_id,
+        "graph_count": graph_count,
+        "total_nodes": total_nodes,
+        "total_relationships": total_relationships,
+        "usage_vs_limits": usage_vs_limits,
+        "graphs": graphs,
+        "timestamp": timestamp,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.user_graph_summary import UserGraphSummary
+    from ..models.user_usage_summary_response_usage_vs_limits import (
+      UserUsageSummaryResponseUsageVsLimits,
+    )
+
+    d = dict(src_dict)
+    user_id = d.pop("user_id")
+
+    graph_count = d.pop("graph_count")
+
+    total_nodes = d.pop("total_nodes")
+
+    total_relationships = d.pop("total_relationships")
+
+    usage_vs_limits = UserUsageSummaryResponseUsageVsLimits.from_dict(
+      d.pop("usage_vs_limits")
+    )
+
+    graphs = []
+    _graphs = d.pop("graphs")
+    for graphs_item_data in _graphs:
+      graphs_item = UserGraphSummary.from_dict(graphs_item_data)
+
+      graphs.append(graphs_item)
+
+    timestamp = d.pop("timestamp")
+
+    user_usage_summary_response = cls(
+      user_id=user_id,
+      graph_count=graph_count,
+      total_nodes=total_nodes,
+      total_relationships=total_relationships,
+      usage_vs_limits=usage_vs_limits,
+      graphs=graphs,
+      timestamp=timestamp,
+    )
+
+    user_usage_summary_response.additional_properties = d
+    return user_usage_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/user_usage_summary_response_usage_vs_limits.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="UserUsageSummaryResponseUsageVsLimits")
+
+
+@_attrs_define
+class UserUsageSummaryResponseUsageVsLimits:
+  """Usage compared to limits"""
+
+  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)
+    user_usage_summary_response_usage_vs_limits = cls()
+
+    user_usage_summary_response_usage_vs_limits.additional_properties = d
+    return user_usage_summary_response_usage_vs_limits
+
+  @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/validation_error.py

@@ -0,0 +1,88 @@
+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
+
+T = TypeVar("T", bound="ValidationError")
+
+
+@_attrs_define
+class ValidationError:
+  """
+  Attributes:
+      loc (list[Union[int, str]]):
+      msg (str):
+      type_ (str):
+  """
+
+  loc: list[Union[int, str]]
+  msg: str
+  type_: str
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    loc = []
+    for loc_item_data in self.loc:
+      loc_item: Union[int, str]
+      loc_item = loc_item_data
+      loc.append(loc_item)
+
+    msg = self.msg
+
+    type_ = self.type_
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "loc": loc,
+        "msg": msg,
+        "type": type_,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    loc = []
+    _loc = d.pop("loc")
+    for loc_item_data in _loc:
+
+      def _parse_loc_item(data: object) -> Union[int, str]:
+        return cast(Union[int, str], data)
+
+      loc_item = _parse_loc_item(loc_item_data)
+
+      loc.append(loc_item)
+
+    msg = d.pop("msg")
+
+    type_ = d.pop("type")
+
+    validation_error = cls(
+      loc=loc,
+      msg=msg,
+      type_=type_,
+    )
+
+    validation_error.additional_properties = d
+    return validation_error
+
+  @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/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

robosystems_client/sdk-config.yaml

@@ -0,0 +1,5 @@
+class_name: RoboSystemsClient
+package_name: robosystems_client
+project_name: robosystems-sdk
+package_description: "Python SDK for RoboSystems financial graph database API"
+package_version: "0.1.0"

robosystems_client/types.py

@@ -0,0 +1,54 @@
+"""Contains some shared types for properties"""
+
+from collections.abc import Mapping, MutableMapping
+from http import HTTPStatus
+from typing import IO, BinaryIO, Generic, Literal, Optional, TypeVar, Union
+
+from attrs import define
+
+
+class Unset:
+  def __bool__(self) -> Literal[False]:
+    return False
+
+
+UNSET: Unset = Unset()
+
+# The types that `httpx.Client(files=)` can accept, copied from that library.
+FileContent = Union[IO[bytes], bytes, str]
+FileTypes = Union[
+  # (filename, file (or bytes), content_type)
+  tuple[Optional[str], FileContent, Optional[str]],
+  # (filename, file (or bytes), content_type, headers)
+  tuple[Optional[str], FileContent, Optional[str], Mapping[str, str]],
+]
+RequestFiles = list[tuple[str, FileTypes]]
+
+
+@define
+class File:
+  """Contains information for file uploads"""
+
+  payload: BinaryIO
+  file_name: Optional[str] = None
+  mime_type: Optional[str] = None
+
+  def to_tuple(self) -> FileTypes:
+    """Return a tuple representation that httpx will accept for multipart/form-data"""
+    return self.file_name, self.payload, self.mime_type
+
+
+T = TypeVar("T")
+
+
+@define
+class Response(Generic[T]):
+  """A response from an endpoint"""
+
+  status_code: HTTPStatus
+  content: bytes
+  headers: MutableMapping[str, str]
+  parsed: Optional[T]
+
+
+__all__ = ["UNSET", "File", "FileTypes", "RequestFiles", "Response", "Unset"]