UncountablePythonSDK 0.0.91__tar.gz → 0.0.93__tar.gz

{uncountablepythonsdk-0.0.91/UncountablePythonSDK.egg-info → uncountablepythonsdk-0.0.93}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: UncountablePythonSDK
-Version: 0.0.91
+Version: 0.0.93
 Summary: Uncountable SDK
 Project-URL: Homepage, https://github.com/uncountableinc/uncountable-python-sdk
 Project-URL: Repository, https://github.com/uncountableinc/uncountable-python-sdk.git

{uncountablepythonsdk-0.0.91 → uncountablepythonsdk-0.0.93/UncountablePythonSDK.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: UncountablePythonSDK
-Version: 0.0.91
+Version: 0.0.93
 Summary: Uncountable SDK
 Project-URL: Homepage, https://github.com/uncountableinc/uncountable-python-sdk
 Project-URL: Repository, https://github.com/uncountableinc/uncountable-python-sdk.git

{uncountablepythonsdk-0.0.91 → uncountablepythonsdk-0.0.93}/examples/set_recipe_metadata_file.py

@@ -18,7 +18,7 @@ client = Client(
 )
 uploaded_file = client.upload_files(
     file_uploads=[
-        MediaFileUpload(path="/home/logan/Downloads/my_file_to_upload.csv"),
+        MediaFileUpload(path="Downloads/my_file_to_upload.csv"),
     ]
 )[0]
 

{uncountablepythonsdk-0.0.91 → uncountablepythonsdk-0.0.93}/examples/upload_files.py

@@ -12,8 +12,7 @@ client = Client(
 )
 uploaded = client.upload_files(
     file_uploads=[
-        MediaFileUpload(path="/my/file/path.doc"),
-        MediaFileUpload(path="/my/file/path2.doc"),
+        MediaFileUpload(path="Downloads/file"),
     ]
 )
 pprint(uploaded)

{uncountablepythonsdk-0.0.91 → uncountablepythonsdk-0.0.93}/pkgs/argument_parser/__init__.py

@@ -1,8 +1,11 @@
 from .argument_parser import CachedParser as CachedParser
 from .argument_parser import ParserError as ParserError
+from .argument_parser import ParserExtraFieldsError as ParserExtraFieldsError
 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_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

{uncountablepythonsdk-0.0.91 → uncountablepythonsdk-0.0.93}/pkgs/argument_parser/argument_parser.py

@@ -5,7 +5,6 @@ import math
 import types
 import typing
 from collections import defaultdict
-from dataclasses import MISSING, dataclass
 from datetime import date, datetime
 from decimal import Decimal
 from enum import Enum, auto
@@ -35,7 +34,7 @@ class SourceEncoding(Enum):
     STORAGE = auto()
 
 
-@dataclass(frozen=True, eq=True)
+@dataclasses.dataclass(frozen=True, eq=True)
 class ParserOptions:
     encoding: SourceEncoding
     strict_property_parsing: bool = False
@@ -57,8 +56,12 @@ class ParserOptions:
     def from_camel_case(self) -> bool:
         return self.encoding == SourceEncoding.API
 
+    @property
+    def allow_direct_dataclass(self) -> bool:
+        return self.encoding == SourceEncoding.STORAGE
+
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class ParserContext:
     options: ParserOptions
     cache: ParserCache
@@ -77,21 +80,23 @@ class ParserExtraFieldsError(ParserError):
         return f"extra fields were provided: {', '.join(self.extra_fields)}"
 
 
+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 typing.get_origin(field_type) is typing.Union and type(
-        None
-    ) in typing.get_args(field_type)
+    return is_union(field_type) and type(None) in typing.get_args(field_type)
 
 
 def is_missing(field_type: typing.Any) -> bool:
-    origin = typing.get_origin(field_type)
-    if origin is not typing.Union:
+    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 _invoke_tuple_parsers(
+def _invoke_tuple_parsers[T](
     tuple_type: type[T],
     arg_parsers: typing.Sequence[typing.Callable[[typing.Any], object]],
     has_ellipsis: bool,
@@ -128,7 +133,7 @@ def _invoke_fallback_parsers(
     ) from ExceptionGroup("Fallback Parser Exception", exceptions)
 
 
-def _invoke_membership_parser(
+def _invoke_membership_parser[T](
     expected_values: set[T],
     value: typing.Any,
 ) -> T:
@@ -143,11 +148,16 @@ def _invoke_membership_parser(
     raise ValueError(f"Expected value from {expected_values} but got value {value}")
 
 
-def _build_parser_discriminated_union(
-    discriminator: str, discriminator_map: dict[str, ParserFunction[T]]
+def _build_parser_discriminated_union[T](
+    context: ParserContext,
+    discriminator: str,
+    discriminator_map: dict[str, ParserFunction[T]],
 ) -> ParserFunction[T]:
     def parse(value: typing.Any) -> typing.Any:
-        discriminant = value.get(discriminator)
+        if context.options.allow_direct_dataclass and dataclasses.is_dataclass(value):
+            discriminant = getattr(value, discriminator)
+        else:
+            discriminant = value.get(discriminator)
         if discriminant is None:
             raise ValueError("missing-union-discriminant")
         if not isinstance(discriminant, str):
@@ -160,7 +170,7 @@ def _build_parser_discriminated_union(
     return parse
 
 
-def _build_parser_inner(
+def _build_parser_inner[T](
     parsed_type: type[T],
     context: ParserContext,
 ) -> ParserFunction[T]:
@@ -178,6 +188,7 @@ def _build_parser_inner(
             parsed_type = serial_union.get_union_underlying()
         else:
             return _build_parser_discriminated_union(
+                context,
                 discriminator,
                 {
                     key: _build_parser_inner(value, context)
@@ -357,7 +368,7 @@ def _build_parser_inner(
     raise ValueError(f"Unhandled type {parsed_type}")
 
 
-def _build_parser_dataclass(
+def _build_parser_dataclass[T](
     parsed_type: type[T],
     context: ParserContext,
 ) -> ParserFunction[T]:
@@ -392,21 +403,25 @@ def _build_parser_dataclass(
         )
 
     def parse(value: typing.Any) -> typing.Any:
+        # Use an exact type match to prevent base/derived class mismatches
+        if context.options.allow_direct_dataclass and type(value) is parsed_type:
+            return value
+
         data: dict[typing.Any, typing.Any] = {}
         for field, field_type, field_parser in dc_field_parsers:
             field_raw_value = None
             try:
                 field_raw_value = value.get(
                     resolve_serialized_field_name(field_name=field.name),
-                    MISSING,
+                    dataclasses.MISSING,
                 )
                 field_value: typing.Any
-                if field_raw_value == MISSING:
+                if field_raw_value == dataclasses.MISSING:
                     if serial_class_data.has_parse_require(field.name):
                         raise ValueError("missing-required-field", field.name)
-                    if field.default != MISSING:
+                    if field.default != dataclasses.MISSING:
                         field_value = field.default
-                    elif field.default_factory != MISSING:
+                    elif field.default_factory != dataclasses.MISSING:
                         field_value = field.default_factory()
                     elif is_missing(field_type):
                         field_value = MissingSentryType()
@@ -464,7 +479,7 @@ def _build_parser_dataclass(
 _CACHE_MAP: dict[ParserOptions, ParserCache] = defaultdict(ParserCache)
 
 
-def build_parser(
+def build_parser[T](
     parsed_type: type[T],
     options: ParserOptions,
 ) -> ParserFunction[T]:
@@ -486,17 +501,31 @@ def build_parser(
     return built_parser
 
 
-class CachedParser(typing.Generic[T]):
+class CachedParser[T]:
     def __init__(
         self,
         args: type[T],
         strict_property_parsing: bool = False,
     ):
         self.arguments = args
-        self.parser_api: typing.Optional[ParserFunction[T]] = None
-        self.parser_storage: typing.Optional[ParserFunction[T]] = None
+        self.parser_api: ParserFunction[T] | None = None
+        self.parser_storage: ParserFunction[T] | None = None
         self.strict_property_parsing = strict_property_parsing
 
+    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)
+
     def parse_api(self, args: typing.Any) -> T:
         """
         Parses data coming from an API/Endpoint

{uncountablepythonsdk-0.0.91 → uncountablepythonsdk-0.0.93}/pkgs/filesystem_utils/__init__.py

@@ -17,3 +17,4 @@ from .file_type_utils import FileSystemSFTPConfig as FileSystemSFTPConfig
 from .file_type_utils import FileTransfer as FileTransfer
 from .file_type_utils import IncompatibleFileReference as IncompatibleFileReference
 from .file_type_utils import RemoteObjectReference as RemoteObjectReference
+from .filesystem_session import FileSystemSession as FileSystemSession

{uncountablepythonsdk-0.0.91 → uncountablepythonsdk-0.0.93}/pkgs/filesystem_utils/_gdrive_session.py

@@ -1,6 +1,6 @@
 import os
 from io import BytesIO
-from typing import Any, Optional
+from typing import Any
 
 from google.oauth2 import service_account
 from googleapiclient.discovery import build as build_gdrive_connection
@@ -30,7 +30,7 @@ def download_gdrive_file(
     mime_type: str,
     *,
     verbose: bool = False,
-) -> Optional[FileObjectData]:
+) -> FileObjectData | None:
     if "folder" in mime_type:
         if verbose:
             print(f"{filename} is a folder and will not be downloaded.")
@@ -148,7 +148,7 @@ def move_gdrive_file(
     src_file_id: str,
     dest_folder_id: str,
     *,
-    dest_filename: Optional[str] = None,
+    dest_filename: str | None = None,
 ) -> None:
     # Retrieve the existing parents to remove
     file = (
@@ -197,7 +197,7 @@ class GDriveSession(FileSystemSession):
         dir_path: FileSystemObject,
         *,
         recursive: bool = False,
-        valid_file_extensions: Optional[tuple[str, ...]] = None,
+        valid_file_extensions: tuple[str, ...] | None = None,
     ) -> list[FileSystemObject]:
         if not isinstance(dir_path, RemoteObjectReference):
             raise IncompatibleFileReference(

{uncountablepythonsdk-0.0.91 → uncountablepythonsdk-0.0.93}/pkgs/filesystem_utils/_s3_session.py

@@ -1,6 +1,7 @@
 from io import BytesIO
 
 from boto3.session import Session
+from mypy_boto3_s3.service_resource import Bucket
 
 from pkgs.filesystem_utils.file_type_utils import (
     FileObjectData,
@@ -37,7 +38,7 @@ class S3Session(FileSystemSession):
             aws_session_token=self.config.session_token,
         )
 
-        self.bucket = s3_resource.Bucket(self.config.bucket_name)
+        self.bucket: Bucket | None = s3_resource.Bucket(self.config.bucket_name)
 
     def __enter__(self) -> "S3Session":
         self.start()

{uncountablepythonsdk-0.0.91 → uncountablepythonsdk-0.0.93}/pkgs/filesystem_utils/_sftp_session.py

@@ -1,7 +1,6 @@
 import os
 from collections.abc import Iterable
 from io import BytesIO
-from typing import Optional
 
 import paramiko
 import pysftp
@@ -30,8 +29,8 @@ def list_sftp_files(
     connection: pysftp.Connection,
     dir_path: str,
     *,
-    valid_extensions: Optional[Iterable[str]] = None,
-    parent_dir_path: Optional[str] = None,
+    valid_extensions: Iterable[str] | None = None,
+    parent_dir_path: str | None = None,
     recursive: bool = True,
 ) -> list[str]:
     file_paths: list[str] = []

{uncountablepythonsdk-0.0.91 → uncountablepythonsdk-0.0.93}/pkgs/filesystem_utils/file_type_utils.py

@@ -1,7 +1,7 @@
 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 (
@@ -17,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
@@ -39,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:
@@ -63,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
 
 
@@ -71,10 +71,10 @@ 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)

{uncountablepythonsdk-0.0.91 → uncountablepythonsdk-0.0.93}/pkgs/serialization/annotation.py

@@ -6,7 +6,7 @@ T = typing.TypeVar("T")
 
 @dataclasses.dataclass(kw_only=True, frozen=True, eq=True)
 class SerialBase:
-    named_type_path: typing.Optional[str] = None
+    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
@@ -16,7 +16,7 @@ class SerialBase:
     from_decorator: bool = False
 
 
-def get_serial_annotation(parsed_type: type[T]) -> SerialBase | None:
+def get_serial_annotation[T](parsed_type: type[T]) -> SerialBase | None:
     if not hasattr(parsed_type, "__metadata__"):
         return None
     metadata = parsed_type.__metadata__  # type:ignore[attr-defined]
@@ -28,13 +28,13 @@ def get_serial_annotation(parsed_type: type[T]) -> SerialBase | None:
     return serial
 
 
-class SerialInspector(typing.Generic[T]):
+class SerialInspector[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) -> typing.Optional[str]:
+    def named_type_path(self) -> str | None:
         return self._serial_base.named_type_path
 
     @property
@@ -53,7 +53,7 @@ class SerialInspector(typing.Generic[T]):
         return self._serial_base.is_dynamic_allowed
 
 
-def unwrap_annotated(parsed_type: type[T]) -> type[T]:
+def unwrap_annotated[T](parsed_type: type[T]) -> type[T]:
     """
     If the type is an annotated type then return the origin of it.
     Otherwise return the original type.

{uncountablepythonsdk-0.0.91 → uncountablepythonsdk-0.0.93}/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[ClassT](value: MissingType[ClassT]) -> ClassT | None:
     return None if isinstance(value, MissingSentryType) else value

{uncountablepythonsdk-0.0.91 → uncountablepythonsdk-0.0.93}/pkgs/serialization/serial_alias.py

@@ -16,7 +16,7 @@ class _SerialAlias(SerialBase):
 
 def serial_alias_annotation(
     *,
-    named_type_path: typing.Optional[str] = None,
+    named_type_path: str | None = None,
     is_dynamic_allowed: bool = False,
 ) -> _SerialAlias:
     return _SerialAlias(
@@ -26,7 +26,7 @@ def serial_alias_annotation(
     )
 
 
-def _get_serial_alias(parsed_type: type[T]) -> _SerialAlias | None:
+def _get_serial_alias[T](parsed_type: type[T]) -> _SerialAlias | None:
     serial = get_serial_annotation(parsed_type)
     if not isinstance(serial, _SerialAlias):
         return None
@@ -39,7 +39,7 @@ class SerialAliasInspector(SerialInspector[T]):
         self._serial_alias = serial_alias
 
 
-def get_serial_alias_data(parsed_type: type[T]) -> SerialAliasInspector[T] | None:
+def get_serial_alias_data[T](parsed_type: type[T]) -> SerialAliasInspector[T] | None:
     serial = _get_serial_alias(parsed_type)
     if serial is None:
         return None

{uncountablepythonsdk-0.0.91 → uncountablepythonsdk-0.0.93}/pkgs/serialization/serial_class.py

@@ -3,7 +3,7 @@ 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
 
 from .annotation import SerialBase, SerialInspector
 
@@ -16,7 +16,7 @@ class _SerialClassData(SerialBase):
     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
+    named_type_path: str | None = None
 
 
 EMPTY_SERIAL_CLASS_DATA = _SerialClassData()
@@ -24,11 +24,11 @@ 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,
+    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]:
     """
@@ -119,7 +119,7 @@ def get_merged_serial_class_data(type_class: type[Any]) -> _SerialClassData | No
     return base_class_data
 
 
-def get_serial_class_data(
+def get_serial_class_data[_ClassT](
     type_class: type[_ClassT],
 ) -> SerialClassDataInspector[_ClassT]:
     return SerialClassDataInspector(
@@ -134,7 +134,7 @@ class _SerialStringEnumData:
 
 
 def serial_string_enum(
-    *, labels: Optional[dict[str, str]] = None, deprecated: Optional[set[str]] = None
+    *, labels: dict[str, str] | None = None, deprecated: set[str] | None = None
 ) -> Callable[[_ClassT], _ClassT]:
     """
     A decorator for enums to provide serialization data, including labels.
@@ -153,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:

{uncountablepythonsdk-0.0.91 → uncountablepythonsdk-0.0.93}/pkgs/serialization/serial_generic.py

@@ -6,7 +6,7 @@ from .serial_class import get_merged_serial_class_data
 T = typing.TypeVar("T")
 
 
-def get_serial_data(parsed_type: type[T]) -> SerialInspector[T] | None:
+def get_serial_data[T](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)

{uncountablepythonsdk-0.0.91 → uncountablepythonsdk-0.0.93}/pkgs/serialization/serial_union.py

@@ -6,7 +6,7 @@ from .annotation import SerialBase, SerialInspector, get_serial_annotation
 T = typing.TypeVar("T")
 
 
-class IdentityHashWrapper(typing.Generic[T]):
+class IdentityHashWrapper[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."""
@@ -27,15 +27,15 @@ class _SerialUnion(SerialBase):
 
     # 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
+    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(
@@ -49,7 +49,7 @@ def serial_union_annotation(
     )
 
 
-def _get_serial_union(parsed_type: type[T]) -> _SerialUnion | None:
+def _get_serial_union[T](parsed_type: type[T]) -> _SerialUnion | None:
     serial = get_serial_annotation(parsed_type)
     if not isinstance(serial, _SerialUnion):
         return None
@@ -66,17 +66,17 @@ class SerialClassInspector(SerialInspector[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
 
 
-def get_serial_union_data(parsed_type: type[T]) -> SerialClassInspector[T] | None:
+def get_serial_union_data[T](parsed_type: type[T]) -> SerialClassInspector[T] | None:
     serial = _get_serial_union(parsed_type)
     if serial is None:
         return None

{uncountablepythonsdk-0.0.91 → uncountablepythonsdk-0.0.93}/pkgs/serialization_util/__init__.py

@@ -2,6 +2,7 @@ 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,
@@ -14,4 +15,5 @@ __all__: list[str] = [
     "serialize_for_storage_dict",
     "iterate_fields",
     "dict_fields",
+    "JsonValue",
 ]

{uncountablepythonsdk-0.0.91 → uncountablepythonsdk-0.0.93}/pkgs/serialization_util/serialization_helpers.py

@@ -12,7 +12,6 @@ from typing import (
     Any,
     ClassVar,
     Protocol,
-    TypeVar,
     Union,
     overload,
 )
@@ -34,14 +33,12 @@ 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:
+def identity[T](x: T) -> T:
     return x
 
 

{uncountablepythonsdk-0.0.91 → uncountablepythonsdk-0.0.93}/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