UncountablePythonSDK 0.0.52__py3-none-any.whl → 0.0.131__py3-none-any.whl

pkgs/serialization/yaml.py

@@ -45,7 +45,10 @@ def safe_load(src: str | bytes | SupportsRead) -> Any:
 
 
 def safe_dump(
-    obj: Any, sort_keys: bool = False, indent: int | None = None, width: int | None = None
+    obj: Any,
+    sort_keys: bool = False,
+    indent: int | None = None,
+    width: int | None = None,
 ) -> str:
     return yaml.safe_dump(obj, sort_keys=sort_keys, indent=indent, width=width)
 

pkgs/serialization_util/__init__.py

@@ -1,5 +1,8 @@
 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 (
+    JsonValue,
     serialize_for_api,
     serialize_for_storage,
     serialize_for_storage_dict,
@@ -10,4 +13,7 @@ __all__: list[str] = [
     "serialize_for_api",
     "serialize_for_storage",
     "serialize_for_storage_dict",
+    "iterate_fields",
+    "dict_fields",
+    "JsonValue",
 ]

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))

pkgs/serialization_util/serialization_helpers.py

@@ -25,6 +25,7 @@ from pkgs.serialization import (
 )
 
 from ._get_type_for_serialization import SerializationType, get_serialization_type
+from .dataclasses import iterate_fields
 
 # Inlined types which otherwise would import from types/base.py
 JsonScalar = Union[str, float, bool, Decimal, None, datetime.datetime, datetime.date]
@@ -77,8 +78,16 @@ def _serialize_dict(d: dict[str, Any]) -> dict[str, JsonValue]:
     return {k: serialize_for_storage(v) for k, v in d.items() if v != MISSING_SENTRY}
 
 
+def _serialize_dataclass(d: Any) -> dict[str, JsonValue]:
+    return {
+        k: serialize_for_storage(v) for k, v in iterate_fields(d) if v != MISSING_SENTRY
+    }
+
+
 def _to_string_value(value: Any) -> str:
-    assert isinstance(value, (Decimal, int))
+    assert isinstance(value, (Decimal, int)), (
+        f"Expecting decimal or int, received: {value} (type={type(value)})"
+    )
     return str(value)
 
 
@@ -105,7 +114,7 @@ def _get_dataclass_conversion_lookups(dataclass_type: Any) -> DataclassConversio
         if scd.has_to_string_value(key):
             value_conversion_functions[key] = _to_string_value
         elif scd.has_unconverted_value(key):
-            value_conversion_functions[key] = identity
+            value_conversion_functions[key] = serialize_for_storage
         else:
             value_conversion_functions[key] = serialize_for_api
 
@@ -121,7 +130,7 @@ def _convert_dataclass(d: Any) -> dict[str, JsonValue]:
         conversions.key_conversions[k]: (
             conversions.value_conversion_functions[k](v) if v is not None else None
         )
-        for k, v in d.__dict__.items()
+        for k, v in iterate_fields(d)
         if v != MISSING_SENTRY
     }
 
@@ -169,14 +178,15 @@ def serialize_for_api(obj: Any) -> JsonValue:
         serialization_type == SerializationType.UNKNOWN
     ):  # performance optimization to not do function lookup
         return obj  # type: ignore
-    return _CONVERSION_SERIALIZATION_FUNCS[serialization_type](obj)
+    r = _CONVERSION_SERIALIZATION_FUNCS[serialization_type](obj)
+    return r
 
 
 _SERIALIZATION_FUNCS_DICT: dict[
     SerializationType, Callable[[Any], dict[str, JsonValue]]
 ] = {
     SerializationType.DICT: _serialize_dict,
-    SerializationType.DATACLASS: lambda x: _serialize_dict(x.__dict__),
+    SerializationType.DATACLASS: _serialize_dataclass,
 }
 
 

pkgs/type_spec/actions_registry/__main__.py

@@ -6,7 +6,6 @@ import os
 import sys
 from collections import defaultdict
 from dataclasses import dataclass
-from typing import TypeVar
 
 from main.base.types import actions_registry_t
 from pkgs.type_spec import builder
@@ -22,9 +21,6 @@ key_short_description = "short_description"
 key_description = "description"
 
 
-TypeT = TypeVar("TypeT")
-
-
 class InvalidSpecException(Exception):
     pass
 

pkgs/type_spec/actions_registry/emit_typescript.py

@@ -64,7 +64,7 @@ def _emit_imports(
         sorted([f"type {_action_namespace_name(item)}" for item in list(namespaces)])
     )
     out.write(
-        f'import {{ ActionsRegistryT, {namespaces_to_import} }} from "unc_mat/types"\n\n'
+        f'import {{ ActionsRegistryT, {namespaces_to_import} }} from "unc_types"\n\n'
     )
     out.write(MODIFY_NOTICE)
     return out.getvalue()
@@ -111,9 +111,7 @@ def _get_argument_type(arguments: str | None) -> str | None:
     argument_parts = arguments.split(".")
     namespace = argument_parts[0]
     type_name = argument_parts[1]
-    if namespace is not None and type_name is not None:
-        return f"{_action_namespace_name(namespace)}.{type_name}"
-    return None
+    return f"{_action_namespace_name(namespace)}.{type_name}"
 
 
 def _emit_action_definition(
@@ -129,7 +127,9 @@ def _emit_action_definition(
     out.write(f"{indent}{_action_symbol_name(action_definition)}: {{\n")
     out.write(f"{sub_indent}name: {encode_common_string(action_definition.name)},\n")
     if action_definition.icon is not None:
-        out.write(f"{sub_indent}icon: {encode_common_string(action_definition.icon)},\n")
+        out.write(
+            f"{sub_indent}icon: {encode_common_string(action_definition.icon)},\n"
+        )
     out.write(
         f"{sub_indent}shortDescription: {encode_common_string(action_definition.short_description)},\n"
     )