robosystems-client 0.1.9__py3-none-any.whl

robosystems_client/models/agent_request.py

@@ -0,0 +1,132 @@
+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.agent_message import AgentMessage
+  from ..models.agent_request_context_type_0 import AgentRequestContextType0
+
+
+T = TypeVar("T", bound="AgentRequest")
+
+
+@_attrs_define
+class AgentRequest:
+  """Request model for financial agent interactions.
+
+  Attributes:
+      message (str): Financial analysis query
+      history (Union[Unset, list['AgentMessage']]): Conversation history
+      context (Union['AgentRequestContextType0', None, Unset]): Additional context for analysis (e.g., include_schema,
+          limit_results)
+      force_extended_analysis (Union[Unset, bool]): Force extended analysis mode with comprehensive research (like
+          Claude Desktop's deep research) Default: False.
+  """
+
+  message: str
+  history: Union[Unset, list["AgentMessage"]] = UNSET
+  context: Union["AgentRequestContextType0", None, Unset] = UNSET
+  force_extended_analysis: Union[Unset, bool] = False
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    from ..models.agent_request_context_type_0 import AgentRequestContextType0
+
+    message = self.message
+
+    history: Union[Unset, list[dict[str, Any]]] = UNSET
+    if not isinstance(self.history, Unset):
+      history = []
+      for history_item_data in self.history:
+        history_item = history_item_data.to_dict()
+        history.append(history_item)
+
+    context: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.context, Unset):
+      context = UNSET
+    elif isinstance(self.context, AgentRequestContextType0):
+      context = self.context.to_dict()
+    else:
+      context = self.context
+
+    force_extended_analysis = self.force_extended_analysis
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "message": message,
+      }
+    )
+    if history is not UNSET:
+      field_dict["history"] = history
+    if context is not UNSET:
+      field_dict["context"] = context
+    if force_extended_analysis is not UNSET:
+      field_dict["force_extended_analysis"] = force_extended_analysis
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.agent_message import AgentMessage
+    from ..models.agent_request_context_type_0 import AgentRequestContextType0
+
+    d = dict(src_dict)
+    message = d.pop("message")
+
+    history = []
+    _history = d.pop("history", UNSET)
+    for history_item_data in _history or []:
+      history_item = AgentMessage.from_dict(history_item_data)
+
+      history.append(history_item)
+
+    def _parse_context(data: object) -> Union["AgentRequestContextType0", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        context_type_0 = AgentRequestContextType0.from_dict(data)
+
+        return context_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["AgentRequestContextType0", None, Unset], data)
+
+    context = _parse_context(d.pop("context", UNSET))
+
+    force_extended_analysis = d.pop("force_extended_analysis", UNSET)
+
+    agent_request = cls(
+      message=message,
+      history=history,
+      context=context,
+      force_extended_analysis=force_extended_analysis,
+    )
+
+    agent_request.additional_properties = d
+    return 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/agent_request_context_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="AgentRequestContextType0")
+
+
+@_attrs_define
+class AgentRequestContextType0:
+  """ """
+
+  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_request_context_type_0 = cls()
+
+    agent_request_context_type_0.additional_properties = d
+    return agent_request_context_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.py

@@ -0,0 +1,132 @@
+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.agent_response_metadata_type_0 import AgentResponseMetadataType0
+
+
+T = TypeVar("T", bound="AgentResponse")
+
+
+@_attrs_define
+class AgentResponse:
+  """Response model for financial agent interactions.
+
+  Attributes:
+      response (str): Financial analysis response
+      metadata (Union['AgentResponseMetadataType0', None, Unset]): Analysis metadata (e.g., analysis_type, graph_id)
+      operation_id (Union[None, Unset, str]): SSE operation ID for monitoring extended analysis via
+          /v1/operations/{operation_id}/stream
+      is_partial (Union[Unset, bool]): Whether this is a partial response with more analysis coming Default: False.
+  """
+
+  response: str
+  metadata: Union["AgentResponseMetadataType0", None, Unset] = UNSET
+  operation_id: Union[None, Unset, str] = UNSET
+  is_partial: Union[Unset, bool] = False
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    from ..models.agent_response_metadata_type_0 import AgentResponseMetadataType0
+
+    response = self.response
+
+    metadata: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.metadata, Unset):
+      metadata = UNSET
+    elif isinstance(self.metadata, AgentResponseMetadataType0):
+      metadata = self.metadata.to_dict()
+    else:
+      metadata = self.metadata
+
+    operation_id: Union[None, Unset, str]
+    if isinstance(self.operation_id, Unset):
+      operation_id = UNSET
+    else:
+      operation_id = self.operation_id
+
+    is_partial = self.is_partial
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "response": response,
+      }
+    )
+    if metadata is not UNSET:
+      field_dict["metadata"] = metadata
+    if operation_id is not UNSET:
+      field_dict["operation_id"] = operation_id
+    if is_partial is not UNSET:
+      field_dict["is_partial"] = is_partial
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.agent_response_metadata_type_0 import AgentResponseMetadataType0
+
+    d = dict(src_dict)
+    response = d.pop("response")
+
+    def _parse_metadata(
+      data: object,
+    ) -> Union["AgentResponseMetadataType0", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        metadata_type_0 = AgentResponseMetadataType0.from_dict(data)
+
+        return metadata_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["AgentResponseMetadataType0", None, Unset], data)
+
+    metadata = _parse_metadata(d.pop("metadata", 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))
+
+    is_partial = d.pop("is_partial", UNSET)
+
+    agent_response = cls(
+      response=response,
+      metadata=metadata,
+      operation_id=operation_id,
+      is_partial=is_partial,
+    )
+
+    agent_response.additional_properties = d
+    return 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/agent_response_metadata_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="AgentResponseMetadataType0")
+
+
+@_attrs_define
+class AgentResponseMetadataType0:
+  """ """
+
+  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_metadata_type_0 = cls()
+
+    agent_response_metadata_type_0.additional_properties = d
+    return agent_response_metadata_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/api_key_info.py

@@ -0,0 +1,134 @@
+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="APIKeyInfo")
+
+
+@_attrs_define
+class APIKeyInfo:
+  """API key information response model.
+
+  Attributes:
+      id (str): API key ID
+      name (str): API key name
+      prefix (str): API key prefix for identification
+      is_active (bool): Whether the key is active
+      created_at (str): Creation timestamp
+      description (Union[None, Unset, str]): API key description
+      last_used_at (Union[None, Unset, str]): Last used timestamp
+  """
+
+  id: str
+  name: str
+  prefix: str
+  is_active: bool
+  created_at: str
+  description: Union[None, Unset, str] = UNSET
+  last_used_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
+
+    name = self.name
+
+    prefix = self.prefix
+
+    is_active = self.is_active
+
+    created_at = self.created_at
+
+    description: Union[None, Unset, str]
+    if isinstance(self.description, Unset):
+      description = UNSET
+    else:
+      description = self.description
+
+    last_used_at: Union[None, Unset, str]
+    if isinstance(self.last_used_at, Unset):
+      last_used_at = UNSET
+    else:
+      last_used_at = self.last_used_at
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "id": id,
+        "name": name,
+        "prefix": prefix,
+        "is_active": is_active,
+        "created_at": created_at,
+      }
+    )
+    if description is not UNSET:
+      field_dict["description"] = description
+    if last_used_at is not UNSET:
+      field_dict["last_used_at"] = last_used_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")
+
+    name = d.pop("name")
+
+    prefix = d.pop("prefix")
+
+    is_active = d.pop("is_active")
+
+    created_at = d.pop("created_at")
+
+    def _parse_description(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)
+
+    description = _parse_description(d.pop("description", UNSET))
+
+    def _parse_last_used_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)
+
+    last_used_at = _parse_last_used_at(d.pop("last_used_at", UNSET))
+
+    api_key_info = cls(
+      id=id,
+      name=name,
+      prefix=prefix,
+      is_active=is_active,
+      created_at=created_at,
+      description=description,
+      last_used_at=last_used_at,
+    )
+
+    api_key_info.additional_properties = d
+    return api_key_info
+
+  @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/api_keys_response.py

@@ -0,0 +1,74 @@
+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.api_key_info import APIKeyInfo
+
+
+T = TypeVar("T", bound="APIKeysResponse")
+
+
+@_attrs_define
+class APIKeysResponse:
+  """Response model for listing API keys.
+
+  Attributes:
+      api_keys (list['APIKeyInfo']): List of user's API keys
+  """
+
+  api_keys: list["APIKeyInfo"]
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    api_keys = []
+    for api_keys_item_data in self.api_keys:
+      api_keys_item = api_keys_item_data.to_dict()
+      api_keys.append(api_keys_item)
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "api_keys": api_keys,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.api_key_info import APIKeyInfo
+
+    d = dict(src_dict)
+    api_keys = []
+    _api_keys = d.pop("api_keys")
+    for api_keys_item_data in _api_keys:
+      api_keys_item = APIKeyInfo.from_dict(api_keys_item_data)
+
+      api_keys.append(api_keys_item)
+
+    api_keys_response = cls(
+      api_keys=api_keys,
+    )
+
+    api_keys_response.additional_properties = d
+    return api_keys_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/auth_response.py

@@ -0,0 +1,82 @@
+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.auth_response_user import AuthResponseUser
+
+
+T = TypeVar("T", bound="AuthResponse")
+
+
+@_attrs_define
+class AuthResponse:
+  """Authentication response model.
+
+  Attributes:
+      user (AuthResponseUser): User information
+      message (str): Success message
+      token (str): JWT authentication token
+  """
+
+  user: "AuthResponseUser"
+  message: str
+  token: str
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    user = self.user.to_dict()
+
+    message = self.message
+
+    token = self.token
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "user": user,
+        "message": message,
+        "token": token,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.auth_response_user import AuthResponseUser
+
+    d = dict(src_dict)
+    user = AuthResponseUser.from_dict(d.pop("user"))
+
+    message = d.pop("message")
+
+    token = d.pop("token")
+
+    auth_response = cls(
+      user=user,
+      message=message,
+      token=token,
+    )
+
+    auth_response.additional_properties = d
+    return auth_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/auth_response_user.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="AuthResponseUser")
+
+
+@_attrs_define
+class AuthResponseUser:
+  """User information"""
+
+  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)
+    auth_response_user = cls()
+
+    auth_response_user.additional_properties = d
+    return auth_response_user
+
+  @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