robosystems-client 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

robosystems_client/models/agent_response_error_details_type_0.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="AgentResponseErrorDetailsType0")
+
+
+@_attrs_define
+class AgentResponseErrorDetailsType0:
+  """ """
+
+  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)
+    agent_response_error_details_type_0 = cls()
+
+    agent_response_error_details_type_0.additional_properties = d
+    return agent_response_error_details_type_0
+
+  @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/agent_response_tokens_used_type_0.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="AgentResponseTokensUsedType0")
+
+
+@_attrs_define
+class AgentResponseTokensUsedType0:
+  """ """
+
+  additional_properties: dict[str, int] = _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)
+    agent_response_tokens_used_type_0 = cls()
+
+    agent_response_tokens_used_type_0.additional_properties = d
+    return agent_response_tokens_used_type_0
+
+  @property
+  def additional_keys(self) -> list[str]:
+    return list(self.additional_properties.keys())
+
+  def __getitem__(self, key: str) -> int:
+    return self.additional_properties[key]
+
+  def __setitem__(self, key: str, value: int) -> 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/auth_response.py

@@ -1,9 +1,11 @@
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any, TypeVar
+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.auth_response_user import AuthResponseUser
 
@@ -18,12 +20,12 @@ class AuthResponse:
   Attributes:
       user (AuthResponseUser): User information
       message (str): Success message
-      token (str): JWT authentication token
+      token (Union[None, Unset, str]): JWT authentication token (optional for cookie-based auth)
   """
 
   user: "AuthResponseUser"
   message: str
-  token: str
+  token: Union[None, Unset, str] = UNSET
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
@@ -31,7 +33,11 @@ class AuthResponse:
 
     message = self.message
 
-    token = self.token
+    token: Union[None, Unset, str]
+    if isinstance(self.token, Unset):
+      token = UNSET
+    else:
+      token = self.token
 
     field_dict: dict[str, Any] = {}
     field_dict.update(self.additional_properties)
@@ -39,9 +45,10 @@ class AuthResponse:
       {
         "user": user,
         "message": message,
-        "token": token,
       }
     )
+    if token is not UNSET:
+      field_dict["token"] = token
 
     return field_dict
 
@@ -54,7 +61,14 @@ class AuthResponse:
 
     message = d.pop("message")
 
-    token = d.pop("token")
+    def _parse_token(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)
+
+    token = _parse_token(d.pop("token", UNSET))
 
     auth_response = cls(
       user=user,

robosystems_client/models/batch_agent_request.py

@@ -0,0 +1,85 @@
+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.agent_request import AgentRequest
+
+
+T = TypeVar("T", bound="BatchAgentRequest")
+
+
+@_attrs_define
+class BatchAgentRequest:
+  """Request for batch processing multiple queries.
+
+  Attributes:
+      queries (list['AgentRequest']): List of queries to process
+      parallel (Union[Unset, bool]): Process queries in parallel Default: False.
+  """
+
+  queries: list["AgentRequest"]
+  parallel: Union[Unset, bool] = False
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    queries = []
+    for queries_item_data in self.queries:
+      queries_item = queries_item_data.to_dict()
+      queries.append(queries_item)
+
+    parallel = self.parallel
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "queries": queries,
+      }
+    )
+    if parallel is not UNSET:
+      field_dict["parallel"] = parallel
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.agent_request import AgentRequest
+
+    d = dict(src_dict)
+    queries = []
+    _queries = d.pop("queries")
+    for queries_item_data in _queries:
+      queries_item = AgentRequest.from_dict(queries_item_data)
+
+      queries.append(queries_item)
+
+    parallel = d.pop("parallel", UNSET)
+
+    batch_agent_request = cls(
+      queries=queries,
+      parallel=parallel,
+    )
+
+    batch_agent_request.additional_properties = d
+    return batch_agent_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/batch_agent_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.agent_response import AgentResponse
+
+
+T = TypeVar("T", bound="BatchAgentResponse")
+
+
+@_attrs_define
+class BatchAgentResponse:
+  """Response for batch processing.
+
+  Attributes:
+      results (list['AgentResponse']): List of agent responses
+      total_execution_time (float): Total execution time
+      parallel_processed (bool): Whether queries were processed in parallel
+  """
+
+  results: list["AgentResponse"]
+  total_execution_time: float
+  parallel_processed: bool
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    results = []
+    for results_item_data in self.results:
+      results_item = results_item_data.to_dict()
+      results.append(results_item)
+
+    total_execution_time = self.total_execution_time
+
+    parallel_processed = self.parallel_processed
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "results": results,
+        "total_execution_time": total_execution_time,
+        "parallel_processed": parallel_processed,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.agent_response import AgentResponse
+
+    d = dict(src_dict)
+    results = []
+    _results = d.pop("results")
+    for results_item_data in _results:
+      results_item = AgentResponse.from_dict(results_item_data)
+
+      results.append(results_item)
+
+    total_execution_time = d.pop("total_execution_time")
+
+    parallel_processed = d.pop("parallel_processed")
+
+    batch_agent_response = cls(
+      results=results,
+      total_execution_time=total_execution_time,
+      parallel_processed=parallel_processed,
+    )
+
+    batch_agent_response.additional_properties = d
+    return batch_agent_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/credit_summary.py

@@ -1,5 +1,5 @@
 from collections.abc import Mapping
-from typing import Any, TypeVar, Union
+from typing import Any, TypeVar, Union, cast
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -21,8 +21,8 @@ class CreditSummary:
       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)
+      last_allocation_date (Union[None, Unset, str]): Last allocation date (ISO format)
+      next_allocation_date (Union[None, Unset, str]): Next allocation date (ISO format)
   """
 
   current_balance: float
@@ -32,8 +32,8 @@ class CreditSummary:
   rollover_credits: float
   allows_rollover: bool
   is_active: bool
-  last_allocation_date: Union[Unset, str] = UNSET
-  next_allocation_date: Union[Unset, str] = UNSET
+  last_allocation_date: Union[None, Unset, str] = UNSET
+  next_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]:
@@ -51,9 +51,17 @@ class CreditSummary:
 
     is_active = self.is_active
 
-    last_allocation_date = self.last_allocation_date
+    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
 
-    next_allocation_date = self.next_allocation_date
+    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
 
     field_dict: dict[str, Any] = {}
     field_dict.update(self.additional_properties)
@@ -92,9 +100,27 @@ class CreditSummary:
 
     is_active = d.pop("is_active")
 
-    last_allocation_date = d.pop("last_allocation_date", UNSET)
+    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)
 
-    next_allocation_date = d.pop("next_allocation_date", UNSET)
+    last_allocation_date = _parse_last_allocation_date(
+      d.pop("last_allocation_date", UNSET)
+    )
+
+    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)
+
+    next_allocation_date = _parse_next_allocation_date(
+      d.pop("next_allocation_date", UNSET)
+    )
 
     credit_summary = cls(
       current_balance=current_balance,

robosystems_client/models/credits_summary_response.py

@@ -1,5 +1,5 @@
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any, TypeVar, Union
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -8,8 +8,8 @@ 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,
+  from ..models.credits_summary_response_credits_by_addon_type_0_item import (
+    CreditsSummaryResponseCreditsByAddonType0Item,
   )
 
 
@@ -24,16 +24,16 @@ class CreditsSummaryResponse:
       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
+      credits_by_addon (Union[None, Unset, list['CreditsSummaryResponseCreditsByAddonType0Item']]): 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
-  )
+  credits_by_addon: Union[
+    None, Unset, list["CreditsSummaryResponseCreditsByAddonType0Item"]
+  ] = UNSET
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
@@ -46,12 +46,17 @@ class CreditsSummaryResponse:
 
     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: Union[None, Unset, list[dict[str, Any]]]
+    if isinstance(self.credits_by_addon, Unset):
+      credits_by_addon = UNSET
+    elif isinstance(self.credits_by_addon, list):
       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)
+      for credits_by_addon_type_0_item_data in self.credits_by_addon:
+        credits_by_addon_type_0_item = credits_by_addon_type_0_item_data.to_dict()
+        credits_by_addon.append(credits_by_addon_type_0_item)
+
+    else:
+      credits_by_addon = self.credits_by_addon
 
     field_dict: dict[str, Any] = {}
     field_dict.update(self.additional_properties)
@@ -70,8 +75,8 @@ class CreditsSummaryResponse:
   @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,
+    from ..models.credits_summary_response_credits_by_addon_type_0_item import (
+      CreditsSummaryResponseCreditsByAddonType0Item,
     )
 
     d = dict(src_dict)
@@ -86,14 +91,35 @@ class CreditsSummaryResponse:
 
     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
+    def _parse_credits_by_addon(
+      data: object,
+    ) -> Union[None, Unset, list["CreditsSummaryResponseCreditsByAddonType0Item"]]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, list):
+          raise TypeError()
+        credits_by_addon_type_0 = []
+        _credits_by_addon_type_0 = data
+        for credits_by_addon_type_0_item_data in _credits_by_addon_type_0:
+          credits_by_addon_type_0_item = (
+            CreditsSummaryResponseCreditsByAddonType0Item.from_dict(
+              credits_by_addon_type_0_item_data
+            )
+          )
+
+          credits_by_addon_type_0.append(credits_by_addon_type_0_item)
+
+        return credits_by_addon_type_0
+      except:  # noqa: E722
+        pass
+      return cast(
+        Union[None, Unset, list["CreditsSummaryResponseCreditsByAddonType0Item"]], data
       )
 
-      credits_by_addon.append(credits_by_addon_item)
+    credits_by_addon = _parse_credits_by_addon(d.pop("credits_by_addon", UNSET))
 
     credits_summary_response = cls(
       add_ons=add_ons,

robosystems_client/models/credits_summary_response_credits_by_addon_type_0_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="CreditsSummaryResponseCreditsByAddonType0Item")
+
+
+@_attrs_define
+class CreditsSummaryResponseCreditsByAddonType0Item:
+  """ """
+
+  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_type_0_item = cls()
+
+    credits_summary_response_credits_by_addon_type_0_item.additional_properties = d
+    return credits_summary_response_credits_by_addon_type_0_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

robosystems_client/models/custom_schema_definition.py

@@ -21,23 +21,16 @@ T = TypeVar("T", bound="CustomSchemaDefinition")
 
 @_attrs_define
 class CustomSchemaDefinition:
-  """Custom schema definition for user-defined graphs.
+  """Custom schema definition for custom graphs.
 
   Attributes:
-      name (str): Schema name Example: inventory_management.
-      version (Union[Unset, str]): Schema version Default: '1.0.0'. Example: 1.0.0.
-      description (Union[None, Unset, str]): Schema description Example: Inventory management system schema.
-      extends (Union[None, Unset, str]): Base schema to extend (e.g., 'base') Example: base.
-      nodes (Union[Unset, list['CustomSchemaDefinitionNodesItem']]): List of node definitions with properties Example:
-          [{'name': 'Product', 'properties': [{'name': 'sku', 'type': 'STRING', 'is_primary_key': True}, {'name': 'name',
-          'type': 'STRING', 'is_required': True}, {'name': 'price', 'type': 'DOUBLE'}, {'name': 'quantity', 'type':
-          'INT64'}]}, {'name': 'Warehouse', 'properties': [{'name': 'identifier', 'type': 'STRING', 'is_primary_key':
-          True}, {'name': 'location', 'type': 'STRING'}]}].
+      name (str): Schema name
+      version (Union[Unset, str]): Schema version Default: '1.0.0'.
+      description (Union[None, Unset, str]): Schema description
+      extends (Union[None, Unset, str]): Base schema to extend (e.g., 'base')
+      nodes (Union[Unset, list['CustomSchemaDefinitionNodesItem']]): List of node definitions with properties
       relationships (Union[Unset, list['CustomSchemaDefinitionRelationshipsItem']]): List of relationship definitions
-          Example: [{'from_node': 'Product', 'name': 'STORED_IN', 'properties': [{'name': 'since', 'type': 'DATE'}],
-          'to_node': 'Warehouse'}].
-      metadata (Union[Unset, CustomSchemaDefinitionMetadata]): Additional schema metadata Example: {'created_by':
-          'inventory_team', 'industry': 'retail'}.
+      metadata (Union[Unset, CustomSchemaDefinitionMetadata]): Additional schema metadata
   """
 
   name: str

robosystems_client/models/custom_schema_definition_metadata.py

@@ -9,12 +9,7 @@ T = TypeVar("T", bound="CustomSchemaDefinitionMetadata")
 
 @_attrs_define
 class CustomSchemaDefinitionMetadata:
-  """Additional schema metadata
-
-  Example:
-      {'created_by': 'inventory_team', 'industry': 'retail'}
-
-  """
+  """Additional schema metadata"""
 
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 

robosystems_client/models/database_health_response.py

@@ -14,17 +14,17 @@ class DatabaseHealthResponse:
   """Response model for database health check.
 
   Attributes:
-      graph_id (str): Graph database identifier Example: kg1a2b3c4d5.
-      status (str): Overall health status Example: healthy.
-      connection_status (str): Database connection status Example: connected.
-      uptime_seconds (float): Database uptime in seconds Example: 3600.5.
-      query_count_24h (int): Number of queries executed in last 24 hours Example: 150.
-      avg_query_time_ms (float): Average query execution time in milliseconds Example: 45.2.
-      error_rate_24h (float): Error rate in last 24 hours (percentage) Example: 0.5.
-      last_query_time (Union[None, Unset, str]): Timestamp of last query execution Example: 2024-01-15T10:30:00Z.
-      memory_usage_mb (Union[None, Unset, float]): Memory usage in MB Example: 512.3.
-      storage_usage_mb (Union[None, Unset, float]): Storage usage in MB Example: 1024.7.
-      alerts (Union[Unset, list[str]]): Active alerts or warnings Example: ['High memory usage detected'].
+      graph_id (str): Graph database identifier
+      status (str): Overall health status
+      connection_status (str): Database connection status
+      uptime_seconds (float): Database uptime in seconds
+      query_count_24h (int): Number of queries executed in last 24 hours
+      avg_query_time_ms (float): Average query execution time in milliseconds
+      error_rate_24h (float): Error rate in last 24 hours (percentage)
+      last_query_time (Union[None, Unset, str]): Timestamp of last query execution
+      memory_usage_mb (Union[None, Unset, float]): Memory usage in MB
+      storage_usage_mb (Union[None, Unset, float]): Storage usage in MB
+      alerts (Union[Unset, list[str]]): Active alerts or warnings
   """
 
   graph_id: str