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

robosystems_client/models/view_axis_config.py

@@ -0,0 +1,276 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, 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.view_axis_config_element_labels_type_0 import (
+    ViewAxisConfigElementLabelsType0,
+  )
+  from ..models.view_axis_config_member_labels_type_0 import (
+    ViewAxisConfigMemberLabelsType0,
+  )
+
+
+T = TypeVar("T", bound="ViewAxisConfig")
+
+
+@_attrs_define
+class ViewAxisConfig:
+  """
+  Attributes:
+      type_ (str): Axis type: 'element', 'period', 'dimension', 'entity'
+      dimension_axis (None | str | Unset): Dimension axis name for dimension-type axes
+      include_null_dimension (bool | Unset): Include facts where this dimension is NULL (default: false) Default:
+          False.
+      selected_members (list[str] | None | Unset): Specific members to include (e.g., ['2024-12-31', '2023-12-31'])
+      member_order (list[str] | None | Unset): Explicit ordering of members (overrides default sort)
+      member_labels (None | Unset | ViewAxisConfigMemberLabelsType0): Custom labels for members (e.g., {'2024-12-31':
+          'Current Year'})
+      element_order (list[str] | None | Unset): Element ordering for hierarchy display (e.g., ['us-gaap:Assets', 'us-
+          gaap:Cash', ...])
+      element_labels (None | Unset | ViewAxisConfigElementLabelsType0): Custom labels for elements (e.g., {'us-
+          gaap:Cash': 'Cash and Cash Equivalents'})
+  """
+
+  type_: str
+  dimension_axis: None | str | Unset = UNSET
+  include_null_dimension: bool | Unset = False
+  selected_members: list[str] | None | Unset = UNSET
+  member_order: list[str] | None | Unset = UNSET
+  member_labels: None | Unset | ViewAxisConfigMemberLabelsType0 = UNSET
+  element_order: list[str] | None | Unset = UNSET
+  element_labels: None | Unset | ViewAxisConfigElementLabelsType0 = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    from ..models.view_axis_config_element_labels_type_0 import (
+      ViewAxisConfigElementLabelsType0,
+    )
+    from ..models.view_axis_config_member_labels_type_0 import (
+      ViewAxisConfigMemberLabelsType0,
+    )
+
+    type_ = self.type_
+
+    dimension_axis: None | str | Unset
+    if isinstance(self.dimension_axis, Unset):
+      dimension_axis = UNSET
+    else:
+      dimension_axis = self.dimension_axis
+
+    include_null_dimension = self.include_null_dimension
+
+    selected_members: list[str] | None | Unset
+    if isinstance(self.selected_members, Unset):
+      selected_members = UNSET
+    elif isinstance(self.selected_members, list):
+      selected_members = self.selected_members
+
+    else:
+      selected_members = self.selected_members
+
+    member_order: list[str] | None | Unset
+    if isinstance(self.member_order, Unset):
+      member_order = UNSET
+    elif isinstance(self.member_order, list):
+      member_order = self.member_order
+
+    else:
+      member_order = self.member_order
+
+    member_labels: dict[str, Any] | None | Unset
+    if isinstance(self.member_labels, Unset):
+      member_labels = UNSET
+    elif isinstance(self.member_labels, ViewAxisConfigMemberLabelsType0):
+      member_labels = self.member_labels.to_dict()
+    else:
+      member_labels = self.member_labels
+
+    element_order: list[str] | None | Unset
+    if isinstance(self.element_order, Unset):
+      element_order = UNSET
+    elif isinstance(self.element_order, list):
+      element_order = self.element_order
+
+    else:
+      element_order = self.element_order
+
+    element_labels: dict[str, Any] | None | Unset
+    if isinstance(self.element_labels, Unset):
+      element_labels = UNSET
+    elif isinstance(self.element_labels, ViewAxisConfigElementLabelsType0):
+      element_labels = self.element_labels.to_dict()
+    else:
+      element_labels = self.element_labels
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "type": type_,
+      }
+    )
+    if dimension_axis is not UNSET:
+      field_dict["dimension_axis"] = dimension_axis
+    if include_null_dimension is not UNSET:
+      field_dict["include_null_dimension"] = include_null_dimension
+    if selected_members is not UNSET:
+      field_dict["selected_members"] = selected_members
+    if member_order is not UNSET:
+      field_dict["member_order"] = member_order
+    if member_labels is not UNSET:
+      field_dict["member_labels"] = member_labels
+    if element_order is not UNSET:
+      field_dict["element_order"] = element_order
+    if element_labels is not UNSET:
+      field_dict["element_labels"] = element_labels
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.view_axis_config_element_labels_type_0 import (
+      ViewAxisConfigElementLabelsType0,
+    )
+    from ..models.view_axis_config_member_labels_type_0 import (
+      ViewAxisConfigMemberLabelsType0,
+    )
+
+    d = dict(src_dict)
+    type_ = d.pop("type")
+
+    def _parse_dimension_axis(data: object) -> None | str | Unset:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(None | str | Unset, data)
+
+    dimension_axis = _parse_dimension_axis(d.pop("dimension_axis", UNSET))
+
+    include_null_dimension = d.pop("include_null_dimension", UNSET)
+
+    def _parse_selected_members(data: object) -> list[str] | None | Unset:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, list):
+          raise TypeError()
+        selected_members_type_0 = cast(list[str], data)
+
+        return selected_members_type_0
+      except (TypeError, ValueError, AttributeError, KeyError):
+        pass
+      return cast(list[str] | None | Unset, data)
+
+    selected_members = _parse_selected_members(d.pop("selected_members", UNSET))
+
+    def _parse_member_order(data: object) -> list[str] | None | Unset:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, list):
+          raise TypeError()
+        member_order_type_0 = cast(list[str], data)
+
+        return member_order_type_0
+      except (TypeError, ValueError, AttributeError, KeyError):
+        pass
+      return cast(list[str] | None | Unset, data)
+
+    member_order = _parse_member_order(d.pop("member_order", UNSET))
+
+    def _parse_member_labels(
+      data: object,
+    ) -> None | Unset | ViewAxisConfigMemberLabelsType0:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        member_labels_type_0 = ViewAxisConfigMemberLabelsType0.from_dict(data)
+
+        return member_labels_type_0
+      except (TypeError, ValueError, AttributeError, KeyError):
+        pass
+      return cast(None | Unset | ViewAxisConfigMemberLabelsType0, data)
+
+    member_labels = _parse_member_labels(d.pop("member_labels", UNSET))
+
+    def _parse_element_order(data: object) -> list[str] | None | Unset:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, list):
+          raise TypeError()
+        element_order_type_0 = cast(list[str], data)
+
+        return element_order_type_0
+      except (TypeError, ValueError, AttributeError, KeyError):
+        pass
+      return cast(list[str] | None | Unset, data)
+
+    element_order = _parse_element_order(d.pop("element_order", UNSET))
+
+    def _parse_element_labels(
+      data: object,
+    ) -> None | Unset | ViewAxisConfigElementLabelsType0:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        element_labels_type_0 = ViewAxisConfigElementLabelsType0.from_dict(data)
+
+        return element_labels_type_0
+      except (TypeError, ValueError, AttributeError, KeyError):
+        pass
+      return cast(None | Unset | ViewAxisConfigElementLabelsType0, data)
+
+    element_labels = _parse_element_labels(d.pop("element_labels", UNSET))
+
+    view_axis_config = cls(
+      type_=type_,
+      dimension_axis=dimension_axis,
+      include_null_dimension=include_null_dimension,
+      selected_members=selected_members,
+      member_order=member_order,
+      member_labels=member_labels,
+      element_order=element_order,
+      element_labels=element_labels,
+    )
+
+    view_axis_config.additional_properties = d
+    return view_axis_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/view_axis_config_element_labels_type_0.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+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="ViewAxisConfigElementLabelsType0")
+
+
+@_attrs_define
+class ViewAxisConfigElementLabelsType0:
+  """ """
+
+  additional_properties: dict[str, str] = _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)
+    view_axis_config_element_labels_type_0 = cls()
+
+    view_axis_config_element_labels_type_0.additional_properties = d
+    return view_axis_config_element_labels_type_0
+
+  @property
+  def additional_keys(self) -> list[str]:
+    return list(self.additional_properties.keys())
+
+  def __getitem__(self, key: str) -> str:
+    return self.additional_properties[key]
+
+  def __setitem__(self, key: str, value: str) -> 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/view_axis_config_member_labels_type_0.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+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="ViewAxisConfigMemberLabelsType0")
+
+
+@_attrs_define
+class ViewAxisConfigMemberLabelsType0:
+  """ """
+
+  additional_properties: dict[str, str] = _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)
+    view_axis_config_member_labels_type_0 = cls()
+
+    view_axis_config_member_labels_type_0.additional_properties = d
+    return view_axis_config_member_labels_type_0
+
+  @property
+  def additional_keys(self) -> list[str]:
+    return list(self.additional_properties.keys())
+
+  def __getitem__(self, key: str) -> str:
+    return self.additional_properties[key]
+
+  def __setitem__(self, key: str, value: str) -> 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/view_config.py

@@ -0,0 +1,127 @@
+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
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+  from ..models.view_axis_config import ViewAxisConfig
+
+
+T = TypeVar("T", bound="ViewConfig")
+
+
+@_attrs_define
+class ViewConfig:
+  """
+  Attributes:
+      rows (list[ViewAxisConfig] | Unset): Row axis configuration
+      columns (list[ViewAxisConfig] | Unset): Column axis configuration
+      values (str | Unset): Field to use for values (default: numeric_value) Default: 'numeric_value'.
+      aggregation_function (str | Unset): Aggregation function: sum, average, count Default: 'sum'.
+      fill_value (float | Unset): Value to use for missing data Default: 0.0.
+  """
+
+  rows: list[ViewAxisConfig] | Unset = UNSET
+  columns: list[ViewAxisConfig] | Unset = UNSET
+  values: str | Unset = "numeric_value"
+  aggregation_function: str | Unset = "sum"
+  fill_value: float | Unset = 0.0
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    rows: list[dict[str, Any]] | Unset = UNSET
+    if not isinstance(self.rows, Unset):
+      rows = []
+      for rows_item_data in self.rows:
+        rows_item = rows_item_data.to_dict()
+        rows.append(rows_item)
+
+    columns: list[dict[str, Any]] | Unset = UNSET
+    if not isinstance(self.columns, Unset):
+      columns = []
+      for columns_item_data in self.columns:
+        columns_item = columns_item_data.to_dict()
+        columns.append(columns_item)
+
+    values = self.values
+
+    aggregation_function = self.aggregation_function
+
+    fill_value = self.fill_value
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update({})
+    if rows is not UNSET:
+      field_dict["rows"] = rows
+    if columns is not UNSET:
+      field_dict["columns"] = columns
+    if values is not UNSET:
+      field_dict["values"] = values
+    if aggregation_function is not UNSET:
+      field_dict["aggregation_function"] = aggregation_function
+    if fill_value is not UNSET:
+      field_dict["fill_value"] = fill_value
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.view_axis_config import ViewAxisConfig
+
+    d = dict(src_dict)
+    _rows = d.pop("rows", UNSET)
+    rows: list[ViewAxisConfig] | Unset = UNSET
+    if _rows is not UNSET:
+      rows = []
+      for rows_item_data in _rows:
+        rows_item = ViewAxisConfig.from_dict(rows_item_data)
+
+        rows.append(rows_item)
+
+    _columns = d.pop("columns", UNSET)
+    columns: list[ViewAxisConfig] | Unset = UNSET
+    if _columns is not UNSET:
+      columns = []
+      for columns_item_data in _columns:
+        columns_item = ViewAxisConfig.from_dict(columns_item_data)
+
+        columns.append(columns_item)
+
+    values = d.pop("values", UNSET)
+
+    aggregation_function = d.pop("aggregation_function", UNSET)
+
+    fill_value = d.pop("fill_value", UNSET)
+
+    view_config = cls(
+      rows=rows,
+      columns=columns,
+      values=values,
+      aggregation_function=aggregation_function,
+      fill_value=fill_value,
+    )
+
+    view_config.additional_properties = d
+    return view_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/view_source.py

@@ -0,0 +1,144 @@
+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 ..models.view_source_type import ViewSourceType
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ViewSource")
+
+
+@_attrs_define
+class ViewSource:
+  """
+  Attributes:
+      type_ (ViewSourceType):
+      period_start (None | str | Unset): Start date for transaction aggregation (YYYY-MM-DD)
+      period_end (None | str | Unset): End date for transaction aggregation (YYYY-MM-DD)
+      fact_set_id (None | str | Unset): FactSet ID for existing facts mode
+      entity_id (None | str | Unset): Filter by entity (optional)
+  """
+
+  type_: ViewSourceType
+  period_start: None | str | Unset = UNSET
+  period_end: None | str | Unset = UNSET
+  fact_set_id: None | str | Unset = UNSET
+  entity_id: None | str | Unset = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    type_ = self.type_.value
+
+    period_start: None | str | Unset
+    if isinstance(self.period_start, Unset):
+      period_start = UNSET
+    else:
+      period_start = self.period_start
+
+    period_end: None | str | Unset
+    if isinstance(self.period_end, Unset):
+      period_end = UNSET
+    else:
+      period_end = self.period_end
+
+    fact_set_id: None | str | Unset
+    if isinstance(self.fact_set_id, Unset):
+      fact_set_id = UNSET
+    else:
+      fact_set_id = self.fact_set_id
+
+    entity_id: None | str | Unset
+    if isinstance(self.entity_id, Unset):
+      entity_id = UNSET
+    else:
+      entity_id = self.entity_id
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "type": type_,
+      }
+    )
+    if period_start is not UNSET:
+      field_dict["period_start"] = period_start
+    if period_end is not UNSET:
+      field_dict["period_end"] = period_end
+    if fact_set_id is not UNSET:
+      field_dict["fact_set_id"] = fact_set_id
+    if entity_id is not UNSET:
+      field_dict["entity_id"] = entity_id
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    type_ = ViewSourceType(d.pop("type"))
+
+    def _parse_period_start(data: object) -> None | str | Unset:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(None | str | Unset, data)
+
+    period_start = _parse_period_start(d.pop("period_start", UNSET))
+
+    def _parse_period_end(data: object) -> None | str | Unset:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(None | str | Unset, data)
+
+    period_end = _parse_period_end(d.pop("period_end", UNSET))
+
+    def _parse_fact_set_id(data: object) -> None | str | Unset:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(None | str | Unset, data)
+
+    fact_set_id = _parse_fact_set_id(d.pop("fact_set_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))
+
+    view_source = cls(
+      type_=type_,
+      period_start=period_start,
+      period_end=period_end,
+      fact_set_id=fact_set_id,
+      entity_id=entity_id,
+    )
+
+    view_source.additional_properties = d
+    return view_source
+
+  @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/view_source_type.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class ViewSourceType(str, Enum):
+  FACT_SET = "fact_set"
+  TRANSACTIONS = "transactions"
+
+  def __str__(self) -> str:
+    return str(self.value)

robosystems_client/types.py

@@ -2,7 +2,7 @@
 
 from collections.abc import Mapping, MutableMapping
 from http import HTTPStatus
-from typing import IO, BinaryIO, Generic, Literal, Optional, TypeVar, Union
+from typing import IO, BinaryIO, Generic, Literal, TypeVar
 
 from attrs import define
 
@@ -15,13 +15,13 @@ class Unset:
 UNSET: Unset = Unset()
 
 # The types that `httpx.Client(files=)` can accept, copied from that library.
-FileContent = Union[IO[bytes], bytes, str]
-FileTypes = Union[
+FileContent = IO[bytes] | bytes | str
+FileTypes = (
   # (filename, file (or bytes), content_type)
-  tuple[Optional[str], FileContent, Optional[str]],
+  tuple[str | None, FileContent, str | None]
   # (filename, file (or bytes), content_type, headers)
-  tuple[Optional[str], FileContent, Optional[str], Mapping[str, str]],
-]
+  | tuple[str | None, FileContent, str | None, Mapping[str, str]]
+)
 RequestFiles = list[tuple[str, FileTypes]]
 
 
@@ -30,8 +30,8 @@ class File:
   """Contains information for file uploads"""
 
   payload: BinaryIO
-  file_name: Optional[str] = None
-  mime_type: Optional[str] = None
+  file_name: str | None = None
+  mime_type: str | None = None
 
   def to_tuple(self) -> FileTypes:
     """Return a tuple representation that httpx will accept for multipart/form-data"""
@@ -48,7 +48,7 @@ class Response(Generic[T]):
   status_code: HTTPStatus
   content: bytes
   headers: MutableMapping[str, str]
-  parsed: Optional[T]
+  parsed: T | None
 
 
 __all__ = ["UNSET", "File", "FileTypes", "RequestFiles", "Response", "Unset"]

{robosystems_client-0.2.15.dist-info → robosystems_client-0.2.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robosystems-client
-Version: 0.2.15
+Version: 0.2.16
 Summary: Python Client for RoboSystems financial graph database API
 Author: RFS LLC
 License: MIT