UncountablePythonSDK 0.0.171__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]