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

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.")
@@ -63,7 +63,7 @@ def download_gdrive_file(
     downloader = MediaIoBaseDownload(file_handler, file_request)
     download_complete = False
     while not download_complete:
-        status, download_complete = downloader.next_chunk()
+        _status, download_complete = downloader.next_chunk()
 
     file_handler.seek(0)
     file_data = file_handler.read()
@@ -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(
@@ -212,7 +212,8 @@ class GDriveSession(FileSystemSession):
         for file_context in files:
             if (
                 valid_file_extensions is not None
-                and os.path.splitext(file_context["name"])[1] not in valid_file_extensions
+                and os.path.splitext(file_context["name"])[1]
+                not in valid_file_extensions
             ):
                 continue
             gdrive_files.append(
@@ -256,7 +257,9 @@ class GDriveSession(FileSystemSession):
                         dest_filename=new_filename,
                     )
                 else:
-                    move_gdrive_file(self.connection, src_file.file_id, dest_file.file_id)
+                    move_gdrive_file(
+                        self.connection, src_file.file_id, dest_file.file_id
+                    )
             elif isinstance(src_file, FileObjectData):
                 if src_file.mime_type is None:
                     raise IncompatibleFileReference(

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()
@@ -53,18 +54,19 @@ class S3Session(FileSystemSession):
         recursive: bool = False,
         valid_extensions: list[str] | None = None,
     ) -> list[FileSystemObject]:
-        if recursive:
-            raise NotImplementedError("recursive file listings not implemented for s3")
-
         if not isinstance(dir_path, FileSystemFileReference):
             raise IncompatibleFileReference()
 
         assert self.bucket is not None, "call to list_files on uninitialized s3 session"
 
         filesystem_references: list[FileSystemObject] = []
-        for obj in self.bucket.objects.filter(Prefix=dir_path.filepath):
+        prefix = _add_slash(dir_path.filepath)
+        for obj in self.bucket.objects.filter(Prefix=prefix):
+            if not recursive and (obj.key == prefix or "/" in obj.key[len(prefix) :]):
+                continue
             if valid_extensions is None or any(
-                obj.key.endswith(valid_extension) for valid_extension in valid_extensions
+                obj.key.endswith(valid_extension)
+                for valid_extension in valid_extensions
             ):
                 filesystem_references.append(FileSystemFileReference(obj.key))
 
@@ -75,9 +77,9 @@ class S3Session(FileSystemSession):
         filepaths: list[FileSystemObject],
     ) -> list[FileObjectData]:
         downloaded_files: list[FileObjectData] = []
-        assert (
-            self.bucket is not None
-        ), "call to download_files on uninitialized s3 session"
+        assert self.bucket is not None, (
+            "call to download_files on uninitialized s3 session"
+        )
 
         for file_object in filepaths:
             if (
@@ -85,7 +87,7 @@ class S3Session(FileSystemSession):
                 or file_object.filename is None
             ):
                 raise IncompatibleFileReference()
-            s3_file_obj = self.bucket.Object(_add_slash(file_object.filepath))
+            s3_file_obj = self.bucket.Object(file_object.filepath)
             response = s3_file_obj.get()
             file_obj_bytes = response["Body"].read()
             downloaded_files.append(
@@ -107,10 +109,10 @@ class S3Session(FileSystemSession):
                 dest_file, FileSystemFileReference
             ):
                 raise IncompatibleFileReference()
-            self.bucket.Object(_add_slash(dest_file.filepath)).copy_from(
+            self.bucket.Object(dest_file.filepath).copy_from(
                 CopySource={
                     "Bucket": self.bucket.name,
-                    "Key": _add_slash(src_file.filepath),
+                    "Key": src_file.filepath,
                 }
             )
-            self.bucket.Object(_add_slash(src_file.filepath)).delete()
+            self.bucket.Object(src_file.filepath).delete()

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] = []
@@ -42,7 +41,8 @@ def list_sftp_files(
 
         def _add_file(path: str) -> None:
             if (
-                valid_extensions is None or os.path.splitext(path)[1] in valid_extensions
+                valid_extensions is None
+                or os.path.splitext(path)[1] in valid_extensions
             ) and (parent_dir_path is None or os.path.dirname(path) == parent_dir_path):
                 file_paths.append(path)
 
@@ -54,6 +54,10 @@ def list_sftp_files(
             os.path.join(dir_path, file)
             for file in connection.listdir(dir_path)
             if connection.isfile(os.path.join(dir_path, file))
+            and (
+                valid_extensions is None
+                or os.path.splitext(file)[1] in valid_extensions
+            )
         ])
     return file_paths
 
@@ -106,9 +110,9 @@ class SFTPSession(FileSystemSession):
         recursive: bool = True,
         valid_extensions: list[str] | None = None,
     ) -> list[FileSystemObject]:
-        if not isinstance(dir_path, FileSystemFileReference) or not self.connection.isdir(
-            dir_path.filepath
-        ):
+        if not isinstance(
+            dir_path, FileSystemFileReference
+        ) or not self.connection.isdir(dir_path.filepath):
             raise IncompatibleFileReference()
 
         return [

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,17 +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: str | None = None
 
 
 EMPTY_SERIAL_CLASS_DATA = _SerialClassData()
@@ -21,11 +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,
-) -> 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.
 
@@ -45,25 +50,32 @@ def serial_class(
         This field is always required while parsing, even if it has a default in the definition.
         This allows supporting literal type defaults for Python instantiation, but
         requiring them for the API input.
+    @param named_type_path
+        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(),
             to_string_values=to_string_values or set(),
             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:
@@ -79,30 +91,39 @@ class SerialClassDataInspector:
         return key in self.current.parse_require
 
 
-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")
         else None
     )
+    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 = 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.to_string_values |= curr_base_class_data.to_string_values
-                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
     )
 
 
@@ -113,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()
         )
@@ -132,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,37 +27,38 @@ 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
+    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,
+    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:
-    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
 
@@ -63,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