robosystems-client 0.1.18__py3-none-any.whl → 0.2.0__py3-none-any.whl

robosystems_client/models/file_update_request.py

@@ -0,0 +1,62 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="FileUpdateRequest")
+
+
+@_attrs_define
+class FileUpdateRequest:
+  """
+  Attributes:
+      file_size_bytes (int): Actual uploaded file size in bytes
+      row_count (Union[None, Unset, int]): Number of rows in the file
+  """
+
+  file_size_bytes: int
+  row_count: Union[None, Unset, int] = UNSET
+
+  def to_dict(self) -> dict[str, Any]:
+    file_size_bytes = self.file_size_bytes
+
+    row_count: Union[None, Unset, int]
+    if isinstance(self.row_count, Unset):
+      row_count = UNSET
+    else:
+      row_count = self.row_count
+
+    field_dict: dict[str, Any] = {}
+
+    field_dict.update(
+      {
+        "file_size_bytes": file_size_bytes,
+      }
+    )
+    if row_count is not UNSET:
+      field_dict["row_count"] = row_count
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    file_size_bytes = d.pop("file_size_bytes")
+
+    def _parse_row_count(data: object) -> Union[None, Unset, int]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, int], data)
+
+    row_count = _parse_row_count(d.pop("row_count", UNSET))
+
+    file_update_request = cls(
+      file_size_bytes=file_size_bytes,
+      row_count=row_count,
+    )
+
+    return file_update_request

robosystems_client/models/file_upload_request.py

@@ -0,0 +1,51 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="FileUploadRequest")
+
+
+@_attrs_define
+class FileUploadRequest:
+  """
+  Attributes:
+      file_name (str): File name to upload
+      content_type (Union[Unset, str]): File MIME type Default: 'application/x-parquet'.
+  """
+
+  file_name: str
+  content_type: Union[Unset, str] = "application/x-parquet"
+
+  def to_dict(self) -> dict[str, Any]:
+    file_name = self.file_name
+
+    content_type = self.content_type
+
+    field_dict: dict[str, Any] = {}
+
+    field_dict.update(
+      {
+        "file_name": file_name,
+      }
+    )
+    if content_type is not UNSET:
+      field_dict["content_type"] = content_type
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    file_name = d.pop("file_name")
+
+    content_type = d.pop("content_type", UNSET)
+
+    file_upload_request = cls(
+      file_name=file_name,
+      content_type=content_type,
+    )
+
+    return file_upload_request

robosystems_client/models/file_upload_response.py

@@ -0,0 +1,83 @@
+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="FileUploadResponse")
+
+
+@_attrs_define
+class FileUploadResponse:
+  """
+  Attributes:
+      upload_url (str): Presigned S3 upload URL
+      expires_in (int): URL expiration time in seconds
+      file_id (str): File tracking ID
+      s3_key (str): S3 object key
+  """
+
+  upload_url: str
+  expires_in: int
+  file_id: str
+  s3_key: str
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    upload_url = self.upload_url
+
+    expires_in = self.expires_in
+
+    file_id = self.file_id
+
+    s3_key = self.s3_key
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "upload_url": upload_url,
+        "expires_in": expires_in,
+        "file_id": file_id,
+        "s3_key": s3_key,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    upload_url = d.pop("upload_url")
+
+    expires_in = d.pop("expires_in")
+
+    file_id = d.pop("file_id")
+
+    s3_key = d.pop("s3_key")
+
+    file_upload_response = cls(
+      upload_url=upload_url,
+      expires_in=expires_in,
+      file_id=file_id,
+      s3_key=s3_key,
+    )
+
+    file_upload_response.additional_properties = d
+    return file_upload_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/{get_graph_schema_info_response_getgraphschemainfo.py → get_file_info_v1_graphs_graph_id_tables_files_file_id_get_response_get_file_info_v1_graphs_graph_id_tables_files_file_id_get.py}

@@ -4,11 +4,14 @@ from typing import Any, TypeVar
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="GetGraphSchemaInfoResponseGetgraphschemainfo")
+T = TypeVar(
+  "T",
+  bound="GetFileInfoV1GraphsGraphIdTablesFilesFileIdGetResponseGetFileInfoV1GraphsGraphIdTablesFilesFileIdGet",
+)
 
 
 @_attrs_define
-class GetGraphSchemaInfoResponseGetgraphschemainfo:
+class GetFileInfoV1GraphsGraphIdTablesFilesFileIdGetResponseGetFileInfoV1GraphsGraphIdTablesFilesFileIdGet:
   """ """
 
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -22,10 +25,10 @@ class GetGraphSchemaInfoResponseGetgraphschemainfo:
   @classmethod
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
     d = dict(src_dict)
-    get_graph_schema_info_response_getgraphschemainfo = cls()
+    get_file_info_v1_graphs_graph_id_tables_files_file_id_get_response_get_file_info_v1_graphs_graph_id_tables_files_file_id_get = cls()
 
-    get_graph_schema_info_response_getgraphschemainfo.additional_properties = d
-    return get_graph_schema_info_response_getgraphschemainfo
+    get_file_info_v1_graphs_graph_id_tables_files_file_id_get_response_get_file_info_v1_graphs_graph_id_tables_files_file_id_get.additional_properties = d
+    return get_file_info_v1_graphs_graph_id_tables_files_file_id_get_response_get_file_info_v1_graphs_graph_id_tables_files_file_id_get
 
   @property
   def additional_keys(self) -> list[str]:

robosystems_client/models/{copy_response_error_details_type_0.py → get_graph_schema_response_getgraphschema.py}

@@ -4,11 +4,11 @@ from typing import Any, TypeVar
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="CopyResponseErrorDetailsType0")
+T = TypeVar("T", bound="GetGraphSchemaResponseGetgraphschema")
 
 
 @_attrs_define
-class CopyResponseErrorDetailsType0:
+class GetGraphSchemaResponseGetgraphschema:
   """ """
 
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -22,10 +22,10 @@ class CopyResponseErrorDetailsType0:
   @classmethod
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
     d = dict(src_dict)
-    copy_response_error_details_type_0 = cls()
+    get_graph_schema_response_getgraphschema = cls()
 
-    copy_response_error_details_type_0.additional_properties = d
-    return copy_response_error_details_type_0
+    get_graph_schema_response_getgraphschema.additional_properties = d
+    return get_graph_schema_response_getgraphschema
 
   @property
   def additional_keys(self) -> list[str]:

robosystems_client/models/list_table_files_v1_graphs_graph_id_tables_table_name_files_get_response_list_table_files_v1_graphs_graph_id_tables_table_name_files_get.py

@@ -0,0 +1,47 @@
+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="ListTableFilesV1GraphsGraphIdTablesTableNameFilesGetResponseListTableFilesV1GraphsGraphIdTablesTableNameFilesGet",
+)
+
+
+@_attrs_define
+class ListTableFilesV1GraphsGraphIdTablesTableNameFilesGetResponseListTableFilesV1GraphsGraphIdTablesTableNameFilesGet:
+  """ """
+
+  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)
+    list_table_files_v1_graphs_graph_id_tables_table_name_files_get_response_list_table_files_v1_graphs_graph_id_tables_table_name_files_get = cls()
+
+    list_table_files_v1_graphs_graph_id_tables_table_name_files_get_response_list_table_files_v1_graphs_graph_id_tables_table_name_files_get.additional_properties = d
+    return list_table_files_v1_graphs_graph_id_tables_table_name_files_get_response_list_table_files_v1_graphs_graph_id_tables_table_name_files_get
+
+  @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/table_info.py

@@ -0,0 +1,107 @@
+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="TableInfo")
+
+
+@_attrs_define
+class TableInfo:
+  """
+  Attributes:
+      table_name (str): Table name
+      row_count (int): Approximate row count
+      file_count (Union[Unset, int]): Number of files Default: 0.
+      total_size_bytes (Union[Unset, int]): Total size in bytes Default: 0.
+      s3_location (Union[None, Unset, str]): S3 location for external tables
+  """
+
+  table_name: str
+  row_count: int
+  file_count: Union[Unset, int] = 0
+  total_size_bytes: Union[Unset, int] = 0
+  s3_location: Union[None, Unset, str] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    table_name = self.table_name
+
+    row_count = self.row_count
+
+    file_count = self.file_count
+
+    total_size_bytes = self.total_size_bytes
+
+    s3_location: Union[None, Unset, str]
+    if isinstance(self.s3_location, Unset):
+      s3_location = UNSET
+    else:
+      s3_location = self.s3_location
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "table_name": table_name,
+        "row_count": row_count,
+      }
+    )
+    if file_count is not UNSET:
+      field_dict["file_count"] = file_count
+    if total_size_bytes is not UNSET:
+      field_dict["total_size_bytes"] = total_size_bytes
+    if s3_location is not UNSET:
+      field_dict["s3_location"] = s3_location
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    table_name = d.pop("table_name")
+
+    row_count = d.pop("row_count")
+
+    file_count = d.pop("file_count", UNSET)
+
+    total_size_bytes = d.pop("total_size_bytes", UNSET)
+
+    def _parse_s3_location(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)
+
+    s3_location = _parse_s3_location(d.pop("s3_location", UNSET))
+
+    table_info = cls(
+      table_name=table_name,
+      row_count=row_count,
+      file_count=file_count,
+      total_size_bytes=total_size_bytes,
+      s3_location=s3_location,
+    )
+
+    table_info.additional_properties = d
+    return table_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/table_ingest_result.py

@@ -0,0 +1,107 @@
+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="TableIngestResult")
+
+
+@_attrs_define
+class TableIngestResult:
+  """
+  Attributes:
+      table_name (str): Table name
+      status (str): Ingestion status (success/failed/skipped)
+      rows_ingested (Union[Unset, int]): Number of rows ingested Default: 0.
+      execution_time_ms (Union[Unset, float]): Ingestion time in milliseconds Default: 0.0.
+      error (Union[None, Unset, str]): Error message if failed
+  """
+
+  table_name: str
+  status: str
+  rows_ingested: Union[Unset, int] = 0
+  execution_time_ms: Union[Unset, float] = 0.0
+  error: Union[None, Unset, str] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    table_name = self.table_name
+
+    status = self.status
+
+    rows_ingested = self.rows_ingested
+
+    execution_time_ms = self.execution_time_ms
+
+    error: Union[None, Unset, str]
+    if isinstance(self.error, Unset):
+      error = UNSET
+    else:
+      error = self.error
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "table_name": table_name,
+        "status": status,
+      }
+    )
+    if rows_ingested is not UNSET:
+      field_dict["rows_ingested"] = rows_ingested
+    if execution_time_ms is not UNSET:
+      field_dict["execution_time_ms"] = execution_time_ms
+    if error is not UNSET:
+      field_dict["error"] = error
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    table_name = d.pop("table_name")
+
+    status = d.pop("status")
+
+    rows_ingested = d.pop("rows_ingested", UNSET)
+
+    execution_time_ms = d.pop("execution_time_ms", UNSET)
+
+    def _parse_error(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)
+
+    error = _parse_error(d.pop("error", UNSET))
+
+    table_ingest_result = cls(
+      table_name=table_name,
+      status=status,
+      rows_ingested=rows_ingested,
+      execution_time_ms=execution_time_ms,
+      error=error,
+    )
+
+    table_ingest_result.additional_properties = d
+    return table_ingest_result
+
+  @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/table_list_response.py

@@ -0,0 +1,81 @@
+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.table_info import TableInfo
+
+
+T = TypeVar("T", bound="TableListResponse")
+
+
+@_attrs_define
+class TableListResponse:
+  """
+  Attributes:
+      tables (list['TableInfo']): List of tables
+      total_count (int): Total number of tables
+  """
+
+  tables: list["TableInfo"]
+  total_count: int
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    tables = []
+    for tables_item_data in self.tables:
+      tables_item = tables_item_data.to_dict()
+      tables.append(tables_item)
+
+    total_count = self.total_count
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "tables": tables,
+        "total_count": total_count,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.table_info import TableInfo
+
+    d = dict(src_dict)
+    tables = []
+    _tables = d.pop("tables")
+    for tables_item_data in _tables:
+      tables_item = TableInfo.from_dict(tables_item_data)
+
+      tables.append(tables_item)
+
+    total_count = d.pop("total_count")
+
+    table_list_response = cls(
+      tables=tables,
+      total_count=total_count,
+    )
+
+    table_list_response.additional_properties = d
+    return table_list_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/table_query_request.py

@@ -0,0 +1,40 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+
+T = TypeVar("T", bound="TableQueryRequest")
+
+
+@_attrs_define
+class TableQueryRequest:
+  """
+  Attributes:
+      sql (str): SQL query to execute on staging tables
+  """
+
+  sql: str
+
+  def to_dict(self) -> dict[str, Any]:
+    sql = self.sql
+
+    field_dict: dict[str, Any] = {}
+
+    field_dict.update(
+      {
+        "sql": sql,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    sql = d.pop("sql")
+
+    table_query_request = cls(
+      sql=sql,
+    )
+
+    return table_query_request