robosystems-client 0.2.15__py3-none-any.whl → 0.2.16__py3-none-any.whl

robosystems_client/models/save_view_request.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+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 ..types import UNSET, Unset
+
+T = TypeVar("T", bound="SaveViewRequest")
+
+
+@_attrs_define
+class SaveViewRequest:
+  """
+  Attributes:
+      report_type (str): Type of report (e.g., 'Annual Report', 'Quarterly Report', '10-K')
+      period_start (str): Period start date (YYYY-MM-DD)
+      period_end (str): Period end date (YYYY-MM-DD)
+      report_id (None | str | Unset): Existing report ID to update (if provided, deletes existing facts/structures and
+          creates new ones)
+      entity_id (None | str | Unset): Entity identifier (defaults to primary entity)
+      include_presentation (bool | Unset): Create presentation structures Default: True.
+      include_calculation (bool | Unset): Create calculation structures Default: True.
+  """
+
+  report_type: str
+  period_start: str
+  period_end: str
+  report_id: None | str | Unset = UNSET
+  entity_id: None | str | Unset = UNSET
+  include_presentation: bool | Unset = True
+  include_calculation: bool | Unset = True
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    report_type = self.report_type
+
+    period_start = self.period_start
+
+    period_end = self.period_end
+
+    report_id: None | str | Unset
+    if isinstance(self.report_id, Unset):
+      report_id = UNSET
+    else:
+      report_id = self.report_id
+
+    entity_id: None | str | Unset
+    if isinstance(self.entity_id, Unset):
+      entity_id = UNSET
+    else:
+      entity_id = self.entity_id
+
+    include_presentation = self.include_presentation
+
+    include_calculation = self.include_calculation
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "report_type": report_type,
+        "period_start": period_start,
+        "period_end": period_end,
+      }
+    )
+    if report_id is not UNSET:
+      field_dict["report_id"] = report_id
+    if entity_id is not UNSET:
+      field_dict["entity_id"] = entity_id
+    if include_presentation is not UNSET:
+      field_dict["include_presentation"] = include_presentation
+    if include_calculation is not UNSET:
+      field_dict["include_calculation"] = include_calculation
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    report_type = d.pop("report_type")
+
+    period_start = d.pop("period_start")
+
+    period_end = d.pop("period_end")
+
+    def _parse_report_id(data: object) -> None | str | Unset:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(None | str | Unset, data)
+
+    report_id = _parse_report_id(d.pop("report_id", UNSET))
+
+    def _parse_entity_id(data: object) -> None | str | Unset:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(None | str | Unset, data)
+
+    entity_id = _parse_entity_id(d.pop("entity_id", UNSET))
+
+    include_presentation = d.pop("include_presentation", UNSET)
+
+    include_calculation = d.pop("include_calculation", UNSET)
+
+    save_view_request = cls(
+      report_type=report_type,
+      period_start=period_start,
+      period_end=period_end,
+      report_id=report_id,
+      entity_id=entity_id,
+      include_presentation=include_presentation,
+      include_calculation=include_calculation,
+    )
+
+    save_view_request.additional_properties = d
+    return save_view_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/save_view_response.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+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.fact_detail import FactDetail
+  from ..models.structure_detail import StructureDetail
+
+
+T = TypeVar("T", bound="SaveViewResponse")
+
+
+@_attrs_define
+class SaveViewResponse:
+  """
+  Attributes:
+      report_id (str): Unique report identifier (used as parquet export prefix)
+      report_type (str):
+      entity_id (str):
+      entity_name (str):
+      period_start (str):
+      period_end (str):
+      fact_count (int):
+      presentation_count (int):
+      calculation_count (int):
+      facts (list[FactDetail]):
+      structures (list[StructureDetail]):
+      created_at (str):
+      parquet_export_prefix (str): Prefix for parquet file exports
+  """
+
+  report_id: str
+  report_type: str
+  entity_id: str
+  entity_name: str
+  period_start: str
+  period_end: str
+  fact_count: int
+  presentation_count: int
+  calculation_count: int
+  facts: list[FactDetail]
+  structures: list[StructureDetail]
+  created_at: str
+  parquet_export_prefix: str
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    report_id = self.report_id
+
+    report_type = self.report_type
+
+    entity_id = self.entity_id
+
+    entity_name = self.entity_name
+
+    period_start = self.period_start
+
+    period_end = self.period_end
+
+    fact_count = self.fact_count
+
+    presentation_count = self.presentation_count
+
+    calculation_count = self.calculation_count
+
+    facts = []
+    for facts_item_data in self.facts:
+      facts_item = facts_item_data.to_dict()
+      facts.append(facts_item)
+
+    structures = []
+    for structures_item_data in self.structures:
+      structures_item = structures_item_data.to_dict()
+      structures.append(structures_item)
+
+    created_at = self.created_at
+
+    parquet_export_prefix = self.parquet_export_prefix
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "report_id": report_id,
+        "report_type": report_type,
+        "entity_id": entity_id,
+        "entity_name": entity_name,
+        "period_start": period_start,
+        "period_end": period_end,
+        "fact_count": fact_count,
+        "presentation_count": presentation_count,
+        "calculation_count": calculation_count,
+        "facts": facts,
+        "structures": structures,
+        "created_at": created_at,
+        "parquet_export_prefix": parquet_export_prefix,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.fact_detail import FactDetail
+    from ..models.structure_detail import StructureDetail
+
+    d = dict(src_dict)
+    report_id = d.pop("report_id")
+
+    report_type = d.pop("report_type")
+
+    entity_id = d.pop("entity_id")
+
+    entity_name = d.pop("entity_name")
+
+    period_start = d.pop("period_start")
+
+    period_end = d.pop("period_end")
+
+    fact_count = d.pop("fact_count")
+
+    presentation_count = d.pop("presentation_count")
+
+    calculation_count = d.pop("calculation_count")
+
+    facts = []
+    _facts = d.pop("facts")
+    for facts_item_data in _facts:
+      facts_item = FactDetail.from_dict(facts_item_data)
+
+      facts.append(facts_item)
+
+    structures = []
+    _structures = d.pop("structures")
+    for structures_item_data in _structures:
+      structures_item = StructureDetail.from_dict(structures_item_data)
+
+      structures.append(structures_item)
+
+    created_at = d.pop("created_at")
+
+    parquet_export_prefix = d.pop("parquet_export_prefix")
+
+    save_view_response = cls(
+      report_id=report_id,
+      report_type=report_type,
+      entity_id=entity_id,
+      entity_name=entity_name,
+      period_start=period_start,
+      period_end=period_end,
+      fact_count=fact_count,
+      presentation_count=presentation_count,
+      calculation_count=calculation_count,
+      facts=facts,
+      structures=structures,
+      created_at=created_at,
+      parquet_export_prefix=parquet_export_prefix,
+    )
+
+    save_view_response.additional_properties = d
+    return save_view_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

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+from typing import TYPE_CHECKING, Any, TypeVar, cast
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -24,19 +26,19 @@ class SchemaExportResponse:
 
   Attributes:
       graph_id (str): Graph ID
-      schema_definition (Union['SchemaExportResponseSchemaDefinitionType0', str]): Exported schema definition (format
-          depends on 'format' parameter)
+      schema_definition (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 (only when
+      data_stats (None | SchemaExportResponseDataStatsType0 | Unset): Data statistics if requested (only when
           include_data_stats=true)
   """
 
   graph_id: str
-  schema_definition: Union["SchemaExportResponseSchemaDefinitionType0", str]
+  schema_definition: SchemaExportResponseSchemaDefinitionType0 | str
   format_: str
   exported_at: str
-  data_stats: Union["SchemaExportResponseDataStatsType0", None, Unset] = UNSET
+  data_stats: None | SchemaExportResponseDataStatsType0 | Unset = UNSET
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
@@ -49,7 +51,7 @@ class SchemaExportResponse:
 
     graph_id = self.graph_id
 
-    schema_definition: Union[dict[str, Any], str]
+    schema_definition: dict[str, Any] | str
     if isinstance(self.schema_definition, SchemaExportResponseSchemaDefinitionType0):
       schema_definition = self.schema_definition.to_dict()
     else:
@@ -59,7 +61,7 @@ class SchemaExportResponse:
 
     exported_at = self.exported_at
 
-    data_stats: Union[None, Unset, dict[str, Any]]
+    data_stats: dict[str, Any] | None | Unset
     if isinstance(self.data_stats, Unset):
       data_stats = UNSET
     elif isinstance(self.data_stats, SchemaExportResponseDataStatsType0):
@@ -96,7 +98,7 @@ class SchemaExportResponse:
 
     def _parse_schema_definition(
       data: object,
-    ) -> Union["SchemaExportResponseSchemaDefinitionType0", str]:
+    ) -> SchemaExportResponseSchemaDefinitionType0 | str:
       try:
         if not isinstance(data, dict):
           raise TypeError()
@@ -105,9 +107,9 @@ class SchemaExportResponse:
         )
 
         return schema_definition_type_0
-      except:  # noqa: E722
+      except (TypeError, ValueError, AttributeError, KeyError):
         pass
-      return cast(Union["SchemaExportResponseSchemaDefinitionType0", str], data)
+      return cast(SchemaExportResponseSchemaDefinitionType0 | str, data)
 
     schema_definition = _parse_schema_definition(d.pop("schema_definition"))
 
@@ -117,7 +119,7 @@ class SchemaExportResponse:
 
     def _parse_data_stats(
       data: object,
-    ) -> Union["SchemaExportResponseDataStatsType0", None, Unset]:
+    ) -> None | SchemaExportResponseDataStatsType0 | Unset:
       if data is None:
         return data
       if isinstance(data, Unset):
@@ -128,9 +130,9 @@ class SchemaExportResponse:
         data_stats_type_0 = SchemaExportResponseDataStatsType0.from_dict(data)
 
         return data_stats_type_0
-      except:  # noqa: E722
+      except (TypeError, ValueError, AttributeError, KeyError):
         pass
-      return cast(Union["SchemaExportResponseDataStatsType0", None, Unset], data)
+      return cast(None | SchemaExportResponseDataStatsType0 | Unset, data)
 
     data_stats = _parse_data_stats(d.pop("data_stats", UNSET))
 

robosystems_client/models/schema_export_response_data_stats_type_0.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from collections.abc import Mapping
 from typing import Any, TypeVar
 

robosystems_client/models/schema_export_response_schema_definition_type_0.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from collections.abc import Mapping
 from typing import Any, TypeVar
 

robosystems_client/models/schema_info_response.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from collections.abc import Mapping
 from typing import TYPE_CHECKING, Any, TypeVar
 
@@ -24,7 +26,7 @@ class SchemaInfoResponse:
   """
 
   graph_id: str
-  schema: "SchemaInfoResponseSchema"
+  schema: SchemaInfoResponseSchema
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:

robosystems_client/models/schema_info_response_schema.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from collections.abc import Mapping
 from typing import Any, TypeVar
 

robosystems_client/models/schema_validation_request.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+from typing import TYPE_CHECKING, Any, TypeVar, cast
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -20,16 +22,15 @@ class SchemaValidationRequest:
   """Request model for schema validation.
 
   Attributes:
-      schema_definition (Union['SchemaValidationRequestSchemaDefinitionType0', str]): Schema definition as JSON dict
-          or JSON/YAML string
-      format_ (Union[Unset, str]): Schema format: json, yaml, or dict Default: 'json'.
-      check_compatibility (Union[None, Unset, list[str]]): List of existing schema extensions to check compatibility
-          with
+      schema_definition (SchemaValidationRequestSchemaDefinitionType0 | str): Schema definition as JSON dict or
+          JSON/YAML string
+      format_ (str | Unset): Schema format: json, yaml, or dict Default: 'json'.
+      check_compatibility (list[str] | None | Unset): List of existing schema extensions to check compatibility with
   """
 
-  schema_definition: Union["SchemaValidationRequestSchemaDefinitionType0", str]
-  format_: Union[Unset, str] = "json"
-  check_compatibility: Union[None, Unset, list[str]] = UNSET
+  schema_definition: SchemaValidationRequestSchemaDefinitionType0 | str
+  format_: str | Unset = "json"
+  check_compatibility: list[str] | None | Unset = UNSET
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
@@ -37,7 +38,7 @@ class SchemaValidationRequest:
       SchemaValidationRequestSchemaDefinitionType0,
     )
 
-    schema_definition: Union[dict[str, Any], str]
+    schema_definition: dict[str, Any] | str
     if isinstance(self.schema_definition, SchemaValidationRequestSchemaDefinitionType0):
       schema_definition = self.schema_definition.to_dict()
     else:
@@ -45,7 +46,7 @@ class SchemaValidationRequest:
 
     format_ = self.format_
 
-    check_compatibility: Union[None, Unset, list[str]]
+    check_compatibility: list[str] | None | Unset
     if isinstance(self.check_compatibility, Unset):
       check_compatibility = UNSET
     elif isinstance(self.check_compatibility, list):
@@ -78,7 +79,7 @@ class SchemaValidationRequest:
 
     def _parse_schema_definition(
       data: object,
-    ) -> Union["SchemaValidationRequestSchemaDefinitionType0", str]:
+    ) -> SchemaValidationRequestSchemaDefinitionType0 | str:
       try:
         if not isinstance(data, dict):
           raise TypeError()
@@ -87,15 +88,15 @@ class SchemaValidationRequest:
         )
 
         return schema_definition_type_0
-      except:  # noqa: E722
+      except (TypeError, ValueError, AttributeError, KeyError):
         pass
-      return cast(Union["SchemaValidationRequestSchemaDefinitionType0", str], data)
+      return cast(SchemaValidationRequestSchemaDefinitionType0 | str, data)
 
     schema_definition = _parse_schema_definition(d.pop("schema_definition"))
 
     format_ = d.pop("format", UNSET)
 
-    def _parse_check_compatibility(data: object) -> Union[None, Unset, list[str]]:
+    def _parse_check_compatibility(data: object) -> list[str] | None | Unset:
       if data is None:
         return data
       if isinstance(data, Unset):
@@ -106,9 +107,9 @@ class SchemaValidationRequest:
         check_compatibility_type_0 = cast(list[str], data)
 
         return check_compatibility_type_0
-      except:  # noqa: E722
+      except (TypeError, ValueError, AttributeError, KeyError):
         pass
-      return cast(Union[None, Unset, list[str]], data)
+      return cast(list[str] | None | Unset, data)
 
     check_compatibility = _parse_check_compatibility(
       d.pop("check_compatibility", UNSET)

robosystems_client/models/schema_validation_request_schema_definition_type_0.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from collections.abc import Mapping
 from typing import Any, TypeVar