UncountablePythonSDK 0.0.90__tar.gz → 0.0.91__tar.gz

{uncountablepythonsdk-0.0.90/UncountablePythonSDK.egg-info → uncountablepythonsdk-0.0.91}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: UncountablePythonSDK
-Version: 0.0.90
+Version: 0.0.91
 Summary: Uncountable SDK
 Project-URL: Homepage, https://github.com/uncountableinc/uncountable-python-sdk
 Project-URL: Repository, https://github.com/uncountableinc/uncountable-python-sdk.git
@@ -43,7 +43,7 @@ Requires-Dist: mypy==1.*; extra == "test"
 Requires-Dist: ruff==0.*; extra == "test"
 Requires-Dist: pytest==8.*; extra == "test"
 Requires-Dist: coverage[toml]==7.*; extra == "test"
-Requires-Dist: pytest-cov==5.*; extra == "test"
+Requires-Dist: pytest-cov==6.*; extra == "test"
 Requires-Dist: pytest-xdist==3.*; extra == "test"
 
 # Uncountable Python SDK

{uncountablepythonsdk-0.0.90 → uncountablepythonsdk-0.0.91/UncountablePythonSDK.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: UncountablePythonSDK
-Version: 0.0.90
+Version: 0.0.91
 Summary: Uncountable SDK
 Project-URL: Homepage, https://github.com/uncountableinc/uncountable-python-sdk
 Project-URL: Repository, https://github.com/uncountableinc/uncountable-python-sdk.git
@@ -43,7 +43,7 @@ Requires-Dist: mypy==1.*; extra == "test"
 Requires-Dist: ruff==0.*; extra == "test"
 Requires-Dist: pytest==8.*; extra == "test"
 Requires-Dist: coverage[toml]==7.*; extra == "test"
-Requires-Dist: pytest-cov==5.*; extra == "test"
+Requires-Dist: pytest-cov==6.*; extra == "test"
 Requires-Dist: pytest-xdist==3.*; extra == "test"
 
 # Uncountable Python SDK

{uncountablepythonsdk-0.0.90 → uncountablepythonsdk-0.0.91}/UncountablePythonSDK.egg-info/SOURCES.txt

@@ -26,6 +26,7 @@ docs/static/favicons/mstile-150x150.png
 docs/static/favicons/safari-pinned-tab.svg
 examples/async_batch.py
 examples/create_entity.py
+examples/download_files.py
 examples/edit_recipe_inputs.py
 examples/invoke_uploader.py
 examples/set_recipe_metadata_file.py
@@ -51,14 +52,18 @@ pkgs/filesystem_utils/_sftp_session.py
 pkgs/filesystem_utils/file_type_utils.py
 pkgs/filesystem_utils/filesystem_session.py
 pkgs/serialization/__init__.py
+pkgs/serialization/annotation.py
 pkgs/serialization/missing_sentry.py
 pkgs/serialization/opaque_key.py
+pkgs/serialization/serial_alias.py
 pkgs/serialization/serial_class.py
+pkgs/serialization/serial_generic.py
 pkgs/serialization/serial_union.py
 pkgs/serialization/yaml.py
 pkgs/serialization_util/__init__.py
 pkgs/serialization_util/_get_type_for_serialization.py
 pkgs/serialization_util/convert_to_snakecase.py
+pkgs/serialization_util/dataclasses.py
 pkgs/serialization_util/serialization_helpers.py
 pkgs/strenum_compat/__init__.py
 pkgs/strenum_compat/strenum_compat.py
@@ -237,6 +242,8 @@ uncountable/types/api/equipment/__init__.py
 uncountable/types/api/equipment/associate_equipment_input.py
 uncountable/types/api/field_options/__init__.py
 uncountable/types/api/field_options/upsert_field_options.py
+uncountable/types/api/files/__init__.py
+uncountable/types/api/files/download_file.py
 uncountable/types/api/id_source/__init__.py
 uncountable/types/api/id_source/list_id_source.py
 uncountable/types/api/id_source/match_id_source.py

{uncountablepythonsdk-0.0.90 → uncountablepythonsdk-0.0.91}/UncountablePythonSDK.egg-info/requires.txt

@@ -26,5 +26,5 @@ mypy==1.*
 ruff==0.*
 pytest==8.*
 coverage[toml]==7.*
-pytest-cov==5.*
+pytest-cov==6.*
 pytest-xdist==3.*

{uncountablepythonsdk-0.0.90 → uncountablepythonsdk-0.0.91}/docs/requirements.txt

@@ -1,6 +1,6 @@
 furo==2024.8.6
 myst-parser==4.0.0
-sphinx-autoapi==3.3.0
+sphinx-autoapi==3.4.0
 sphinx-copybutton==0.5.2
 Sphinx==8.1.3
 sphinx_design==0.6.1

uncountablepythonsdk-0.0.91/examples/download_files.py

@@ -0,0 +1,26 @@
+import os
+from pprint import pprint
+
+from uncountable.core import AuthDetailsApiKey, Client
+from uncountable.types import download_file_t, entity_t, identifier_t
+
+client = Client(
+    base_url="http://localhost:5000",
+    auth_details=AuthDetailsApiKey(
+        api_id=os.environ["UNC_API_ID"],
+        api_secret_key=os.environ["UNC_API_SECRET_KEY"],
+    ),
+)
+
+file_query = download_file_t.FileDownloadQueryEntityField(
+    entity=entity_t.EntityIdentifier(
+        type=entity_t.EntityType.LAB_REQUEST,
+        identifier_key=identifier_t.IdentifierKeyId(id=2375),
+    ),
+    field_key=identifier_t.IdentifierKeyRefName(ref_name="attachments"),
+)
+
+downloaded = client.download_files(
+    file_query=file_query,
+)
+pprint(downloaded)

{uncountablepythonsdk-0.0.90 → uncountablepythonsdk-0.0.91}/pkgs/argument_parser/argument_parser.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import dataclasses
 import math
 import types
@@ -6,6 +8,7 @@ from collections import defaultdict
 from dataclasses import MISSING, dataclass
 from datetime import date, datetime
 from decimal import Decimal
+from enum import Enum, auto
 from importlib import resources
 
 import dateutil.parser
@@ -27,11 +30,33 @@ ParserFunction = typing.Callable[[typing.Any], T]
 ParserCache = dict[type[typing.Any], ParserFunction[typing.Any]]
 
 
+class SourceEncoding(Enum):
+    API = auto()
+    STORAGE = auto()
+
+
 @dataclass(frozen=True, eq=True)
 class ParserOptions:
-    convert_to_snake_case: bool
+    encoding: SourceEncoding
     strict_property_parsing: bool = False
 
+    @staticmethod
+    def Api(*, strict_property_parsing: bool = False) -> ParserOptions:
+        return ParserOptions(
+            encoding=SourceEncoding.API, strict_property_parsing=strict_property_parsing
+        )
+
+    @staticmethod
+    def Storage(*, strict_property_parsing: bool = False) -> ParserOptions:
+        return ParserOptions(
+            encoding=SourceEncoding.STORAGE,
+            strict_property_parsing=strict_property_parsing,
+        )
+
+    @property
+    def from_camel_case(self) -> bool:
+        return self.encoding == SourceEncoding.API
+
 
 @dataclass(frozen=True)
 class ParserContext:
@@ -138,20 +163,10 @@ def _build_parser_discriminated_union(
 def _build_parser_inner(
     parsed_type: type[T],
     context: ParserContext,
-    *,
-    convert_string_to_snake_case: bool = False,
 ) -> ParserFunction[T]:
     """
-    convert_to_snake_case - internal flag
-                            if convert_to_snake_case is True, and parsed_type is str,
-                            then the generated parser will convert camel to snake case case
-                            should only be True for cases like dictionary keys
-                            should only be True if options.convert_to_snake_case is True
-
-    NOTE: This argument makes caching at this level difficult, as the cache-map
-    would need to vary based on this argument. For this reason only dataclasses
-    are cached now, as they don't use the argument, and they're known to be safe.
-    This is also enough to support some recursion.
+    IMPROVE: We can now cache at this level, to avoid producing redundant
+    internal parsers.
     """
 
     serial_union = get_serial_union_data(parsed_type)
@@ -184,7 +199,7 @@ def _build_parser_inner(
             field_name: field_parser(
                 value.get(
                     snake_to_camel_case(field_name)
-                    if context.options.convert_to_snake_case
+                    if context.options.from_camel_case
                     else field_name
                 )
             )
@@ -245,23 +260,32 @@ def _build_parser_inner(
         args = typing.get_args(parsed_type)
         if len(args) != 2:
             raise ValueError("Dict types only support two arguments for now")
-        k_parser = _build_parser_inner(
+        k_inner_parser = _build_parser_inner(
             args[0],
             context,
-            convert_string_to_snake_case=context.options.convert_to_snake_case,
         )
+
+        def key_parser(value: typing.Any) -> object:
+            inner = k_inner_parser(value)
+            if (
+                isinstance(inner, str)
+                # enum keys and OpaqueData's would also have string value types,
+                # but their explicit type is not a string, thus shouldn't be converted
+                and args[0] is str
+                and context.options.from_camel_case
+            ):
+                return camel_to_snake_case(value)
+            return inner
+
         v_parser = _build_parser_inner(args[1], context)
         return lambda value: origin(
-            (k_parser(k), v_parser(v)) for k, v in value.items()
+            (key_parser(k), v_parser(v)) for k, v in value.items()
         )
 
     if origin == typing.Literal:
         valid_values: set[T] = set(typing.get_args(parsed_type))
         return lambda value: _invoke_membership_parser(valid_values, value)
 
-    if parsed_type is str and convert_string_to_snake_case:
-        return lambda value: camel_to_snake_case(value)  # type: ignore
-
     if parsed_type is int:
         # first parse ints to decimal to allow scientific notation and decimals
         # e.g. (1) 1e4 => 1000, (2) 3.0 => 3
@@ -320,6 +344,16 @@ def _build_parser_inner(
             raise ValueError("Missing type cannot be parsed directly")
 
         return error
+
+    # Check last for generic annotated types and process them unwrapped
+    # this must be last, since some of the expected types, like Unions,
+    # will also be annotated, but have a special form
+    if typing.get_origin(parsed_type) is typing.Annotated:
+        return _build_parser_inner(
+            parsed_type.__origin__,  # type: ignore[attr-defined]
+            context,
+        )
+
     raise ValueError(f"Unhandled type {parsed_type}")
 
 
@@ -351,7 +385,7 @@ def _build_parser_dataclass(
         return (
             snake_to_camel_case(field_name)
             if (
-                context.options.convert_to_snake_case
+                context.options.from_camel_case
                 and not serial_class_data.has_unconverted_key(field_name)
             )
             else field_name
@@ -474,8 +508,7 @@ class CachedParser(typing.Generic[T]):
         if self.parser_api is None:
             self.parser_api = build_parser(
                 self.arguments,
-                ParserOptions(
-                    convert_to_snake_case=True,
+                ParserOptions.Api(
                     strict_property_parsing=self.strict_property_parsing,
                 ),
             )
@@ -489,8 +522,7 @@ class CachedParser(typing.Generic[T]):
         if self.parser_storage is None:
             self.parser_storage = build_parser(
                 self.arguments,
-                ParserOptions(
-                    convert_to_snake_case=False,
+                ParserOptions.Storage(
                     strict_property_parsing=self.strict_property_parsing,
                 ),
             )

{uncountablepythonsdk-0.0.90 → uncountablepythonsdk-0.0.91}/pkgs/serialization/__init__.py

@@ -1,13 +1,17 @@
-# flake8:noqa
+from .annotation import unwrap_annotated as unwrap_annotated
 from .missing_sentry import MISSING_SENTRY as MISSING_SENTRY
 from .missing_sentry import MissingSentryType as MissingSentryType
 from .missing_sentry import MissingType as MissingType
 from .missing_sentry import coalesce_missing_sentry as coalesce_missing_sentry
 from .opaque_key import OpaqueKey as OpaqueKey
+from .serial_alias import SerialAliasInspector as SerialAliasInspector
+from .serial_alias import get_serial_alias_data as get_serial_alias_data
+from .serial_alias import serial_alias_annotation as serial_alias_annotation
+from .serial_class import SerialClassDataInspector as SerialClassDataInspector
 from .serial_class import get_serial_class_data as get_serial_class_data
 from .serial_class import get_serial_string_enum_data as get_serial_string_enum_data
 from .serial_class import serial_class as serial_class
 from .serial_class import serial_string_enum as serial_string_enum
-from .serial_class import SerialClassDataInspector as SerialClassDataInspector
-from .serial_union import serial_union_annotation as serial_union_annotation
+from .serial_generic import get_serial_data as get_serial_data
 from .serial_union import get_serial_union_data as get_serial_union_data
+from .serial_union import serial_union_annotation as serial_union_annotation

uncountablepythonsdk-0.0.91/pkgs/serialization/annotation.py

@@ -0,0 +1,64 @@
+import dataclasses
+import typing
+
+T = typing.TypeVar("T")
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True, eq=True)
+class SerialBase:
+    named_type_path: typing.Optional[str] = None
+    # Indicates this type is allowed in dynamic lookups, such as via a named_type_path
+    # This isn't meant to be limting, but to catalog all the types where we need it
+    is_dynamic_allowed: bool = False
+    # Tracks if this data was provided as a decorator to the type.
+    # This is used to track "proper types" which are appropriate
+    # for serialization and/or dynamic discovery
+    from_decorator: bool = False
+
+
+def get_serial_annotation(parsed_type: type[T]) -> SerialBase | None:
+    if not hasattr(parsed_type, "__metadata__"):
+        return None
+    metadata = parsed_type.__metadata__  # type:ignore[attr-defined]
+    if not isinstance(metadata, tuple) or len(metadata) != 1:
+        return None
+    serial = metadata[0]
+    if not isinstance(serial, SerialBase):
+        return None
+    return serial
+
+
+class SerialInspector(typing.Generic[T]):
+    def __init__(self, parsed_type: type[T], serial_base: SerialBase) -> None:
+        self._parsed_type = parsed_type
+        self._serial_base = serial_base
+
+    @property
+    def named_type_path(self) -> typing.Optional[str]:
+        return self._serial_base.named_type_path
+
+    @property
+    def from_decorator(self) -> bool:
+        return self._serial_base.from_decorator
+
+    @property
+    def is_field_proper(self) -> bool:
+        return (
+            self._serial_base.from_decorator
+            and self._serial_base.named_type_path is not None
+        )
+
+    @property
+    def is_dynamic_allowed(self) -> bool:
+        return self._serial_base.is_dynamic_allowed
+
+
+def unwrap_annotated(parsed_type: type[T]) -> type[T]:
+    """
+    If the type is an annotated type then return the origin of it.
+    Otherwise return the original type.
+    """
+    if typing.get_origin(parsed_type) is typing.Annotated:
+        # It's unclear if there's anyway to type this correctly
+        return parsed_type.__origin__  # type:ignore[attr-defined, no-any-return]
+    return parsed_type

uncountablepythonsdk-0.0.91/pkgs/serialization/serial_alias.py

@@ -0,0 +1,47 @@
+import dataclasses
+import typing
+
+from .annotation import SerialBase, SerialInspector, get_serial_annotation
+
+T = typing.TypeVar("T")
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True, eq=True)
+class _SerialAlias(SerialBase):
+    """
+    This class is to be kept private, to provide flexibility in registration/lookup.
+    Places that need the data should access it via help classes/methods.
+    """
+
+
+def serial_alias_annotation(
+    *,
+    named_type_path: typing.Optional[str] = None,
+    is_dynamic_allowed: bool = False,
+) -> _SerialAlias:
+    return _SerialAlias(
+        named_type_path=named_type_path,
+        from_decorator=True,
+        is_dynamic_allowed=is_dynamic_allowed,
+    )
+
+
+def _get_serial_alias(parsed_type: type[T]) -> _SerialAlias | None:
+    serial = get_serial_annotation(parsed_type)
+    if not isinstance(serial, _SerialAlias):
+        return None
+    return serial
+
+
+class SerialAliasInspector(SerialInspector[T]):
+    def __init__(self, parsed_type: type[T], serial_alias: _SerialAlias) -> None:
+        super().__init__(parsed_type, serial_alias)
+        self._serial_alias = serial_alias
+
+
+def get_serial_alias_data(parsed_type: type[T]) -> SerialAliasInspector[T] | None:
+    serial = _get_serial_alias(parsed_type)
+    if serial is None:
+        return None
+
+    return SerialAliasInspector(parsed_type, serial)

{uncountablepythonsdk-0.0.90 → uncountablepythonsdk-0.0.91}/pkgs/serialization/serial_class.py

@@ -5,20 +5,18 @@ from collections.abc import Callable
 from enum import StrEnum
 from typing import Any, Optional, TypeVar, cast
 
+from .annotation import SerialBase, SerialInspector
+
 _ClassT = TypeVar("_ClassT")
 
 
-@dataclasses.dataclass
-class _SerialClassData:
+@dataclasses.dataclass(kw_only=True, frozen=True, eq=True)
+class _SerialClassData(SerialBase):
     unconverted_keys: set[str] = dataclasses.field(default_factory=set)
     unconverted_values: set[str] = dataclasses.field(default_factory=set)
     to_string_values: set[str] = dataclasses.field(default_factory=set)
     parse_require: set[str] = dataclasses.field(default_factory=set)
     named_type_path: Optional[str] = None
-    # Tracks if this data was provided as a decorator to the type.
-    # This is used to track "proper types" which are appropriate
-    # for serialization and/or dynamic discovery
-    from_decorator: bool = False
 
 
 EMPTY_SERIAL_CLASS_DATA = _SerialClassData()
@@ -31,6 +29,7 @@ def serial_class(
     to_string_values: Optional[set[str]] = None,
     parse_require: Optional[set[str]] = None,
     named_type_path: Optional[str] = None,
+    is_dynamic_allowed: bool = False,
 ) -> Callable[[_ClassT], _ClassT]:
     """
     An additional decorator to a dataclass that specifies serialization options.
@@ -63,17 +62,20 @@ def serial_class(
             parse_require=parse_require or set(),
             named_type_path=named_type_path,
             from_decorator=True,
+            is_dynamic_allowed=is_dynamic_allowed,
         )
         return orig_class
 
     return decorate
 
 
-class SerialClassDataInspector:
+class SerialClassDataInspector(SerialInspector[_ClassT]):
     def __init__(
         self,
+        parsed_type: type[_ClassT],
         current: _SerialClassData,
     ) -> None:
+        super().__init__(parsed_type, current)
         self.current = current
 
     def has_unconverted_key(self, key: str) -> bool:
@@ -88,20 +90,8 @@ class SerialClassDataInspector:
     def has_parse_require(self, key: str) -> bool:
         return key in self.current.parse_require
 
-    @property
-    def from_decorator(self) -> bool:
-        return self.current.from_decorator
-
-    @property
-    def named_type_path(self) -> Optional[str]:
-        return self.current.named_type_path
-
-    @property
-    def is_field_proper(self) -> bool:
-        return self.current.from_decorator and self.current.named_type_path is not None
 
-
-def _get_merged_serial_class_data(type_class: type[Any]) -> _SerialClassData | None:
+def get_merged_serial_class_data(type_class: type[Any]) -> _SerialClassData | None:
     base_class_data = (
         cast(_SerialClassData, type_class.__unc_serial_data)
         if hasattr(type_class, "__unc_serial_data")
@@ -110,26 +100,30 @@ def _get_merged_serial_class_data(type_class: type[Any]) -> _SerialClassData | N
     if base_class_data is None:
         return None
 
+    # IMPROVE: We should cache this result on the type
     if type_class.__bases__ is not None:
         for base in type_class.__bases__:
-            curr_base_class_data = _get_merged_serial_class_data(base)
+            curr_base_class_data = get_merged_serial_class_data(base)
             if curr_base_class_data is not None:
-                base_class_data.unconverted_keys |= (
-                    curr_base_class_data.unconverted_keys
-                )
-                base_class_data.unconverted_values |= (
-                    curr_base_class_data.unconverted_values
-                )
-                base_class_data.to_string_values |= (
-                    curr_base_class_data.to_string_values
+                base_class_data = dataclasses.replace(
+                    base_class_data,
+                    unconverted_keys=base_class_data.unconverted_keys
+                    | curr_base_class_data.unconverted_keys,
+                    unconverted_values=base_class_data.unconverted_values
+                    | curr_base_class_data.unconverted_values,
+                    to_string_values=base_class_data.to_string_values
+                    | curr_base_class_data.to_string_values,
+                    parse_require=base_class_data.parse_require
+                    | curr_base_class_data.parse_require,
                 )
-                base_class_data.parse_require |= curr_base_class_data.parse_require
     return base_class_data
 
 
-def get_serial_class_data(type_class: type[Any]) -> SerialClassDataInspector:
+def get_serial_class_data(
+    type_class: type[_ClassT],
+) -> SerialClassDataInspector[_ClassT]:
     return SerialClassDataInspector(
-        _get_merged_serial_class_data(type_class) or EMPTY_SERIAL_CLASS_DATA
+        type_class, get_merged_serial_class_data(type_class) or EMPTY_SERIAL_CLASS_DATA
     )
 
 

uncountablepythonsdk-0.0.91/pkgs/serialization/serial_generic.py

@@ -0,0 +1,16 @@
+import typing
+
+from .annotation import SerialInspector, get_serial_annotation
+from .serial_class import get_merged_serial_class_data
+
+T = typing.TypeVar("T")
+
+
+def get_serial_data(parsed_type: type[T]) -> SerialInspector[T] | None:
+    serial = get_serial_annotation(parsed_type)
+    if serial is None:
+        serial = get_merged_serial_class_data(parsed_type)
+
+    if serial is not None:
+        return SerialInspector(parsed_type, serial)
+    return None

{uncountablepythonsdk-0.0.90 → uncountablepythonsdk-0.0.91}/pkgs/serialization/serial_union.py

@@ -1,6 +1,8 @@
 import dataclasses
 import typing
 
+from .annotation import SerialBase, SerialInspector, get_serial_annotation
+
 T = typing.TypeVar("T")
 
 
@@ -17,7 +19,7 @@ class IdentityHashWrapper(typing.Generic[T]):
 
 
 @dataclasses.dataclass(kw_only=True, frozen=True, eq=True)
-class _SerialUnion:
+class _SerialUnion(SerialBase):
     """
     This class is to be kept private, to provide flexibility in registration/lookup.
     Places that need the data should access it via help classes/methods.
@@ -27,7 +29,6 @@ class _SerialUnion:
     # determine which type to parse.
     discriminator: typing.Optional[str] = None
     discriminator_map: typing.Optional[IdentityHashWrapper[dict[str, type]]] = None
-    named_type_path: typing.Optional[str] = None
 
 
 def serial_union_annotation(
@@ -35,6 +36,7 @@ def serial_union_annotation(
     discriminator: typing.Optional[str] = None,
     discriminator_map: typing.Optional[dict[str, type]] = None,
     named_type_path: typing.Optional[str] = None,
+    is_dynamic_allowed: bool = False,
 ) -> _SerialUnion:
     return _SerialUnion(
         discriminator=discriminator,
@@ -42,23 +44,21 @@ def serial_union_annotation(
         if discriminator_map is not None
         else None,
         named_type_path=named_type_path,
+        from_decorator=True,
+        is_dynamic_allowed=is_dynamic_allowed,
     )
 
 
 def _get_serial_union(parsed_type: type[T]) -> _SerialUnion | None:
-    if not hasattr(parsed_type, "__metadata__"):
-        return None
-    metadata = parsed_type.__metadata__  # type:ignore[attr-defined]
-    if not isinstance(metadata, tuple) or len(metadata) != 1:
-        return None
-    serial = metadata[0]
+    serial = get_serial_annotation(parsed_type)
     if not isinstance(serial, _SerialUnion):
         return None
     return serial
 
 
-class SerialClassInspector(typing.Generic[T]):
+class SerialClassInspector(SerialInspector[T]):
     def __init__(self, parsed_type: type[T], serial_union: _SerialUnion) -> None:
+        super().__init__(parsed_type, serial_union)
         self._parsed_type = parsed_type
         self._serial_union = serial_union
 

{uncountablepythonsdk-0.0.90 → uncountablepythonsdk-0.0.91}/pkgs/serialization_util/__init__.py

@@ -1,4 +1,6 @@
 from .convert_to_snakecase import convert_dict_to_snake_case
+from .dataclasses import dict_fields as dict_fields
+from .dataclasses import iterate_fields as iterate_fields
 from .serialization_helpers import (
     serialize_for_api,
     serialize_for_storage,
@@ -10,4 +12,6 @@ __all__: list[str] = [
     "serialize_for_api",
     "serialize_for_storage",
     "serialize_for_storage_dict",
+    "iterate_fields",
+    "dict_fields",
 ]

uncountablepythonsdk-0.0.91/pkgs/serialization_util/dataclasses.py

@@ -0,0 +1,14 @@
+from dataclasses import fields
+from typing import TYPE_CHECKING, Any, Iterator
+
+if TYPE_CHECKING:
+    from _typeshed import DataclassInstance
+
+
+def iterate_fields(d: "DataclassInstance") -> Iterator[tuple[str, Any]]:
+    for field in fields(d):
+        yield field.name, getattr(d, field.name)
+
+
+def dict_fields(d: "DataclassInstance") -> dict[str, Any]:
+    return dict(iterate_fields(d))