datachain 0.34.6__py3-none-any.whl → 0.34.7__py3-none-any.whl

datachain/lib/projects.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from datachain.error import ProjectCreateNotAllowedError, ProjectDeleteNotAllowedError
 from datachain.project import Project
 from datachain.query import Session
@@ -8,8 +6,8 @@ from datachain.query import Session
 def create(
     namespace: str,
     name: str,
-    descr: Optional[str] = None,
-    session: Optional[Session] = None,
+    descr: str | None = None,
+    session: Session | None = None,
 ) -> Project:
     """
     Creates a new project under a specified namespace.
@@ -42,7 +40,7 @@ def create(
     return session.catalog.metastore.create_project(namespace, name, descr)
 
 
-def get(name: str, namespace: str, session: Optional[Session]) -> Project:
+def get(name: str, namespace: str, session: Session | None) -> Project:
     """
     Gets a project by name in some namespace.
     If the project is not found, a `ProjectNotFoundError` is raised.
@@ -62,9 +60,7 @@ def get(name: str, namespace: str, session: Optional[Session]) -> Project:
     return Session.get(session).catalog.metastore.get_project(name, namespace)
 
 
-def ls(
-    namespace: Optional[str] = None, session: Optional[Session] = None
-) -> list[Project]:
+def ls(namespace: str | None = None, session: Session | None = None) -> list[Project]:
     """
     Gets a list of projects in a specific namespace or from all namespaces.
 
@@ -88,7 +84,7 @@ def ls(
     return session.catalog.metastore.list_projects(namespace_id)
 
 
-def delete(name: str, namespace: str, session: Optional[Session] = None) -> None:
+def delete(name: str, namespace: str, session: Session | None = None) -> None:
     """
     Removes a project by name within a namespace.
 

datachain/lib/pytorch.py

@@ -1,9 +1,9 @@
 import logging
 import os
 import weakref
-from collections.abc import Generator, Iterable, Iterator
+from collections.abc import Callable, Generator, Iterable, Iterator
 from contextlib import closing
-from typing import TYPE_CHECKING, Any, Callable, Optional
+from typing import TYPE_CHECKING, Any
 
 from PIL import Image
 from torch import float32
@@ -43,13 +43,13 @@ class PytorchDataset(IterableDataset):
     def __init__(
         self,
         name: str,
-        version: Optional[str] = None,
-        catalog: Optional["Catalog"] = None,
-        transform: Optional["Transform"] = None,
-        tokenizer: Optional[Callable] = None,
-        tokenizer_kwargs: Optional[dict[str, Any]] = None,
+        version: str | None = None,
+        catalog: Catalog | None = None,
+        transform: "Transform | None" = None,
+        tokenizer: Callable | None = None,
+        tokenizer_kwargs: dict[str, Any] | None = None,
         num_samples: int = 0,
-        dc_settings: Optional[Settings] = None,
+        dc_settings: Settings | None = None,
         remove_prefetched: bool = False,
     ):
         """
@@ -84,7 +84,7 @@ class PytorchDataset(IterableDataset):
             self.prefetch = prefetch
 
         self._cache = catalog.cache
-        self._prefetch_cache: Optional[Cache] = None
+        self._prefetch_cache: Cache | None = None
         self._remove_prefetched = remove_prefetched
         if prefetch and not self.cache:
             tmp_dir = catalog.cache.tmp_dir
@@ -104,7 +104,7 @@ class PytorchDataset(IterableDataset):
         self._ms_params = catalog.metastore.clone_params()
         self._wh_params = catalog.warehouse.clone_params()
         self._catalog_params = catalog.get_init_params()
-        self.catalog: Optional[Catalog] = None
+        self.catalog: Catalog | None = None
 
     def _get_catalog(self) -> "Catalog":
         ms_cls, ms_args, ms_kwargs = self._ms_params

datachain/lib/settings.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional, Union
+from typing import Any
 
 from datachain.lib.utils import DataChainParamsError
 
@@ -15,25 +15,25 @@ class SettingsError(DataChainParamsError):
 class Settings:
     """Settings for datachain."""
 
-    _cache: Optional[bool]
-    _prefetch: Optional[int]
-    _parallel: Optional[Union[bool, int]]
-    _workers: Optional[int]
-    _namespace: Optional[str]
-    _project: Optional[str]
-    _min_task_size: Optional[int]
-    _batch_size: Optional[int]
+    _cache: bool | None
+    _prefetch: int | None
+    _parallel: bool | int | None
+    _workers: int | None
+    _namespace: str | None
+    _project: str | None
+    _min_task_size: int | None
+    _batch_size: int | None
 
     def __init__(  # noqa: C901, PLR0912
         self,
-        cache: Optional[bool] = None,
-        prefetch: Optional[Union[bool, int]] = None,
-        parallel: Optional[Union[bool, int]] = None,
-        workers: Optional[int] = None,
-        namespace: Optional[str] = None,
-        project: Optional[str] = None,
-        min_task_size: Optional[int] = None,
-        batch_size: Optional[int] = None,
+        cache: bool | None = None,
+        prefetch: bool | int | None = None,
+        parallel: bool | int | None = None,
+        workers: int | None = None,
+        namespace: str | None = None,
+        project: str | None = None,
+        min_task_size: int | None = None,
+        batch_size: int | None = None,
     ) -> None:
         if cache is None:
             self._cache = None
@@ -148,27 +148,27 @@ class Settings:
         return self._cache if self._cache is not None else DEFAULT_CACHE
 
     @property
-    def prefetch(self) -> Optional[int]:
+    def prefetch(self) -> int | None:
         return self._prefetch if self._prefetch is not None else DEFAULT_PREFETCH
 
     @property
-    def parallel(self) -> Optional[Union[bool, int]]:
+    def parallel(self) -> bool | int | None:
         return self._parallel if self._parallel is not None else None
 
     @property
-    def workers(self) -> Optional[int]:
+    def workers(self) -> int | None:
         return self._workers if self._workers is not None else None
 
     @property
-    def namespace(self) -> Optional[str]:
+    def namespace(self) -> str | None:
         return self._namespace if self._namespace is not None else None
 
     @property
-    def project(self) -> Optional[str]:
+    def project(self) -> str | None:
         return self._project if self._project is not None else None
 
     @property
-    def min_task_size(self) -> Optional[int]:
+    def min_task_size(self) -> int | None:
         return self._min_task_size if self._min_task_size is not None else None
 
     @property

datachain/lib/signal_schema.py

@@ -3,22 +3,21 @@ import hashlib
 import json
 import logging
 import math
+import types
 import warnings
-from collections.abc import Iterator, Sequence
+from collections.abc import Callable, Iterator, Mapping, Sequence
 from dataclasses import dataclass
 from datetime import datetime
 from inspect import isclass
-from typing import (  # noqa: UP035
+from typing import (
     IO,
     TYPE_CHECKING,
     Annotated,
     Any,
-    Callable,
-    Dict,
+    Dict,  # type: ignore[UP035]
     Final,
-    List,
+    List,  # type: ignore[UP035]
     Literal,
-    Mapping,
     Optional,
     Union,
     get_args,
@@ -75,7 +74,7 @@ class SignalSchemaWarning(RuntimeWarning):
 
 
 class SignalResolvingError(SignalSchemaError):
-    def __init__(self, path: Optional[list[str]], msg: str):
+    def __init__(self, path: list[str] | None, msg: str):
         name = " '" + ".".join(path) + "'" if path else ""
         super().__init__(f"cannot resolve signal name{name}: {msg}")
 
@@ -95,7 +94,7 @@ class SignalResolvingTypeError(SignalResolvingError):
 
 
 class SignalRemoveError(SignalSchemaError):
-    def __init__(self, path: Optional[list[str]], msg: str):
+    def __init__(self, path: list[str] | None, msg: str):
         name = " '" + ".".join(path) + "'" if path else ""
         super().__init__(f"cannot remove signal name{name}: {msg}")
 
@@ -104,8 +103,8 @@ class CustomType(BaseModel):
     schema_version: int = Field(ge=1, le=2, strict=True)
     name: str
     fields: dict[str, str]
-    bases: list[tuple[str, str, Optional[str]]]
-    hidden_fields: Optional[list[str]] = None
+    bases: list[tuple[str, str, str | None]]
+    hidden_fields: list[str] | None = None
 
     @classmethod
     def deserialize(cls, data: dict[str, Any], type_name: str) -> "CustomType":
@@ -125,8 +124,8 @@ class CustomType(BaseModel):
 
 def create_feature_model(
     name: str,
-    fields: Mapping[str, Union[type, None, tuple[type, Any]]],
-    base: Optional[type] = None,
+    fields: Mapping[str, type | tuple[type, Any] | None],
+    base: type | None = None,
 ) -> type[BaseModel]:
     """
     This gets or returns a dynamic feature model for use in restoring a model
@@ -152,12 +151,12 @@ class SignalSchema:
     values: dict[str, DataType]
     tree: dict[str, Any]
     setup_func: dict[str, Callable]
-    setup_values: Optional[dict[str, Any]]
+    setup_values: dict[str, Any] | None
 
     def __init__(
         self,
         values: dict[str, DataType],
-        setup: Optional[dict[str, Callable]] = None,
+        setup: dict[str, Callable] | None = None,
     ):
         self.values = values
         self.tree = self._build_tree(values)
@@ -196,8 +195,8 @@ class SignalSchema:
         return SignalSchema(signals)
 
     @staticmethod
-    def _get_bases(fr: type) -> list[tuple[str, str, Optional[str]]]:
-        bases: list[tuple[str, str, Optional[str]]] = []
+    def _get_bases(fr: type) -> list[tuple[str, str, str | None]]:
+        bases: list[tuple[str, str, str | None]] = []
         for base in fr.__mro__:
             model_store_name = (
                 ModelStore.get_name(base) if issubclass(base, DataModel) else None
@@ -294,7 +293,7 @@ class SignalSchema:
     @staticmethod
     def _deserialize_custom_type(
         type_name: str, custom_types: dict[str, Any]
-    ) -> Optional[type]:
+    ) -> type | None:
         """Given a type name like MyType@v1 gets a type from ModelStore or recreates
         it based on the information from the custom types dict that includes fields and
         bases."""
@@ -327,7 +326,7 @@ class SignalSchema:
         return None
 
     @staticmethod
-    def _resolve_type(type_name: str, custom_types: dict[str, Any]) -> Optional[type]:
+    def _resolve_type(type_name: str, custom_types: dict[str, Any]) -> type | None:
         """Convert a string-based type back into a python type."""
         type_name = type_name.strip()
         if not type_name:
@@ -336,7 +335,7 @@ class SignalSchema:
             return None
 
         bracket_idx = type_name.find("[")
-        subtypes: Optional[tuple[Optional[type], ...]] = None
+        subtypes: tuple[type | None, ...] | None = None
         if bracket_idx > -1:
             if bracket_idx == 0:
                 raise ValueError("Type cannot start with '['")
@@ -493,7 +492,7 @@ class SignalSchema:
             return math.isnan(value) or value is None
         return value is None
 
-    def get_file_signal(self) -> Optional[str]:
+    def get_file_signal(self) -> str | None:
         for signal_name, signal_type in self.values.items():
             if (fr := ModelStore.to_pydantic(signal_type)) is not None and issubclass(
                 fr, File
@@ -503,8 +502,8 @@ class SignalSchema:
 
     def slice(
         self,
-        params: dict[str, Union[DataType, Any]],
-        setup: Optional[dict[str, Callable]] = None,
+        params: dict[str, DataType | Any],
+        setup: dict[str, Callable] | None = None,
         is_batch: bool = False,
     ) -> "SignalSchema":
         """
@@ -528,9 +527,13 @@ class SignalSchema:
             schema_origin = get_origin(schema_type)
             param_origin = get_origin(param_type)
 
-            if schema_origin is Union and type(None) in get_args(schema_type):
+            if schema_origin in (Union, types.UnionType) and type(None) in get_args(
+                schema_type
+            ):
                 schema_type = get_args(schema_type)[0]
-                if param_origin is Union and type(None) in get_args(param_type):
+                if param_origin in (Union, types.UnionType) and type(None) in get_args(
+                    param_type
+                ):
                     param_type = get_args(param_type)[0]
 
             if is_batch:
@@ -610,8 +613,8 @@ class SignalSchema:
         raise SignalResolvingError([col_name], "is not found")
 
     def db_signals(
-        self, name: Optional[str] = None, as_columns=False, include_hidden: bool = True
-    ) -> Union[list[str], list[Column]]:
+        self, name: str | None = None, as_columns=False, include_hidden: bool = True
+    ) -> list[str] | list[Column]:
         """
         Returns DB columns as strings or Column objects with proper types
         Optionally, it can filter results by specific object, returning only his signals
@@ -802,7 +805,7 @@ class SignalSchema:
     @staticmethod
     def _build_tree(
         values: dict[str, DataType],
-    ) -> dict[str, tuple[DataType, Optional[dict]]]:
+    ) -> dict[str, tuple[DataType, dict | None]]:
         return {
             name: (val, SignalSchema._build_tree_for_type(val))
             for name, val in values.items()
@@ -834,7 +837,7 @@ class SignalSchema:
                     substree, new_prefix, depth + 1, include_hidden
                 )
 
-    def print_tree(self, indent: int = 2, start_at: int = 0, file: Optional[IO] = None):
+    def print_tree(self, indent: int = 2, start_at: int = 0, file: IO | None = None):
         for path, type_, _, depth in self.get_flat_tree():
             total_indent = start_at + depth * indent
             col_name = " " * total_indent + path[-1]
@@ -873,15 +876,20 @@ class SignalSchema:
         return self.values.pop(name)
 
     @staticmethod
-    def _type_to_str(type_: Optional[type], subtypes: Optional[list] = None) -> str:  # noqa: PLR0911
+    def _type_to_str(type_: type | None, subtypes: list | None = None) -> str:  # noqa: C901, PLR0911
         """Convert a type to a string-based representation."""
         if type_ is None:
             return "NoneType"
 
         origin = get_origin(type_)
 
-        if origin == Union:
+        if origin in (Union, types.UnionType):
             args = get_args(type_)
+            if len(args) == 2 and type(None) in args:
+                # This is an Optional type.
+                non_none_type = args[0] if args[1] is type(None) else args[1]
+                type_str = SignalSchema._type_to_str(non_none_type, subtypes)
+                return f"Optional[{type_str}]"
             formatted_types = ", ".join(
                 SignalSchema._type_to_str(arg, subtypes) for arg in args
             )
@@ -892,19 +900,19 @@ class SignalSchema:
             return f"Optional[{type_str}]"
         if origin in (list, List):  # noqa: UP006
             args = get_args(type_)
+            if len(args) == 0:
+                return "list"
             type_str = SignalSchema._type_to_str(args[0], subtypes)
             return f"list[{type_str}]"
         if origin in (dict, Dict):  # noqa: UP006
             args = get_args(type_)
-            type_str = (
-                SignalSchema._type_to_str(args[0], subtypes) if len(args) > 0 else ""
-            )
-            vals = (
-                f", {SignalSchema._type_to_str(args[1], subtypes)}"
-                if len(args) > 1
-                else ""
-            )
-            return f"dict[{type_str}{vals}]"
+            if len(args) == 0:
+                return "dict"
+            key_type = SignalSchema._type_to_str(args[0], subtypes)
+            if len(args) == 1:
+                return f"dict[{key_type}, Any]"
+            val_type = SignalSchema._type_to_str(args[1], subtypes)
+            return f"dict[{key_type}, {val_type}]"
         if origin == Annotated:
             args = get_args(type_)
             return SignalSchema._type_to_str(args[0], subtypes)
@@ -918,7 +926,7 @@ class SignalSchema:
             # Include this type in the list of all subtypes, if requested.
             subtypes.append(type_)
         if not hasattr(type_, "__name__"):
-            # This can happen for some third-party or custom types, mostly on Python 3.9
+            # This can happen for some third-party or custom types
             warnings.warn(
                 f"Unable to determine name of type '{type_}'.",
                 SignalSchemaWarning,
@@ -933,7 +941,7 @@ class SignalSchema:
     @staticmethod
     def _build_tree_for_type(
         model: DataType,
-    ) -> Optional[dict[str, tuple[DataType, Optional[dict]]]]:
+    ) -> dict[str, tuple[DataType, dict | None]] | None:
         if (fr := ModelStore.to_pydantic(model)) is not None:
             return SignalSchema._build_tree_for_model(fr)
         return None
@@ -941,8 +949,8 @@ class SignalSchema:
     @staticmethod
     def _build_tree_for_model(
         model: type[BaseModel],
-    ) -> Optional[dict[str, tuple[DataType, Optional[dict]]]]:
-        res: dict[str, tuple[DataType, Optional[dict]]] = {}
+    ) -> dict[str, tuple[DataType, dict | None]] | None:
+        res: dict[str, tuple[DataType, dict | None]] = {}
 
         for name, f_info in model.model_fields.items():
             anno = f_info.annotation
@@ -991,7 +999,7 @@ class SignalSchema:
         schema: dict[str, Any] = {}
         schema_custom_types: dict[str, CustomType] = {}
 
-        data_model_bases: Optional[list[tuple[str, str, Optional[str]]]] = None
+        data_model_bases: list[tuple[str, str, str | None]] | None = None
 
         signal_partials: dict[str, str] = {}
         partial_versions: dict[str, int] = {}

datachain/lib/text.py

@@ -1,16 +1,17 @@
-from typing import Any, Callable, Optional, Union
+from collections.abc import Callable
+from typing import Any
 
 import torch
 from transformers.tokenization_utils_base import PreTrainedTokenizerBase
 
 
 def convert_text(
-    text: Union[str, list[str]],
-    tokenizer: Optional[Callable] = None,
-    tokenizer_kwargs: Optional[dict[str, Any]] = None,
-    encoder: Optional[Callable] = None,
-    device: Optional[Union[str, torch.device]] = None,
-) -> Union[str, list[str], torch.Tensor]:
+    text: str | list[str],
+    tokenizer: Callable | None = None,
+    tokenizer_kwargs: dict[str, Any] | None = None,
+    encoder: Callable | None = None,
+    device: str | torch.device | None = None,
+) -> str | list[str] | torch.Tensor:
     """
     Tokenize and otherwise transform text.
 

datachain/lib/udf.py

@@ -4,7 +4,7 @@ import traceback
 from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence
 from contextlib import closing, nullcontext
 from functools import partial
-from typing import TYPE_CHECKING, Any, Optional, TypeVar
+from typing import TYPE_CHECKING, Any, TypeVar
 
 import attrs
 from fsspec.callbacks import DEFAULT_CALLBACK, Callback
@@ -60,7 +60,7 @@ UDFResult = dict[str, Any]
 class UDFAdapter:
     inner: "UDFBase"
     output: UDFOutputSpec
-    batch_size: Optional[int] = None
+    batch_size: int | None = None
     batch: int = 1
 
     def hash(self) -> str:
@@ -152,7 +152,7 @@ class UDFBase(AbstractUDF):
     prefetch: int = 0
 
     def __init__(self):
-        self.params: Optional[SignalSchema] = None
+        self.params: SignalSchema | None = None
         self.output = None
         self._func = None
 
@@ -197,7 +197,7 @@ class UDFBase(AbstractUDF):
         self,
         sign: "UdfSignature",
         params: "SignalSchema",
-        func: Optional[Callable],
+        func: Callable | None,
     ):
         self.params = params
         self.output = sign.output_schema
@@ -246,7 +246,7 @@ class UDFBase(AbstractUDF):
 
     def to_udf_wrapper(
         self,
-        batch_size: Optional[int] = None,
+        batch_size: int | None = None,
         batch: int = 1,
     ) -> UDFAdapter:
         return UDFAdapter(
@@ -304,11 +304,11 @@ class UDFBase(AbstractUDF):
                     self._set_stream_recursive(field_value, catalog, cache, download_cb)
 
     def _prepare_row(self, row, udf_fields, catalog, cache, download_cb):
-        row_dict = RowDict(zip(udf_fields, row))
+        row_dict = RowDict(zip(udf_fields, row, strict=False))
         return self._parse_row(row_dict, catalog, cache, download_cb)
 
     def _prepare_row_and_id(self, row, udf_fields, catalog, cache, download_cb):
-        row_dict = RowDict(zip(udf_fields, row))
+        row_dict = RowDict(zip(udf_fields, row, strict=False))
         udf_input = self._parse_row(row_dict, catalog, cache, download_cb)
         return row_dict["sys__id"], *udf_input
 
@@ -333,7 +333,7 @@ def noop(*args, **kwargs):
 
 async def _prefetch_input(
     row: T,
-    download_cb: Optional["Callback"] = None,
+    download_cb: Callback | None = None,
     after_prefetch: "Callable[[], None]" = noop,
 ) -> T:
     for obj in row:
@@ -356,8 +356,8 @@ def _remove_prefetched(row: T) -> None:
 def _prefetch_inputs(
     prepared_inputs: "Iterable[T]",
     prefetch: int = 0,
-    download_cb: Optional["Callback"] = None,
-    after_prefetch: Optional[Callable[[], None]] = None,
+    download_cb: Callback | None = None,
+    after_prefetch: Callable[[], None] | None = None,
     remove_prefetched: bool = False,
 ) -> "abc.Generator[T, None, None]":
     if not prefetch:
@@ -426,7 +426,10 @@ class Mapper(UDFBase):
             for id_, *udf_args in prepared_inputs:
                 result_objs = self.process_safe(udf_args)
                 udf_output = self._flatten_row(result_objs)
-                output = [{"sys__id": id_} | dict(zip(self.signal_names, udf_output))]
+                output = [
+                    {"sys__id": id_}
+                    | dict(zip(self.signal_names, udf_output, strict=False))
+                ]
                 processed_cb.relative_update(1)
                 yield output
 
@@ -474,7 +477,8 @@ class BatchMapper(UDFBase):
                         row, udf_fields, catalog, cache, download_cb
                     )
                     for row in batch
-                ]
+                ],
+                strict=False,
             )
             result_objs = list(self.process_safe(udf_args))
             n_objs = len(result_objs)
@@ -483,8 +487,9 @@ class BatchMapper(UDFBase):
             )
             udf_outputs = (self._flatten_row(row) for row in result_objs)
             output = [
-                {"sys__id": row_id} | dict(zip(self.signal_names, signals))
-                for row_id, signals in zip(row_ids, udf_outputs)
+                {"sys__id": row_id}
+                | dict(zip(self.signal_names, signals, strict=False))
+                for row_id, signals in zip(row_ids, udf_outputs, strict=False)
             ]
             processed_cb.relative_update(n_rows)
             yield output
@@ -520,7 +525,7 @@ class Generator(UDFBase):
             with safe_closing(self.process_safe(row)) as result_objs:
                 for result_obj in result_objs:
                     udf_output = self._flatten_row(result_obj)
-                    yield dict(zip(self.signal_names, udf_output))
+                    yield dict(zip(self.signal_names, udf_output, strict=False))
 
         prepared_inputs = _prepare_rows(udf_inputs)
         prepared_inputs = _prefetch_inputs(
@@ -559,11 +564,14 @@ class Aggregator(UDFBase):
                 *[
                     self._prepare_row(row, udf_fields, catalog, cache, download_cb)
                     for row in batch
-                ]
+                ],
+                strict=False,
             )
             result_objs = self.process_safe(udf_args)
             udf_outputs = (self._flatten_row(row) for row in result_objs)
-            output = (dict(zip(self.signal_names, row)) for row in udf_outputs)
+            output = (
+                dict(zip(self.signal_names, row, strict=False)) for row in udf_outputs
+            )
             processed_cb.relative_update(len(batch))
             yield output
 

datachain/lib/udf_signature.py

@@ -1,7 +1,7 @@
 import inspect
-from collections.abc import Generator, Iterator, Sequence
+from collections.abc import Callable, Generator, Iterator, Sequence
 from dataclasses import dataclass
-from typing import Any, Callable, Union, get_args, get_origin
+from typing import Any, get_args, get_origin
 
 from datachain.lib.data_model import DataType, DataTypeNames, is_chain_type
 from datachain.lib.signal_schema import SignalSchema
@@ -17,8 +17,8 @@ class UdfSignatureError(DataChainParamsError):
 
 @dataclass
 class UdfSignature:  # noqa: PLW1641
-    func: Union[Callable, UDFBase]
-    params: dict[str, Union[DataType, Any]]
+    func: Callable | UDFBase
+    params: dict[str, DataType | Any]
     output_schema: SignalSchema
 
     DEFAULT_RETURN_TYPE = str
@@ -28,9 +28,9 @@ class UdfSignature:  # noqa: PLW1641
         cls,
         chain: str,
         signal_map: dict[str, Callable],
-        func: Union[None, UDFBase, Callable] = None,
-        params: Union[None, str, Sequence[str]] = None,
-        output: Union[None, DataType, Sequence[str], dict[str, DataType]] = None,
+        func: UDFBase | Callable | None = None,
+        params: str | Sequence[str] | None = None,
+        output: DataType | Sequence[str] | dict[str, DataType] | None = None,
         is_generator: bool = True,
     ) -> "UdfSignature":
         keys = ", ".join(signal_map.keys())
@@ -40,7 +40,7 @@ class UdfSignature:  # noqa: PLW1641
                 f"multiple signals '{keys}' are not supported in processors."
                 " Chain multiple processors instead.",
             )
-        udf_func: Union[UDFBase, Callable]
+        udf_func: UDFBase | Callable
         if len(signal_map) == 1:
             if func is not None:
                 raise UdfSignatureError(
@@ -62,7 +62,7 @@ class UdfSignature:  # noqa: PLW1641
             chain, udf_func
         )
 
-        udf_params: dict[str, Union[DataType, Any]] = {}
+        udf_params: dict[str, DataType | Any] = {}
         if params:
             udf_params = (
                 {params: Any} if isinstance(params, str) else dict.fromkeys(params, Any)
@@ -128,7 +128,7 @@ class UdfSignature:  # noqa: PLW1641
                     f" return type length ({len(func_outs_sign)}) does not match",
                 )
 
-            udf_output_map = dict(zip(output, func_outs_sign))
+            udf_output_map = dict(zip(output, func_outs_sign, strict=False))
         elif isinstance(output, dict):
             for key, value in output.items():
                 if not isinstance(key, str):
@@ -164,7 +164,7 @@ class UdfSignature:  # noqa: PLW1641
 
     @staticmethod
     def _func_signature(
-        chain: str, udf_func: Union[Callable, UDFBase]
+        chain: str, udf_func: Callable | UDFBase
     ) -> tuple[dict[str, type], Sequence[type], bool]:
         if isinstance(udf_func, AbstractUDF):
             func = udf_func.process  # type: ignore[unreachable]