robosystems-client 0.1.9__py3-none-any.whl

robosystems_client/models/schema_validation_response_compatibility_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="SchemaValidationResponseCompatibilityType0")
+
+
+@_attrs_define
+class SchemaValidationResponseCompatibilityType0:
+  """ """
+
+  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)
+    schema_validation_response_compatibility_type_0 = cls()
+
+    schema_validation_response_compatibility_type_0.additional_properties = d
+    return schema_validation_response_compatibility_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/schema_validation_response_stats_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="SchemaValidationResponseStatsType0")
+
+
+@_attrs_define
+class SchemaValidationResponseStatsType0:
+  """ """
+
+  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)
+    schema_validation_response_stats_type_0 = cls()
+
+    schema_validation_response_stats_type_0.additional_properties = d
+    return schema_validation_response_stats_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/sec_connection_config.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="SECConnectionConfig")
+
+
+@_attrs_define
+class SECConnectionConfig:
+  """SEC-specific connection configuration.
+
+  Attributes:
+      cik (str): 10-digit CIK number
+      entity_name (Union[None, Unset, str]): Entity name from SEC
+  """
+
+  cik: str
+  entity_name: Union[None, Unset, str] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    cik = self.cik
+
+    entity_name: Union[None, Unset, str]
+    if isinstance(self.entity_name, Unset):
+      entity_name = UNSET
+    else:
+      entity_name = self.entity_name
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "cik": cik,
+      }
+    )
+    if entity_name is not UNSET:
+      field_dict["entity_name"] = entity_name
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    cik = d.pop("cik")
+
+    def _parse_entity_name(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)
+
+    entity_name = _parse_entity_name(d.pop("entity_name", UNSET))
+
+    sec_connection_config = cls(
+      cik=cik,
+      entity_name=entity_name,
+    )
+
+    sec_connection_config.additional_properties = d
+    return sec_connection_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

robosystems_client/models/sso_complete_request.py

@@ -0,0 +1,60 @@
+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="SSOCompleteRequest")
+
+
+@_attrs_define
+class SSOCompleteRequest:
+  """SSO completion request model.
+
+  Attributes:
+      session_id (str): Temporary session ID from secure handoff
+  """
+
+  session_id: str
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    session_id = self.session_id
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "session_id": session_id,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    session_id = d.pop("session_id")
+
+    sso_complete_request = cls(
+      session_id=session_id,
+    )
+
+    sso_complete_request.additional_properties = d
+    return sso_complete_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/sso_exchange_request.py

@@ -0,0 +1,90 @@
+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="SSOExchangeRequest")
+
+
+@_attrs_define
+class SSOExchangeRequest:
+  """SSO token exchange request model.
+
+  Attributes:
+      token (str): Temporary SSO token
+      target_app (str): Target application identifier
+      return_url (Union[None, Unset, str]): Optional return URL after authentication
+  """
+
+  token: str
+  target_app: str
+  return_url: Union[None, Unset, str] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    token = self.token
+
+    target_app = self.target_app
+
+    return_url: Union[None, Unset, str]
+    if isinstance(self.return_url, Unset):
+      return_url = UNSET
+    else:
+      return_url = self.return_url
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "token": token,
+        "target_app": target_app,
+      }
+    )
+    if return_url is not UNSET:
+      field_dict["return_url"] = return_url
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    token = d.pop("token")
+
+    target_app = d.pop("target_app")
+
+    def _parse_return_url(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)
+
+    return_url = _parse_return_url(d.pop("return_url", UNSET))
+
+    sso_exchange_request = cls(
+      token=token,
+      target_app=target_app,
+      return_url=return_url,
+    )
+
+    sso_exchange_request.additional_properties = d
+    return sso_exchange_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/sso_exchange_response.py

@@ -0,0 +1,78 @@
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+T = TypeVar("T", bound="SSOExchangeResponse")
+
+
+@_attrs_define
+class SSOExchangeResponse:
+  """SSO token exchange response model.
+
+  Attributes:
+      session_id (str): Temporary session ID for secure handoff
+      redirect_url (str): URL to redirect to for authentication
+      expires_at (datetime.datetime): Session expiration time
+  """
+
+  session_id: str
+  redirect_url: str
+  expires_at: datetime.datetime
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    session_id = self.session_id
+
+    redirect_url = self.redirect_url
+
+    expires_at = self.expires_at.isoformat()
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "session_id": session_id,
+        "redirect_url": redirect_url,
+        "expires_at": expires_at,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    session_id = d.pop("session_id")
+
+    redirect_url = d.pop("redirect_url")
+
+    expires_at = isoparse(d.pop("expires_at"))
+
+    sso_exchange_response = cls(
+      session_id=session_id,
+      redirect_url=redirect_url,
+      expires_at=expires_at,
+    )
+
+    sso_exchange_response.additional_properties = d
+    return sso_exchange_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/sso_login_request.py

@@ -0,0 +1,60 @@
+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="SSOLoginRequest")
+
+
+@_attrs_define
+class SSOLoginRequest:
+  """SSO login request model.
+
+  Attributes:
+      token (str): Temporary SSO token
+  """
+
+  token: str
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    token = self.token
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "token": token,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    token = d.pop("token")
+
+    sso_login_request = cls(
+      token=token,
+    )
+
+    sso_login_request.additional_properties = d
+    return sso_login_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/sso_token_response.py

@@ -0,0 +1,78 @@
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+T = TypeVar("T", bound="SSOTokenResponse")
+
+
+@_attrs_define
+class SSOTokenResponse:
+  """SSO token response model.
+
+  Attributes:
+      token (str): Temporary SSO token for cross-app authentication
+      expires_at (datetime.datetime): Token expiration time
+      apps (list[str]): Available apps for this user
+  """
+
+  token: str
+  expires_at: datetime.datetime
+  apps: list[str]
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    token = self.token
+
+    expires_at = self.expires_at.isoformat()
+
+    apps = self.apps
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "token": token,
+        "expires_at": expires_at,
+        "apps": apps,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    token = d.pop("token")
+
+    expires_at = isoparse(d.pop("expires_at"))
+
+    apps = cast(list[str], d.pop("apps"))
+
+    sso_token_response = cls(
+      token=token,
+      expires_at=expires_at,
+      apps=apps,
+    )
+
+    sso_token_response.additional_properties = d
+    return sso_token_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/storage_limit_response.py

@@ -0,0 +1,149 @@
+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="StorageLimitResponse")
+
+
+@_attrs_define
+class StorageLimitResponse:
+  """Storage limit information response.
+
+  Attributes:
+      graph_id (str):
+      current_storage_gb (float):
+      effective_limit_gb (float):
+      usage_percentage (float):
+      within_limit (bool):
+      approaching_limit (bool):
+      needs_warning (bool):
+      has_override (bool):
+      recommendations (Union[None, Unset, list[str]]):
+  """
+
+  graph_id: str
+  current_storage_gb: float
+  effective_limit_gb: float
+  usage_percentage: float
+  within_limit: bool
+  approaching_limit: bool
+  needs_warning: bool
+  has_override: bool
+  recommendations: Union[None, Unset, list[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
+
+    current_storage_gb = self.current_storage_gb
+
+    effective_limit_gb = self.effective_limit_gb
+
+    usage_percentage = self.usage_percentage
+
+    within_limit = self.within_limit
+
+    approaching_limit = self.approaching_limit
+
+    needs_warning = self.needs_warning
+
+    has_override = self.has_override
+
+    recommendations: Union[None, Unset, list[str]]
+    if isinstance(self.recommendations, Unset):
+      recommendations = UNSET
+    elif isinstance(self.recommendations, list):
+      recommendations = self.recommendations
+
+    else:
+      recommendations = self.recommendations
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "graph_id": graph_id,
+        "current_storage_gb": current_storage_gb,
+        "effective_limit_gb": effective_limit_gb,
+        "usage_percentage": usage_percentage,
+        "within_limit": within_limit,
+        "approaching_limit": approaching_limit,
+        "needs_warning": needs_warning,
+        "has_override": has_override,
+      }
+    )
+    if recommendations is not UNSET:
+      field_dict["recommendations"] = recommendations
+
+    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")
+
+    current_storage_gb = d.pop("current_storage_gb")
+
+    effective_limit_gb = d.pop("effective_limit_gb")
+
+    usage_percentage = d.pop("usage_percentage")
+
+    within_limit = d.pop("within_limit")
+
+    approaching_limit = d.pop("approaching_limit")
+
+    needs_warning = d.pop("needs_warning")
+
+    has_override = d.pop("has_override")
+
+    def _parse_recommendations(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()
+        recommendations_type_0 = cast(list[str], data)
+
+        return recommendations_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union[None, Unset, list[str]], data)
+
+    recommendations = _parse_recommendations(d.pop("recommendations", UNSET))
+
+    storage_limit_response = cls(
+      graph_id=graph_id,
+      current_storage_gb=current_storage_gb,
+      effective_limit_gb=effective_limit_gb,
+      usage_percentage=usage_percentage,
+      within_limit=within_limit,
+      approaching_limit=approaching_limit,
+      needs_warning=needs_warning,
+      has_override=has_override,
+      recommendations=recommendations,
+    )
+
+    storage_limit_response.additional_properties = d
+    return storage_limit_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