UncountablePythonSDK 0.0.170__py3-none-any.whl → 0.0.172__py3-none-any.whl

examples/integration-server/jobs/materials_auto/example_instrument.py

@@ -14,7 +14,7 @@ from uncountable.types.integration_session_t import IntegrationSessionInstrument
 from websockets.sync.client import connect
 from websockets.typing import Data
 
-from pkgs.argument_parser.argument_parser import CachedParser
+from pkgs.argument_parser import CachedParser
 from pkgs.serialization_util import serialize_for_api
 
 

examples/integration-server/pyproject.toml

@@ -5,19 +5,18 @@ name = "integration-server-testing"
 # end_project_name
 dynamic = ["version"]
 dependencies = [
-  "mypy == 1.*",
+  "mypy >= 2.1.0, < 3",
   "ruff == 0.*",
   "openpyxl == 3.*",
   "more_itertools ==11.*",
-  "types-paramiko ==4.0.0.20260402",
+  "types-paramiko ==4.0.0.20260518",
   "types-openpyxl == 3.*",
-  "types-pysftp == 0.*",
   "types-pytz ==2026.*",
   "types-requests == 2.*",
   "types-simplejson == 3.*",
   "pandas-stubs",
   "xlrd == 2.*",
-  "msgspec ==0.20.*",
+  "msgspec ==0.21.*",
   "websockets==16.0",
 ]
 

pkgs/argument_parser/__init__.py

@@ -1,17 +1,47 @@
-from ._is_enum import is_string_enum_class as is_string_enum_class
-from .argument_parser import CachedParser as CachedParser
-from .argument_parser import ParserBase as ParserBase
-from .argument_parser import ParserFunction as ParserFunction
-from .argument_parser import ParserOptions as ParserOptions
-from .argument_parser import SourceEncoding as SourceEncoding
-from .argument_parser import build_parser as build_parser
-from .argument_parser import is_missing as is_missing
-from .argument_parser import is_optional as is_optional
-from .argument_parser import is_union as is_union
-from .case_convert import camel_to_snake_case as camel_to_snake_case
-from .case_convert import kebab_to_pascal_case as kebab_to_pascal_case
-from .case_convert import snake_to_camel_case as snake_to_camel_case
-from .parser_error import ParserEnumError as ParserEnumError
-from .parser_error import ParserError as ParserError
-from .parser_error import ParserExtraFieldsError as ParserExtraFieldsError
-from .parser_error import ParserTypeError as ParserTypeError
+# CLOSED MODULE
+
+__all__ = [
+    "CachedParser",
+    "ParserBase",
+    "ParserEnumError",
+    "ParserError",
+    "ParserExtraFieldsError",
+    "ParserFunction",
+    "ParserOptions",
+    "ParserTypeError",
+    "SourceEncoding",
+    "build_parser",
+    "camel_to_snake_case",
+    "is_missing",
+    "is_optional",
+    "is_string_enum_class",
+    "is_union",
+    "kebab_to_pascal_case",
+    "snake_to_camel_case",
+]
+
+from .cached_parser import CachedParser as CachedParser
+from .case_convert import (
+    camel_to_snake_case as camel_to_snake_case,
+    kebab_to_pascal_case as kebab_to_pascal_case,
+    snake_to_camel_case as snake_to_camel_case,
+)
+from .parser_base import ParserBase as ParserBase
+from .parser_builder import build_parser as build_parser
+from .parser_error import (
+    ParserEnumError as ParserEnumError,
+    ParserError as ParserError,
+    ParserExtraFieldsError as ParserExtraFieldsError,
+    ParserTypeError as ParserTypeError,
+)
+from .parser_function_type import ParserFunction as ParserFunction
+from .parser_options import (
+    ParserOptions as ParserOptions,
+    SourceEncoding as SourceEncoding,
+)
+from .type_predicates import (
+    is_missing as is_missing,
+    is_optional as is_optional,
+    is_string_enum_class as is_string_enum_class,
+    is_union as is_union,
+)

pkgs/argument_parser/cached_parser.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import typing
+
+from pkgs.serialization import SerialType
+
+from .parser_base import ParserBase
+from .parser_builder import build_parser
+from .parser_function_type import ParserFunction
+from .parser_options import ParserOptions
+
+T = typing.TypeVar("T")
+
+
+class CachedParser(ParserBase[T], typing.Generic[T]):
+    def __init__(
+        self,
+        args: SerialType[T],
+        strict_property_parsing: bool = False,
+    ):
+        self.arguments = args
+        self.parser_api: ParserFunction[T] | None = None
+        self.parser_storage: ParserFunction[T] | None = None
+        self.strict_property_parsing = strict_property_parsing
+
+    def parse_api(self, args: typing.Any) -> T:
+        """
+        Parses data coming from an API/Endpoint
+
+        NOTE: Some places use this to parse storage data due to backwards
+        compatibility. If your data is coming from the DB or a file, it is
+        preferred to use parse_storage.
+        """
+        if self.parser_api is None:
+            self.parser_api = build_parser(
+                self.arguments,
+                ParserOptions.Api(
+                    strict_property_parsing=self.strict_property_parsing,
+                ),
+            )
+        assert self.parser_api is not None
+        return self.parser_api(args)
+
+    def parse_storage(self, args: typing.Any) -> T:
+        """
+        Parses data coming from the database or file.
+        """
+        if self.parser_storage is None:
+            self.parser_storage = build_parser(
+                self.arguments,
+                ParserOptions.Storage(
+                    strict_property_parsing=self.strict_property_parsing,
+                ),
+            )
+        assert self.parser_storage is not None
+        return self.parser_storage(args)

pkgs/argument_parser/parser_base.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import typing
+from abc import ABC, abstractmethod
+from importlib import resources
+
+import msgspec.yaml
+
+from .parser_options import SourceEncoding
+
+T = typing.TypeVar("T")
+
+
+class ParserBase(ABC, typing.Generic[T]):
+    def parse_from_encoding(
+        self,
+        args: typing.Any,
+        *,
+        source_encoding: SourceEncoding,
+    ) -> T:
+        match source_encoding:
+            case SourceEncoding.API:
+                return self.parse_api(args)
+            case SourceEncoding.STORAGE:
+                return self.parse_storage(args)
+            case _:
+                typing.assert_never(source_encoding)
+
+    # IMPROVE: Args would be better typed as "object"
+    @abstractmethod
+    def parse_storage(self, args: typing.Any) -> T: ...
+
+    @abstractmethod
+    def parse_api(self, args: typing.Any) -> T: ...
+
+    def parse_yaml_file(self, path: str) -> T:
+        with open(path, encoding="utf-8") as data_in:
+            return self.parse_storage(msgspec.yaml.decode(data_in.read()))
+
+    def parse_yaml_resource(self, package: resources.Package, resource: str) -> T:
+        with resources.open_text(package, resource) as fp:
+            return self.parse_storage(msgspec.yaml.decode(fp.read()))

pkgs/argument_parser/parser_builder.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import typing
+from collections import defaultdict
+
+from pkgs.serialization import SerialType
+
+from .parser_cache import ParserCache, ParserCacheManager
+from .parser_function_type import ParserFunction
+from .parser_inner import build_parser_inner
+from .parser_options import ParserContext, ParserOptions
+
+T = typing.TypeVar("T")
+
+_CACHE_MAP: dict[ParserOptions, ParserCache] = defaultdict(ParserCache)
+
+
+def build_parser(
+    parsed_type: SerialType[T],
+    options: ParserOptions,
+) -> ParserFunction[T]:
+    """
+    Consider using CachedParser to provide a cleaner API for storage and API
+    data parsing.
+    """
+
+    # Keep a cache per ParserOptions type, as they produce distinct parsers
+    global_cache = _CACHE_MAP[options]
+
+    context = ParserContext(options=options, cache=ParserCacheManager(global_cache))
+
+    # PEP 695 ``type X[T] = ...`` aliases (and their subscripted forms) are not
+    # ``type`` instances, so they can't share the top-level cache keyed on
+    # ``type[Any]``. Skip the top-level cache for them; ``build_parser_inner``
+    # caches parameterized dataclasses internally by ``(type, type_var_map)``.
+    is_alias_type = isinstance(parsed_type, typing.TypeAliasType) or isinstance(
+        typing.get_origin(parsed_type), typing.TypeAliasType
+    )
+
+    if not is_alias_type:
+        cur_parser = global_cache.get(parsed_type)
+        if cur_parser is not None:
+            return cur_parser
+
+    built_parser = build_parser_inner(parsed_type, context, {})
+
+    if not is_alias_type:
+        context.cache.put(parsed_type, built_parser)
+
+    global_cache.update(context.cache.local_cache())
+
+    return built_parser

pkgs/argument_parser/parser_cache.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import types
+import typing
+
+from .parser_function_type import ParserFunction
+
+T = typing.TypeVar("T")
+ParserCacheKey = type[typing.Any] | typing.TypeAliasType | types.UnionType
+ParserCache = dict[
+    ParserCacheKey,
+    ParserFunction[typing.Any],
+]
+
+
+class ParserCacheManager:
+    def __init__(self, global_cache: ParserCache) -> None:
+        self._global_cache = global_cache
+        self._local_cache: ParserCache = dict()
+
+    def get(self, key: ParserCacheKey) -> ParserFunction[typing.Any] | None:
+        if key in self._local_cache:
+            return self._local_cache[key]
+        return self._global_cache.get(key)
+
+    def put(self, key: ParserCacheKey, value: ParserFunction[typing.Any]) -> None:
+        self._local_cache[key] = value
+
+    def local_cache(self) -> ParserCache:
+        return self._local_cache

pkgs/argument_parser/parser_function_type.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+import typing
+
+T = typing.TypeVar("T")
+ParserFunction = typing.Callable[[typing.Any], T]

pkgs/argument_parser/{argument_parser.py → parser_inner.py}

@@ -5,15 +5,11 @@ import datetime
 import math
 import types
 import typing
-from abc import ABC, abstractmethod
-from collections import defaultdict
 from datetime import date
 from decimal import Decimal
-from enum import Enum, auto
-from importlib import resources
+from enum import Enum
 
 import dateutil.parser
-import msgspec.yaml
 
 from pkgs.serialization import (
     MissingSentryType,
@@ -23,8 +19,6 @@ from pkgs.serialization import (
     get_serial_union_data,
 )
 
-from ._is_enum import is_string_enum_class
-from ._is_namedtuple import is_namedtuple_type
 from .case_convert import camel_to_snake_case, snake_to_camel_case
 from .parser_error import (
     ParserEnumError,
@@ -32,66 +26,16 @@ from .parser_error import (
     ParserExtraFieldsError,
     ParserTypeError,
 )
+from .parser_function_type import ParserFunction
+from .parser_options import ParserContext
+from .type_predicates import (
+    is_missing,
+    is_namedtuple_type,
+    is_optional,
+    is_string_enum_class,
+)
 
 T = typing.TypeVar("T")
-ParserFunction = typing.Callable[[typing.Any], T]
-ParserCache = dict[type[typing.Any], ParserFunction[typing.Any]]
-
-
-class SourceEncoding(Enum):
-    API = auto()
-    STORAGE = auto()
-
-
-@dataclasses.dataclass(frozen=True, eq=True)
-class ParserOptions:
-    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
-
-    @property
-    def allow_direct_type(self) -> bool:
-        """This allows parsing from a DB column without having to check whether it's
-        the native format of the type, a JSON column, or a string encoding."""
-        return self.encoding == SourceEncoding.STORAGE
-
-
-@dataclasses.dataclass(frozen=True)
-class ParserContext:
-    options: ParserOptions
-    cache: ParserCache
-
-
-def is_union(field_type: typing.Any) -> bool:
-    origin = typing.get_origin(field_type)
-    return origin is typing.Union or origin is types.UnionType
-
-
-def is_optional(field_type: typing.Any) -> bool:
-    return is_union(field_type) and type(None) in typing.get_args(field_type)
-
-
-def is_missing(field_type: typing.Any) -> bool:
-    if not is_union(field_type):
-        return False
-    args = typing.get_args(field_type)
-    return not (len(args) == 0 or args[0] is not MissingSentryType)
 
 
 def _has_field_default(field: dataclasses.Field[typing.Any]) -> bool:
@@ -130,7 +74,7 @@ def _invoke_tuple_parsers(
 
 
 def _invoke_fallback_parsers(
-    original_type: type[T],
+    original_type: type[T] | types.UnionType,
     arg_parsers: typing.Sequence[typing.Callable[[typing.Any], T]],
     value: typing.Any,
 ) -> T:
@@ -259,15 +203,40 @@ def _resolve_base_type_vars(
                 type_var_map[base_param] = resolved_new_type
 
         # Recurse into base's bases
-        if dataclasses.is_dataclass(base_origin):
+        if isinstance(base_origin, type) and dataclasses.is_dataclass(base_origin):
             _resolve_base_type_vars(
-                cls=base_origin,  # type: ignore[arg-type]
+                cls=base_origin,
                 type_var_map=type_var_map,
             )
 
 
-def _build_parser_inner(
-    parsed_type: type[T] | typing.TypeVar,
+def _build_parser_for_type_alias(
+    alias: typing.TypeAliasType,
+    alias_args: tuple[typing.Any, ...],
+    context: ParserContext,
+    type_var_map: dict[typing.TypeVar, type],
+) -> ParserFunction[T]:
+    """
+    Resolve a PEP 695 ``type X[T] = ...`` alias into a parser by unwrapping
+    ``alias.__value__`` and threading ``alias_args`` through ``type_var_map``
+    so TypeVars inside the alias body resolve correctly downstream.
+
+    ``alias_args`` is empty for the bare alias and the concrete type arguments
+    for a subscripted alias (e.g. ``X[int]``).
+    """
+    merged_alias_map: dict[typing.TypeVar, type] = dict(type_var_map)
+    for param, arg in zip(alias.__type_params__, alias_args, strict=True):
+        assert isinstance(param, typing.TypeVar), (
+            f"PEP 695 alias parameter {param!r} is not a TypeVar"
+        )
+        merged_alias_map[param] = _resolve_type_var(
+            type_arg=arg, type_var_map=type_var_map
+        )
+    return build_parser_inner(alias.__value__, context, merged_alias_map)
+
+
+def build_parser_inner(
+    parsed_type: type[T] | typing.TypeVar | typing.TypeAliasType | types.UnionType,
     context: ParserContext,
     type_var_map: dict[typing.TypeVar, type],
 ) -> ParserFunction[T]:
@@ -276,7 +245,15 @@ def _build_parser_inner(
     internal parsers.
     """
     if isinstance(parsed_type, typing.TypeVar):
-        return _build_parser_inner(type_var_map[parsed_type], context, type_var_map)
+        return build_parser_inner(type_var_map[parsed_type], context, type_var_map)
+
+    if isinstance(parsed_type, typing.TypeAliasType):
+        return _build_parser_for_type_alias(parsed_type, (), context, type_var_map)
+    alias_origin = typing.get_origin(parsed_type)
+    if isinstance(alias_origin, typing.TypeAliasType):
+        return _build_parser_for_type_alias(
+            alias_origin, typing.get_args(parsed_type), context, type_var_map
+        )
 
     serial_union = get_serial_union_data(parsed_type)
     if serial_union is not None:
@@ -290,7 +267,7 @@ def _build_parser_inner(
                 context,
                 discriminator,
                 {
-                    key: _build_parser_inner(value, context, type_var_map)
+                    key: build_parser_inner(value, context, type_var_map)
                     for key, value in discriminator_map.items()
                 },
             )
@@ -302,7 +279,11 @@ def _build_parser_inner(
 
     origin = typing.get_origin(parsed_type)
     type_args = typing.get_args(parsed_type)
-    if dataclasses.is_dataclass(origin) and type_args is not None:
+    if (
+        isinstance(origin, type)
+        and dataclasses.is_dataclass(origin)
+        and type_args is not None
+    ):
         # Build local TypeVar map
         merged_map: dict[typing.TypeVar, type] = {
             **type_var_map,
@@ -316,7 +297,7 @@ def _build_parser_inner(
 
         # Resolve base class TypeVars
         _resolve_base_type_vars(
-            cls=origin,  # type: ignore[arg-type]
+            cls=origin,
             type_var_map=merged_map,
         )
 
@@ -324,11 +305,12 @@ def _build_parser_inner(
 
     # namedtuple support
     if is_namedtuple_type(parsed_type):
+        assert not isinstance(parsed_type, types.UnionType)
         type_hints = typing.get_type_hints(parsed_type)
         field_parsers = [
             (
                 field_name,
-                _build_parser_inner(type_hints[field_name], context, type_var_map),
+                build_parser_inner(type_hints[field_name], context, type_var_map),
             )
             for field_name in parsed_type.__annotations__
         ]
@@ -349,6 +331,7 @@ def _build_parser_inner(
         return typing.cast(ParserFunction[T], NONE_IDENTITY_PARSER)
 
     if origin is tuple:
+        assert not isinstance(parsed_type, types.UnionType)
         args = typing.get_args(parsed_type)
         element_parsers: list[typing.Callable[[typing.Any], object]] = []
         has_ellipsis = False
@@ -358,7 +341,7 @@ def _build_parser_inner(
                 assert len(element_parsers) == 1
                 has_ellipsis = True
             else:
-                element_parsers.append(_build_parser_inner(arg, context, type_var_map))
+                element_parsers.append(build_parser_inner(arg, context, type_var_map))
         return lambda value: _invoke_tuple_parsers(
             parsed_type, element_parsers, has_ellipsis, value
         )
@@ -370,7 +353,7 @@ def _build_parser_inner(
             key=lambda subtype: 0 if subtype == type(None) else 1,  # noqa: E721
         )
         arg_parsers = [
-            _build_parser_inner(arg, context, type_var_map) for arg in sorted_args
+            build_parser_inner(arg, context, type_var_map) for arg in sorted_args
         ]
         return lambda value: _invoke_fallback_parsers(parsed_type, arg_parsers, value)
 
@@ -383,7 +366,7 @@ def _build_parser_inner(
             raise ParserError(
                 "List types only support one argument", expected_type=parsed_type
             )
-        arg_parser = _build_parser_inner(args[0], context, type_var_map)
+        arg_parser = build_parser_inner(args[0], context, type_var_map)
 
         def parse_element(value: typing.Any) -> typing.Any:
             try:
@@ -407,7 +390,7 @@ def _build_parser_inner(
                 "Dict types only support two arguments for now",
                 expected_type=parsed_type,
             )
-        k_inner_parser = _build_parser_inner(
+        k_inner_parser = build_parser_inner(
             args[0],
             context,
             type_var_map,
@@ -425,7 +408,7 @@ def _build_parser_inner(
                 return camel_to_snake_case(value)
             return inner
 
-        v_parser = _build_parser_inner(args[1], context, type_var_map)
+        v_parser = build_parser_inner(args[1], context, type_var_map)
 
         def parse_dict(value: typing.Any) -> typing.Any:
             return origin((key_parser(k), v_parser(v)) for k, v in value.items())
@@ -470,6 +453,9 @@ def _build_parser_inner(
 
         def parse_date(value: typing.Any) -> T:
             if context.options.allow_direct_type and isinstance(value, date):
+                if isinstance(value, datetime.datetime):
+                    assert value.time() == datetime.time.min
+                    return value.date()  # type:ignore
                 return value  # type:ignore
             return date.fromisoformat(value)  # type:ignore
 
@@ -541,7 +527,7 @@ def _build_parser_inner(
     # 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(
+        return build_parser_inner(
             parsed_type.__origin__,  # type: ignore[attr-defined]
             context,
             type_var_map,
@@ -668,7 +654,7 @@ def _build_parser_dataclass(
 
     # Add to cache before building inner types, to support recursion
     parser_function = parse
-    context.cache[cache_key] = parser_function
+    context.cache.put(cache_key, parser_function)
 
     dc_field_parsers = []
     for field in dataclasses.fields(parsed_type):  # type:ignore[arg-type]
@@ -679,107 +665,7 @@ def _build_parser_dataclass(
         dc_field_parsers.append((
             field,
             field_type_hint,
-            _build_parser_inner(field_type_hint, context, type_var_map),
+            build_parser_inner(field_type_hint, context, type_var_map),
         ))
 
     return parser_function
-
-
-_CACHE_MAP: dict[ParserOptions, ParserCache] = defaultdict(ParserCache)
-
-
-def build_parser(
-    parsed_type: type[T],
-    options: ParserOptions,
-) -> ParserFunction[T]:
-    """
-    Consider using CachedParser to provide a cleaner API for storage and API
-    data parsing.
-    """
-
-    # Keep a cache per ParserOptions type, as they produce distinct parsers
-    cache = _CACHE_MAP[options]
-
-    cur_parser = cache.get(parsed_type)
-    if cur_parser is not None:
-        return cur_parser
-
-    context = ParserContext(options=options, cache=cache)
-    built_parser = _build_parser_inner(parsed_type, context, {})
-    cache[parsed_type] = built_parser
-    return built_parser
-
-
-class ParserBase(ABC, typing.Generic[T]):
-    def parse_from_encoding(
-        self,
-        args: typing.Any,
-        *,
-        source_encoding: SourceEncoding,
-    ) -> T:
-        match source_encoding:
-            case SourceEncoding.API:
-                return self.parse_api(args)
-            case SourceEncoding.STORAGE:
-                return self.parse_storage(args)
-            case _:
-                typing.assert_never(source_encoding)
-
-    # IMPROVE: Args would be better typed as "object"
-    @abstractmethod
-    def parse_storage(self, args: typing.Any) -> T: ...
-
-    @abstractmethod
-    def parse_api(self, args: typing.Any) -> T: ...
-
-    def parse_yaml_file(self, path: str) -> T:
-        with open(path, encoding="utf-8") as data_in:
-            return self.parse_storage(msgspec.yaml.decode(data_in.read()))
-
-    def parse_yaml_resource(self, package: resources.Package, resource: str) -> T:
-        with resources.open_text(package, resource) as fp:
-            return self.parse_storage(msgspec.yaml.decode(fp.read()))
-
-
-class CachedParser(ParserBase[T], typing.Generic[T]):
-    def __init__(
-        self,
-        args: type[T],
-        strict_property_parsing: bool = False,
-    ):
-        self.arguments = args
-        self.parser_api: ParserFunction[T] | None = None
-        self.parser_storage: ParserFunction[T] | None = None
-        self.strict_property_parsing = strict_property_parsing
-
-    def parse_api(self, args: typing.Any) -> T:
-        """
-        Parses data coming from an API/Endpoint
-
-        NOTE: Some places use this to parse storage data due to backwards
-        compatibility. If your data is coming from the DB or a file, it is
-        preferred to use parse_storage.
-        """
-        if self.parser_api is None:
-            self.parser_api = build_parser(
-                self.arguments,
-                ParserOptions.Api(
-                    strict_property_parsing=self.strict_property_parsing,
-                ),
-            )
-        assert self.parser_api is not None
-        return self.parser_api(args)
-
-    def parse_storage(self, args: typing.Any) -> T:
-        """
-        Parses data coming from the database or file.
-        """
-        if self.parser_storage is None:
-            self.parser_storage = build_parser(
-                self.arguments,
-                ParserOptions.Storage(
-                    strict_property_parsing=self.strict_property_parsing,
-                ),
-            )
-        assert self.parser_storage is not None
-        return self.parser_storage(args)