robosystems-client 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

robosystems_client/models/file_status_update.py

@@ -0,0 +1,41 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+
+T = TypeVar("T", bound="FileStatusUpdate")
+
+
+@_attrs_define
+class FileStatusUpdate:
+  """
+  Attributes:
+      status (str): File status: 'uploaded' (ready for ingest), 'disabled' (exclude from ingest), 'archived' (soft
+          deleted)
+  """
+
+  status: str
+
+  def to_dict(self) -> dict[str, Any]:
+    status = self.status
+
+    field_dict: dict[str, Any] = {}
+
+    field_dict.update(
+      {
+        "status": status,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    status = d.pop("status")
+
+    file_status_update = cls(
+      status=status,
+    )
+
+    return file_status_update

robosystems_client/models/get_file_info_response.py

@@ -0,0 +1,205 @@
+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="GetFileInfoResponse")
+
+
+@_attrs_define
+class GetFileInfoResponse:
+  """
+  Attributes:
+      file_id (str): Unique file identifier
+      graph_id (str): Graph database identifier
+      table_id (str): Table identifier
+      file_name (str): Original file name
+      file_format (str): File format (parquet, csv, etc.)
+      size_bytes (int): File size in bytes
+      upload_status (str): Current upload status
+      upload_method (str): Upload method used
+      s3_key (str): S3 object key
+      table_name (Union[None, Unset, str]): Table name
+      row_count (Union[None, Unset, int]): Estimated row count
+      created_at (Union[None, Unset, str]): File creation timestamp
+      uploaded_at (Union[None, Unset, str]): File upload completion timestamp
+  """
+
+  file_id: str
+  graph_id: str
+  table_id: str
+  file_name: str
+  file_format: str
+  size_bytes: int
+  upload_status: str
+  upload_method: str
+  s3_key: str
+  table_name: Union[None, Unset, str] = UNSET
+  row_count: Union[None, Unset, int] = UNSET
+  created_at: Union[None, Unset, str] = UNSET
+  uploaded_at: Union[None, Unset, str] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    file_id = self.file_id
+
+    graph_id = self.graph_id
+
+    table_id = self.table_id
+
+    file_name = self.file_name
+
+    file_format = self.file_format
+
+    size_bytes = self.size_bytes
+
+    upload_status = self.upload_status
+
+    upload_method = self.upload_method
+
+    s3_key = self.s3_key
+
+    table_name: Union[None, Unset, str]
+    if isinstance(self.table_name, Unset):
+      table_name = UNSET
+    else:
+      table_name = self.table_name
+
+    row_count: Union[None, Unset, int]
+    if isinstance(self.row_count, Unset):
+      row_count = UNSET
+    else:
+      row_count = self.row_count
+
+    created_at: Union[None, Unset, str]
+    if isinstance(self.created_at, Unset):
+      created_at = UNSET
+    else:
+      created_at = self.created_at
+
+    uploaded_at: Union[None, Unset, str]
+    if isinstance(self.uploaded_at, Unset):
+      uploaded_at = UNSET
+    else:
+      uploaded_at = self.uploaded_at
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "file_id": file_id,
+        "graph_id": graph_id,
+        "table_id": table_id,
+        "file_name": file_name,
+        "file_format": file_format,
+        "size_bytes": size_bytes,
+        "upload_status": upload_status,
+        "upload_method": upload_method,
+        "s3_key": s3_key,
+      }
+    )
+    if table_name is not UNSET:
+      field_dict["table_name"] = table_name
+    if row_count is not UNSET:
+      field_dict["row_count"] = row_count
+    if created_at is not UNSET:
+      field_dict["created_at"] = created_at
+    if uploaded_at is not UNSET:
+      field_dict["uploaded_at"] = uploaded_at
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    file_id = d.pop("file_id")
+
+    graph_id = d.pop("graph_id")
+
+    table_id = d.pop("table_id")
+
+    file_name = d.pop("file_name")
+
+    file_format = d.pop("file_format")
+
+    size_bytes = d.pop("size_bytes")
+
+    upload_status = d.pop("upload_status")
+
+    upload_method = d.pop("upload_method")
+
+    s3_key = d.pop("s3_key")
+
+    def _parse_table_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)
+
+    table_name = _parse_table_name(d.pop("table_name", UNSET))
+
+    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))
+
+    def _parse_created_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)
+
+    created_at = _parse_created_at(d.pop("created_at", UNSET))
+
+    def _parse_uploaded_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)
+
+    uploaded_at = _parse_uploaded_at(d.pop("uploaded_at", UNSET))
+
+    get_file_info_response = cls(
+      file_id=file_id,
+      graph_id=graph_id,
+      table_id=table_id,
+      file_name=file_name,
+      file_format=file_format,
+      size_bytes=size_bytes,
+      upload_status=upload_status,
+      upload_method=upload_method,
+      s3_key=s3_key,
+      table_name=table_name,
+      row_count=row_count,
+      created_at=created_at,
+      uploaded_at=uploaded_at,
+    )
+
+    get_file_info_response.additional_properties = d
+    return get_file_info_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/list_table_files_response.py

@@ -0,0 +1,105 @@
+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.file_info import FileInfo
+
+
+T = TypeVar("T", bound="ListTableFilesResponse")
+
+
+@_attrs_define
+class ListTableFilesResponse:
+  """
+  Attributes:
+      graph_id (str): Graph database identifier
+      table_name (str): Table name
+      files (list['FileInfo']): List of files in the table
+      total_files (int): Total number of files
+      total_size_bytes (int): Total size of all files in bytes
+  """
+
+  graph_id: str
+  table_name: str
+  files: list["FileInfo"]
+  total_files: int
+  total_size_bytes: int
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    graph_id = self.graph_id
+
+    table_name = self.table_name
+
+    files = []
+    for files_item_data in self.files:
+      files_item = files_item_data.to_dict()
+      files.append(files_item)
+
+    total_files = self.total_files
+
+    total_size_bytes = self.total_size_bytes
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "graph_id": graph_id,
+        "table_name": table_name,
+        "files": files,
+        "total_files": total_files,
+        "total_size_bytes": total_size_bytes,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.file_info import FileInfo
+
+    d = dict(src_dict)
+    graph_id = d.pop("graph_id")
+
+    table_name = d.pop("table_name")
+
+    files = []
+    _files = d.pop("files")
+    for files_item_data in _files:
+      files_item = FileInfo.from_dict(files_item_data)
+
+      files.append(files_item)
+
+    total_files = d.pop("total_files")
+
+    total_size_bytes = d.pop("total_size_bytes")
+
+    list_table_files_response = cls(
+      graph_id=graph_id,
+      table_name=table_name,
+      files=files,
+      total_files=total_files,
+      total_size_bytes=total_size_bytes,
+    )
+
+    list_table_files_response.additional_properties = d
+    return list_table_files_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/schema_export_response.py

@@ -24,10 +24,12 @@ class SchemaExportResponse:
 
   Attributes:
       graph_id (str): Graph ID
-      schema_definition (Union['SchemaExportResponseSchemaDefinitionType0', str]): Exported schema definition
+      schema_definition (Union['SchemaExportResponseSchemaDefinitionType0', str]): Exported schema definition (format
+          depends on 'format' parameter)
       format_ (str): Export format used
       exported_at (str): Export timestamp
-      data_stats (Union['SchemaExportResponseDataStatsType0', None, Unset]): Data statistics if requested
+      data_stats (Union['SchemaExportResponseDataStatsType0', None, Unset]): Data statistics if requested (only when
+          include_data_stats=true)
   """
 
   graph_id: str

robosystems_client/models/schema_info_response.py

@@ -0,0 +1,77 @@
+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.schema_info_response_schema import SchemaInfoResponseSchema
+
+
+T = TypeVar("T", bound="SchemaInfoResponse")
+
+
+@_attrs_define
+class SchemaInfoResponse:
+  """Response model for runtime schema introspection.
+
+  This model represents the actual current state of the graph database,
+  showing what node labels, relationship types, and properties exist right now.
+
+      Attributes:
+          graph_id (str): Graph database identifier
+          schema (SchemaInfoResponseSchema): Runtime schema information showing actual database structure
+  """
+
+  graph_id: str
+  schema: "SchemaInfoResponseSchema"
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    graph_id = self.graph_id
+
+    schema = self.schema.to_dict()
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "graph_id": graph_id,
+        "schema": schema,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.schema_info_response_schema import SchemaInfoResponseSchema
+
+    d = dict(src_dict)
+    graph_id = d.pop("graph_id")
+
+    schema = SchemaInfoResponseSchema.from_dict(d.pop("schema"))
+
+    schema_info_response = cls(
+      graph_id=graph_id,
+      schema=schema,
+    )
+
+    schema_info_response.additional_properties = d
+    return schema_info_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_response_getgraphschema.py → schema_info_response_schema.py}

@@ -4,12 +4,12 @@ from typing import Any, TypeVar
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="GetGraphSchemaResponseGetgraphschema")
+T = TypeVar("T", bound="SchemaInfoResponseSchema")
 
 
 @_attrs_define
-class GetGraphSchemaResponseGetgraphschema:
-  """ """
+class SchemaInfoResponseSchema:
+  """Runtime schema information showing actual database structure"""
 
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -22,10 +22,10 @@ class GetGraphSchemaResponseGetgraphschema:
   @classmethod
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
     d = dict(src_dict)
-    get_graph_schema_response_getgraphschema = cls()
+    schema_info_response_schema = cls()
 
-    get_graph_schema_response_getgraphschema.additional_properties = d
-    return get_graph_schema_response_getgraphschema
+    schema_info_response_schema.additional_properties = d
+    return schema_info_response_schema
 
   @property
   def additional_keys(self) -> list[str]:

robosystems_client/models/schema_validation_response.py

@@ -25,12 +25,13 @@ class SchemaValidationResponse:
   Attributes:
       valid (bool): Whether the schema is valid
       message (str): Validation message
-      errors (Union[None, Unset, list[str]]): List of validation errors
-      warnings (Union[None, Unset, list[str]]): List of warnings
-      stats (Union['SchemaValidationResponseStatsType0', None, Unset]): Schema statistics (nodes, relationships,
-          properties)
-      compatibility (Union['SchemaValidationResponseCompatibilityType0', None, Unset]): Compatibility check results if
-          requested
+      errors (Union[None, Unset, list[str]]): List of validation errors (only present when valid=false)
+      warnings (Union[None, Unset, list[str]]): List of validation warnings (schema is still valid but has potential
+          issues)
+      stats (Union['SchemaValidationResponseStatsType0', None, Unset]): Schema statistics (only present when
+          valid=true)
+      compatibility (Union['SchemaValidationResponseCompatibilityType0', None, Unset]): Compatibility check results
+          (only when check_compatibility specified)
   """
 
   valid: bool

robosystems_client/models/table_query_request.py

@@ -1,8 +1,10 @@
 from collections.abc import Mapping
-from typing import Any, TypeVar
+from typing import Any, TypeVar, Union, cast
 
 from attrs import define as _attrs_define
 
+from ..types import UNSET, Unset
+
 T = TypeVar("T", bound="TableQueryRequest")
 
 
@@ -10,14 +12,27 @@ T = TypeVar("T", bound="TableQueryRequest")
 class TableQueryRequest:
   """
   Attributes:
-      sql (str): SQL query to execute on staging tables
+      sql (str): SQL query to execute on staging tables. Use ? placeholders or $param_name for dynamic values to
+          prevent SQL injection.
+      parameters (Union[None, Unset, list[Any]]): Query parameters for safe value substitution. ALWAYS use parameters
+          instead of string concatenation.
   """
 
   sql: str
+  parameters: Union[None, Unset, list[Any]] = UNSET
 
   def to_dict(self) -> dict[str, Any]:
     sql = self.sql
 
+    parameters: Union[None, Unset, list[Any]]
+    if isinstance(self.parameters, Unset):
+      parameters = UNSET
+    elif isinstance(self.parameters, list):
+      parameters = self.parameters
+
+    else:
+      parameters = self.parameters
+
     field_dict: dict[str, Any] = {}
 
     field_dict.update(
@@ -25,6 +40,8 @@ class TableQueryRequest:
         "sql": sql,
       }
     )
+    if parameters is not UNSET:
+      field_dict["parameters"] = parameters
 
     return field_dict
 
@@ -33,8 +50,26 @@ class TableQueryRequest:
     d = dict(src_dict)
     sql = d.pop("sql")
 
+    def _parse_parameters(data: object) -> Union[None, Unset, list[Any]]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, list):
+          raise TypeError()
+        parameters_type_0 = cast(list[Any], data)
+
+        return parameters_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union[None, Unset, list[Any]], data)
+
+    parameters = _parse_parameters(d.pop("parameters", UNSET))
+
     table_query_request = cls(
       sql=sql,
+      parameters=parameters,
     )
 
     return table_query_request

robosystems_client/models/{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 → update_file_status_response_updatefilestatus.py}

@@ -4,14 +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="GetFileInfoV1GraphsGraphIdTablesFilesFileIdGetResponseGetFileInfoV1GraphsGraphIdTablesFilesFileIdGet",
-)
+T = TypeVar("T", bound="UpdateFileStatusResponseUpdatefilestatus")
 
 
 @_attrs_define
-class GetFileInfoV1GraphsGraphIdTablesFilesFileIdGetResponseGetFileInfoV1GraphsGraphIdTablesFilesFileIdGet:
+class UpdateFileStatusResponseUpdatefilestatus:
   """ """
 
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -25,10 +22,10 @@ class GetFileInfoV1GraphsGraphIdTablesFilesFileIdGetResponseGetFileInfoV1GraphsG
   @classmethod
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
     d = dict(src_dict)
-    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()
+    update_file_status_response_updatefilestatus = 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.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
+    update_file_status_response_updatefilestatus.additional_properties = d
+    return update_file_status_response_updatefilestatus
 
   @property
   def additional_keys(self) -> list[str]:

{robosystems_client-0.2.2.dist-info → robosystems_client-0.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robosystems-client
-Version: 0.2.2
+Version: 0.2.4
 Summary: Python Client for RoboSystems financial graph database API
 Author: RFS LLC
 License: MIT
@@ -35,9 +35,9 @@ Provides-Extra: all
 Requires-Dist: pandas>=1.5.0; extra == 'all'
 Requires-Dist: pyarrow>=10.0.0; extra == 'all'
 Provides-Extra: dev
+Requires-Dist: basedpyright>=1.21.0; extra == 'dev'
 Requires-Dist: build>=1.0.0; extra == 'dev'
 Requires-Dist: openapi-python-client>=0.21.8; extra == 'dev'
-Requires-Dist: pyright>=1.1.402; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.26.0; extra == 'dev'
 Requires-Dist: pytest-httpx>=0.30.0; extra == 'dev'
 Requires-Dist: pytest>=8.3.5; extra == 'dev'
@@ -80,8 +80,6 @@ pip install robosystems-client[tables]
 pip install robosystems-client[all]
 ```
 
-See the [examples](./examples) directory for usage guides.
-
 ## API Reference
 
 - [API reference](https://api.robosystems.ai)