UncountablePythonSDK 0.0.83__py3-none-any.whl → 0.0.132__py3-none-any.whl

pkgs/filesystem_utils/file_type_utils.py

@@ -1,9 +1,15 @@
 import os
 from dataclasses import dataclass
 from io import BytesIO
-from typing import Optional, Union
+from typing import Union
 
 import paramiko
+from azure.core.credentials import (
+    AzureNamedKeyCredential,
+    AzureSasCredential,
+    TokenCredential,
+)
+from azure.storage.blob import ContainerProperties
 
 
 @dataclass
@@ -11,9 +17,9 @@ class FileObjectData:
     file_data: bytes
     file_IO: BytesIO
     filename: str
-    filepath: Optional[str] = None
-    mime_type: Optional[str] = None
-    metadata: Optional[dict[str, str]] = None
+    filepath: str | None = None
+    mime_type: str | None = None
+    metadata: dict[str, str] | None = None
 
 
 @dataclass
@@ -33,7 +39,7 @@ class FileSystemFileReference:
 class RemoteObjectReference:
     file_id: str
     mime_type: str
-    filename: Optional[str] = None
+    filename: str | None = None
 
     @property
     def is_dir(self) -> bool:
@@ -57,7 +63,7 @@ class FileSystemSFTPConfig:
     pem_path: str | None
     pem_key: paramiko.RSAKey | None = None
     password: str | None = None
-    valid_extensions: Optional[tuple[str]] = None
+    valid_extensions: tuple[str] | None = None
     recursive: bool = True
 
 
@@ -65,7 +71,21 @@ class FileSystemSFTPConfig:
 class FileSystemS3Config:
     endpoint_url: str
     bucket_name: str
-    region_name: Optional[str]
-    access_key_id: Optional[str]
-    secret_access_key: Optional[str]
-    session_token: Optional[str]
+    region_name: str | None
+    access_key_id: str | None
+    secret_access_key: str | None
+    session_token: str | None
+
+
+@dataclass(kw_only=True)
+class FileSystemBlobConfig:
+    account_url: str
+    credential: (
+        str
+        | dict[str, str]
+        | AzureNamedKeyCredential
+        | AzureSasCredential
+        | TokenCredential
+        | None
+    )
+    container: ContainerProperties | str

pkgs/serialization/__init__.py

@@ -1,12 +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_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

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: str | None = 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) -> str | None:
+        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

pkgs/serialization/missing_sentry.py

@@ -26,5 +26,5 @@ MISSING_SENTRY = MissingSentryType()
 MissingType = Union[MissingSentryType, ClassT]
 
 
-def coalesce_missing_sentry(value: MissingType[ClassT]) -> Optional[ClassT]:
+def coalesce_missing_sentry(value: MissingType[ClassT]) -> ClassT | None:
     return None if isinstance(value, MissingSentryType) else value

pkgs/serialization/opaque_key.py

@@ -1,4 +1,4 @@
 # Blocks a string key value from being interpreted for case conversion
-class OpaqueKey(str):
+class OpaqueKey(str):  # noqa: FURB189
     def __new__(cls, key: str) -> "OpaqueKey":
         return str.__new__(cls, key)

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: str | None = 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)

pkgs/serialization/serial_class.py

@@ -3,22 +3,20 @@ from __future__ import annotations
 import dataclasses
 from collections.abc import Callable
 from enum import StrEnum
-from typing import Any, Optional, TypeVar, cast
+from typing import Any, TypeVar, cast
 
-_ClassT = TypeVar("_ClassT")
+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
+    named_type_path: str | None = None
 
 
 EMPTY_SERIAL_CLASS_DATA = _SerialClassData()
@@ -26,12 +24,13 @@ EMPTY_SERIAL_CLASS_DATA = _SerialClassData()
 
 def serial_class(
     *,
-    unconverted_keys: Optional[set[str]] = None,
-    unconverted_values: Optional[set[str]] = None,
-    to_string_values: Optional[set[str]] = None,
-    parse_require: Optional[set[str]] = None,
-    named_type_path: Optional[str] = None,
-) -> Callable[[_ClassT], _ClassT]:
+    unconverted_keys: set[str] | None = None,
+    unconverted_values: set[str] | None = None,
+    to_string_values: set[str] | None = None,
+    parse_require: set[str] | None = None,
+    named_type_path: str | None = None,
+    is_dynamic_allowed: bool = False,
+) -> Callable[[ClassT], ClassT]:
     """
     An additional decorator to a dataclass that specifies serialization options.
 
@@ -55,7 +54,7 @@ def serial_class(
         The type_spec type-path to this type. This applies only to named types.
     """
 
-    def decorate(orig_class: _ClassT) -> _ClassT:
+    def decorate(orig_class: ClassT) -> ClassT:
         cast(Any, orig_class).__unc_serial_data = _SerialClassData(
             unconverted_keys=unconverted_keys or set(),
             unconverted_values=unconverted_values or set(),
@@ -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,28 +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:
-                if base_class_data is None:
-                    base_class_data = _SerialClassData()
-                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
     )
 
 
@@ -142,13 +134,13 @@ class _SerialStringEnumData:
 
 
 def serial_string_enum(
-    *, labels: Optional[dict[str, str]] = None, deprecated: Optional[set[str]] = None
-) -> Callable[[_ClassT], _ClassT]:
+    *, labels: dict[str, str] | None = None, deprecated: set[str] | None = None
+) -> Callable[[ClassT], ClassT]:
     """
     A decorator for enums to provide serialization data, including labels.
     """
 
-    def decorate(orig_class: _ClassT) -> _ClassT:
+    def decorate(orig_class: ClassT) -> ClassT:
         cast(Any, orig_class).__unc_serial_string_enum_data = _SerialStringEnumData(
             labels=labels or {}, deprecated=deprecated or set()
         )
@@ -161,7 +153,7 @@ class SerialStringEnumInspector:
     def __init__(self, current: _SerialStringEnumData) -> None:
         self.current = current
 
-    def get_label(self, value: str) -> Optional[str]:
+    def get_label(self, value: str) -> str | None:
         return self.current.labels.get(value)
 
     def get_deprecated(self, value: str) -> bool:

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

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.
@@ -25,16 +27,16 @@ class _SerialUnion:
 
     # If specified, indicates the Union has a discriminator which should be used to
     # 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
+    discriminator: str | None = None
+    discriminator_map: IdentityHashWrapper[dict[str, type]] | None = None
 
 
 def serial_union_annotation(
     *,
-    discriminator: typing.Optional[str] = None,
-    discriminator_map: typing.Optional[dict[str, type]] = None,
-    named_type_path: typing.Optional[str] = None,
+    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,
@@ -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
 
@@ -66,11 +66,11 @@ class SerialClassInspector(typing.Generic[T]):
         return typing.get_args(self._parsed_type)[0]  # type:ignore[no-any-return]
 
     @property
-    def discriminator(self) -> typing.Optional[str]:
+    def discriminator(self) -> str | None:
         return self._serial_union.discriminator
 
     @property
-    def discriminator_map(self) -> typing.Optional[dict[str, type]]:
+    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

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(