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

pkgs/serialization/serial_union.py

@@ -0,0 +1,84 @@
+import dataclasses
+import typing
+
+from .annotation import SerialBase, SerialInspector, get_serial_annotation
+
+T = typing.TypeVar("T")
+
+
+class IdentityHashWrapper(typing.Generic[T]):
+    """This allows unhashable types to be used in the SerialUnion, like dict.
+    Since we have only one copy of the types themselves, we rely on
+    object identity for the hashing."""
+
+    def __init__(self, inner: T) -> None:
+        self.inner = inner
+
+    def __hash__(self) -> int:
+        return id(self.inner)
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True, eq=True)
+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.
+    """
+
+    # If specified, indicates the Union has a discriminator which should be used to
+    # determine which type to parse.
+    discriminator: str | None = None
+    discriminator_map: IdentityHashWrapper[dict[str, type]] | None = None
+
+
+def serial_union_annotation(
+    *,
+    discriminator: str | None = None,
+    discriminator_map: dict[str, type] | None = None,
+    named_type_path: str | None = None,
+    is_dynamic_allowed: bool = False,
+) -> _SerialUnion:
+    return _SerialUnion(
+        discriminator=discriminator,
+        discriminator_map=IdentityHashWrapper(discriminator_map)
+        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:
+    serial = get_serial_annotation(parsed_type)
+    if not isinstance(serial, _SerialUnion):
+        return None
+    return serial
+
+
+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
+
+    def get_union_underlying(self) -> type[T]:
+        return typing.get_args(self._parsed_type)[0]  # type:ignore[no-any-return]
+
+    @property
+    def discriminator(self) -> str | None:
+        return self._serial_union.discriminator
+
+    @property
+    def discriminator_map(self) -> dict[str, type] | None:
+        if self._serial_union.discriminator_map is None:
+            return None
+        return self._serial_union.discriminator_map.inner
+
+
+def get_serial_union_data(parsed_type: type[T]) -> SerialClassInspector[T] | None:
+    serial = _get_serial_union(parsed_type)
+    if serial is None:
+        return None
+
+    return SerialClassInspector(parsed_type, serial)

pkgs/serialization/yaml.py

@@ -0,0 +1,57 @@
+from decimal import Decimal
+from typing import TYPE_CHECKING, Any
+
+import yaml
+
+if TYPE_CHECKING:
+    from _typeshed import SupportsRead as SupportsReadT
+    from _typeshed import SupportsWrite as SupportsWriteT
+
+    SupportsRead = SupportsReadT[Any]
+    SupportsWrite = SupportsWriteT[Any]
+else:
+    SupportsRead = object
+    SupportsWrite = object
+
+
+def _decimal_constructor(loader, node):  # type:ignore
+    value = loader.construct_scalar(node)
+    return Decimal(value)
+
+
+# A semi-acceptable patch to force a number to be parsed as a decimal, since pyyaml
+# parses them as lossy floats otherwise. Though a bit ugly, at least this way we have
+# support for decimal constants
+yaml.SafeLoader.add_constructor("!decimal", _decimal_constructor)
+
+
+class YAMLError(BaseException):
+    pass
+
+
+def dumps(obj: Any, sort_keys: bool = False) -> str:
+    return yaml.dump(obj, sort_keys=sort_keys)
+
+
+def dump(obj: Any, f: SupportsWrite, sort_keys: bool = False) -> None:
+    yaml.dump(obj, f, sort_keys=sort_keys)
+
+
+def safe_load(src: str | bytes | SupportsRead) -> Any:
+    try:
+        return yaml.safe_load(src)
+    except yaml.YAMLError as e:
+        raise YAMLError() from e
+
+
+def safe_dump(
+    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)
+
+
+def c_load(f: SupportsRead) -> Any:
+    return yaml.load(f, Loader=yaml.CLoader)

pkgs/serialization_util/__init__.py

@@ -1,8 +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 (
-    convert_dict_to_snake_case,
-    convert_to_camelcase,
-    resolve_missing_to_none,
-    serialize,
+    JsonValue,
     serialize_for_api,
     serialize_for_storage,
     serialize_for_storage_dict,
@@ -10,10 +10,10 @@ from .serialization_helpers import (
 
 __all__: list[str] = [
     "convert_dict_to_snake_case",
-    "convert_to_camelcase",
-    "resolve_missing_to_none",
-    "serialize",
     "serialize_for_api",
     "serialize_for_storage",
     "serialize_for_storage_dict",
+    "iterate_fields",
+    "dict_fields",
+    "JsonValue",
 ]

pkgs/serialization_util/convert_to_snakecase.py

@@ -0,0 +1,27 @@
+from typing import (
+    Any,
+)
+
+from pkgs.argument_parser import camel_to_snake_case
+from pkgs.serialization import (
+    MISSING_SENTRY,
+    OpaqueKey,
+)
+
+
+def _key_convert_to_snake_case(o: Any) -> Any:
+    if isinstance(o, OpaqueKey):
+        return o
+    if isinstance(o, str):
+        return camel_to_snake_case(o)
+    return o
+
+
+def convert_dict_to_snake_case(data: Any) -> Any:
+    return {
+        _key_convert_to_snake_case(k): convert_dict_to_snake_case(v)
+        if isinstance(v, dict)
+        else v
+        for k, v in data.items()
+        if v != MISSING_SENTRY
+    }

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

@@ -1,25 +1,31 @@
+# warnings -- types here assume that keys to dictionaries are strings
+# this is true most of the time, but there are cases where we have integer indexes
+
+import dataclasses
 import datetime
 import enum
+import functools
 from collections.abc import Callable, Mapping, Sequence
 from decimal import Decimal
 from typing import (
     TYPE_CHECKING,
     Any,
-    Optional,
+    ClassVar,
+    Protocol,
     TypeVar,
     Union,
+    overload,
 )
 
-from pkgs.argument_parser import camel_to_snake_case, snake_to_camel_case
+from pkgs.argument_parser import snake_to_camel_case
 from pkgs.serialization import (
     MISSING_SENTRY,
-    MissingSentryType,
-    MissingType,
     OpaqueKey,
     get_serial_class_data,
 )
 
 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]
@@ -28,53 +34,103 @@ if TYPE_CHECKING:
 else:
     JsonValue = Union[JsonScalar, dict[str, Any], list[Any]]
 
+T = TypeVar("T")
+
+
+class Dataclass(Protocol):
+    __dataclass_fields__: ClassVar[dict]  # type: ignore[type-arg,unused-ignore]
+
+
+def identity(x: T) -> T:
+    return x
 
-def key_convert_to_camelcase(o: Any) -> Any:
+
+@overload
+def key_convert_to_camelcase(o: str) -> str: ...
+
+
+@overload
+def key_convert_to_camelcase(o: int) -> int: ...
+
+
+def key_convert_to_camelcase(o: Any) -> str | int:
     if isinstance(o, OpaqueKey):
         return o
-    if isinstance(o, enum.Enum):
+    if isinstance(o, enum.StrEnum):
         return o.value
     if isinstance(o, str):
         return snake_to_camel_case(o)
-    return o
+    if isinstance(o, int):
+        # we allow dictionaries to use integer keys
+        return o
+    raise ValueError("Unexpected key type", o)
 
 
-def _convert_dict(d: Any) -> Any:
+def _convert_dict(d: dict[str, Any]) -> dict[str, JsonValue]:
     return {
-        key_convert_to_camelcase(k): convert_to_camelcase(v)
+        key_convert_to_camelcase(k): serialize_for_api(v)
         for k, v in d.items()
         if v != MISSING_SENTRY
     }
 
 
-def _serialize_dict(d: Any) -> dict[str, Any]:
-    return {k: serialize(v) for k, v in d.items() if v != MISSING_SENTRY}
+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 _convert_dataclass(d: Any) -> Any:
-    dct = type(d)
-    scd = get_serial_class_data(dct)
+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)), (
+        f"Expecting decimal or int, received: {value} (type={type(value)})"
+    )
+    return str(value)
+
+
+@dataclasses.dataclass(kw_only=True)
+class DataclassConversions:
+    key_conversions: dict[str, str]
+    value_conversion_functions: dict[str, Callable[[Any], JsonValue]]
 
-    def key_convert(key: Any) -> Any:
+
+@functools.lru_cache(maxsize=10000)
+def _get_dataclass_conversion_lookups(dataclass_type: Any) -> DataclassConversions:
+    scd = get_serial_class_data(dataclass_type)
+
+    key_conversions: dict[str, str] = {}
+    value_conversion_functions: dict[str, Callable[[Any], JsonValue]] = {}
+
+    for field in dataclasses.fields(dataclass_type):
+        key = field.name
         if scd.has_unconverted_key(key):
-            return key
-        return key_convert_to_camelcase(key)
+            key_conversions[key] = key
+        else:
+            key_conversions[key] = key_convert_to_camelcase(key)
 
-    def value_convert(key: Any, value: Any) -> Any:
-        if value is None:
-            return None
         if scd.has_to_string_value(key):
-            # Limit to types we know we need to support to avoid surprises
-            # Generics, like List/Dict would need to be per-value stringified
-            assert isinstance(value, (Decimal, int))
-            return str(value)
-        if scd.has_unconverted_value(key):
-            return value
-        return convert_to_camelcase(value)
+            value_conversion_functions[key] = _to_string_value
+        elif scd.has_unconverted_value(key):
+            value_conversion_functions[key] = serialize_for_storage
+        else:
+            value_conversion_functions[key] = serialize_for_api
 
+    return DataclassConversions(
+        key_conversions=key_conversions,
+        value_conversion_functions=value_conversion_functions,
+    )
+
+
+def _convert_dataclass(d: Any) -> dict[str, JsonValue]:
+    conversions = _get_dataclass_conversion_lookups(type(d))  # type: ignore[arg-type]
     return {
-        key_convert(k): value_convert(k, v)
-        for k, v in d.__dict__.items()
+        conversions.key_conversions[k]: (
+            conversions.value_conversion_functions[k](v) if v is not None else None
+        )
+        for k, v in iterate_fields(d)
         if v != MISSING_SENTRY
     }
 
@@ -83,38 +139,54 @@ _SERIALIZATION_FUNCS_STANDARD = {
     SerializationType.ENUM: lambda x: str(x.value),
     SerializationType.DATE: lambda x: x.isoformat(),
     SerializationType.TIMEDELTA: lambda x: x.total_seconds(),
-    SerializationType.UNKNOWN: lambda x: x,
+    SerializationType.UNKNOWN: identity,
 }
 
-_CONVERSION_SERIALIZATION_FUNCS = {
+_CONVERSION_SERIALIZATION_FUNCS: dict[SerializationType, Callable[[Any], JsonValue]] = {
     **_SERIALIZATION_FUNCS_STANDARD,
     SerializationType.NAMED_TUPLE: lambda x: _convert_dict(x._asdict()),
-    SerializationType.ITERABLE: lambda x: [convert_to_camelcase(v) for v in x],
+    SerializationType.ITERABLE: lambda x: [serialize_for_api(v) for v in x],
     SerializationType.DICT: _convert_dict,
     SerializationType.DATACLASS: _convert_dataclass,
 }
 
 
-def convert_to_camelcase(obj: Any) -> Any:
-    """@DEPRECATED prefer serialize_for_api"""
-    return serialize_for_api(obj)
+@overload
+def serialize_for_api(obj: None) -> None: ...
+
 
+@overload
+def serialize_for_api(obj: dict[str, Any]) -> dict[str, JsonValue]: ...
 
-def serialize_for_api(obj: Any) -> Any:
+
+@overload
+def serialize_for_api(obj: Dataclass) -> dict[str, JsonValue]: ...
+
+
+@overload
+def serialize_for_api(obj: Any) -> JsonValue: ...
+
+
+def serialize_for_api(obj: Any) -> JsonValue:
     """
     Serialize to a parsed-JSON format suitably encoded for API output.
 
     Use the CachedParser.parse_api to parse this data.
     """
     serialization_type = get_serialization_type(type(obj))  # type: ignore
-    return _CONVERSION_SERIALIZATION_FUNCS[serialization_type](obj)
+    if (
+        serialization_type == SerializationType.UNKNOWN
+    ):  # performance optimization to not do function lookup
+        return obj  # type: ignore
+    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,
 }
 
 
@@ -122,15 +194,10 @@ _SERIALIZATION_FUNCS: dict[SerializationType, Callable[[Any], JsonValue]] = {
     **_SERIALIZATION_FUNCS_STANDARD,
     **_SERIALIZATION_FUNCS_DICT,
     SerializationType.NAMED_TUPLE: lambda x: _serialize_dict(x._asdict()),
-    SerializationType.ITERABLE: lambda x: [serialize(v) for v in x],
+    SerializationType.ITERABLE: lambda x: [serialize_for_storage(v) for v in x],
 }
 
 
-def serialize(obj: Any) -> Any:
-    """@DEPRECATED: prefer serialize_for_storage"""
-    return serialize_for_storage(obj)
-
-
 def serialize_for_storage(obj: Any) -> JsonValue:
     """
     Convert a value into the pseudo-JSON form for
@@ -139,37 +206,16 @@ def serialize_for_storage(obj: Any) -> JsonValue:
     Use the CachedParser.parse_storage to parse this data.
     """
     serialization_type = get_serialization_type(type(obj))  # type: ignore
+    if (
+        serialization_type == SerializationType.UNKNOWN
+    ):  # performance optimization to not do function lookup
+        return obj  # type: ignore
     return _SERIALIZATION_FUNCS[serialization_type](obj)
 
 
-def serialize_for_storage_dict(obj: Any) -> dict[str, JsonValue]:
+def serialize_for_storage_dict(obj: dict | Dataclass) -> dict[str, JsonValue]:  # type: ignore[type-arg]
     """
     Same as serialize for storage but guarantees outer object is a dictionary
     """
-    serialization_type = get_serialization_type(type(obj))  # type: ignore
+    serialization_type = get_serialization_type(type(obj))
     return _SERIALIZATION_FUNCS_DICT[serialization_type](obj)
-
-
-def key_convert_to_snake_case(o: Any) -> Any:
-    if isinstance(o, OpaqueKey):
-        return o
-    if isinstance(o, str):
-        return camel_to_snake_case(o)
-    return o
-
-
-def convert_dict_to_snake_case(data: Any) -> Any:
-    return {
-        key_convert_to_snake_case(k): convert_dict_to_snake_case(v)
-        if isinstance(v, dict)
-        else v
-        for k, v in data.items()
-        if v != MISSING_SENTRY
-    }
-
-
-T = TypeVar("T")
-
-
-def resolve_missing_to_none(val: MissingType[T]) -> Optional[T]:
-    return val if not isinstance(val, MissingSentryType) else None

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