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

datachain/diff/__init__.py

@@ -1,6 +1,6 @@
 from collections.abc import Sequence
 from enum import Enum
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING
 
 from datachain.func import case, ifelse, isnone, or_
 from datachain.lib.signal_schema import SignalSchema
@@ -27,22 +27,22 @@ class CompareStatus(str, Enum):
 def _compare(  # noqa: C901, PLR0912
     left: "DataChain",
     right: "DataChain",
-    on: Union[str, Sequence[str]],
-    right_on: Optional[Union[str, Sequence[str]]] = None,
-    compare: Optional[Union[str, Sequence[str]]] = None,
-    right_compare: Optional[Union[str, Sequence[str]]] = None,
+    on: str | Sequence[str],
+    right_on: str | Sequence[str] | None = None,
+    compare: str | Sequence[str] | None = None,
+    right_compare: str | Sequence[str] | None = None,
     added: bool = True,
     deleted: bool = True,
     modified: bool = True,
     same: bool = True,
-    status_col: Optional[str] = None,
+    status_col: str | None = None,
 ) -> "DataChain":
     """Comparing two chains by identifying rows that are added, deleted, modified
     or same"""
     rname = "right_"
     schema = left.signals_schema  # final chain must have schema from left chain
 
-    def _to_list(obj: Optional[Union[str, Sequence[str]]]) -> Optional[list[str]]:
+    def _to_list(obj: str | Sequence[str] | None) -> list[str] | None:
         if obj is None:
             return None
         return [obj] if isinstance(obj, str) else list(obj)
@@ -109,7 +109,7 @@ def _compare(  # noqa: C901, PLR0912
         modified_cond = or_(  # type: ignore[assignment]
             *[
                 C(c) != (C(f"{rname}{rc}") if c == rc else C(rc))
-                for c, rc in zip(compare, right_compare)  # type: ignore[arg-type]
+                for c, rc in zip(compare, right_compare, strict=False)  # type: ignore[arg-type]
             ]
         )
 
@@ -133,7 +133,7 @@ def _compare(  # noqa: C901, PLR0912
                     C(f"{rname + l_on if on == right_on else r_on}"),
                     C(l_on),
                 )
-                for l_on, r_on in zip(on, right_on)  # type: ignore[arg-type]
+                for l_on, r_on in zip(on, right_on, strict=False)  # type: ignore[arg-type]
             }
         )
         .select_except(ldiff_col, rdiff_col)
@@ -168,10 +168,10 @@ def _compare(  # noqa: C901, PLR0912
 def compare_and_split(
     left: "DataChain",
     right: "DataChain",
-    on: Union[str, Sequence[str]],
-    right_on: Optional[Union[str, Sequence[str]]] = None,
-    compare: Optional[Union[str, Sequence[str]]] = None,
-    right_compare: Optional[Union[str, Sequence[str]]] = None,
+    on: str | Sequence[str],
+    right_on: str | Sequence[str] | None = None,
+    compare: str | Sequence[str] | None = None,
+    right_compare: str | Sequence[str] | None = None,
     added: bool = True,
     deleted: bool = True,
     modified: bool = True,

datachain/func/aggregate.py

@@ -1,5 +1,3 @@
-from typing import Optional, Union
-
 from sqlalchemy import func as sa_func
 
 from datachain.query.schema import Column
@@ -8,7 +6,7 @@ from datachain.sql.functions import aggregate
 from .func import Func
 
 
-def count(col: Optional[Union[str, Column]] = None) -> Func:
+def count(col: str | Column | None = None) -> Func:
     """
     Returns a COUNT aggregate SQL function for the specified column.
 
@@ -44,7 +42,7 @@ def count(col: Optional[Union[str, Column]] = None) -> Func:
     )
 
 
-def sum(col: Union[str, Column]) -> Func:
+def sum(col: str | Column) -> Func:
     """
     Returns the SUM aggregate SQL function for the specified column.
 
@@ -74,7 +72,7 @@ def sum(col: Union[str, Column]) -> Func:
     return Func("sum", inner=sa_func.sum, cols=[col])
 
 
-def avg(col: Union[str, Column]) -> Func:
+def avg(col: str | Column) -> Func:
     """
     Returns the AVG aggregate SQL function for the specified column.
 
@@ -104,7 +102,7 @@ def avg(col: Union[str, Column]) -> Func:
     return Func("avg", inner=aggregate.avg, cols=[col], result_type=float)
 
 
-def min(col: Union[str, Column]) -> Func:
+def min(col: str | Column) -> Func:
     """
     Returns the MIN aggregate SQL function for the specified column.
 
@@ -134,7 +132,7 @@ def min(col: Union[str, Column]) -> Func:
     return Func("min", inner=sa_func.min, cols=[col])
 
 
-def max(col: Union[str, Column]) -> Func:
+def max(col: str | Column) -> Func:
     """
     Returns the MAX aggregate SQL function for the given column name.
 
@@ -164,7 +162,7 @@ def max(col: Union[str, Column]) -> Func:
     return Func("max", inner=sa_func.max, cols=[col])
 
 
-def any_value(col: Union[str, Column]) -> Func:
+def any_value(col: str | Column) -> Func:
     """
     Returns the ANY_VALUE aggregate SQL function for the given column name.
 
@@ -198,7 +196,7 @@ def any_value(col: Union[str, Column]) -> Func:
     return Func("any_value", inner=aggregate.any_value, cols=[col])
 
 
-def collect(col: Union[str, Column]) -> Func:
+def collect(col: str | Column) -> Func:
     """
     Returns the COLLECT aggregate SQL function for the given column name.
 
@@ -229,7 +227,7 @@ def collect(col: Union[str, Column]) -> Func:
     return Func("collect", inner=aggregate.collect, cols=[col], is_array=True)
 
 
-def concat(col: Union[str, Column], separator="") -> Func:
+def concat(col: str | Column, separator="") -> Func:
     """
     Returns the CONCAT aggregate SQL function for the given column name.
 
@@ -348,7 +346,7 @@ def dense_rank() -> Func:
     return Func("dense_rank", inner=sa_func.dense_rank, result_type=int, is_window=True)
 
 
-def first(col: Union[str, Column]) -> Func:
+def first(col: str | Column) -> Func:
     """
     Returns the FIRST_VALUE window function for SQL queries.
 

datachain/func/array.py

@@ -1,5 +1,5 @@
 from collections.abc import Sequence
-from typing import Any, Optional, Union
+from typing import Any
 
 from datachain.query.schema import Column
 from datachain.sql.functions import array
@@ -7,7 +7,7 @@ from datachain.sql.functions import array
 from .func import Func
 
 
-def cosine_distance(*args: Union[str, Column, Func, Sequence]) -> Func:
+def cosine_distance(*args: str | Column | Func | Sequence) -> Func:
     """
     Returns the cosine distance between two vectors.
 
@@ -62,7 +62,7 @@ def cosine_distance(*args: Union[str, Column, Func, Sequence]) -> Func:
     )
 
 
-def euclidean_distance(*args: Union[str, Column, Func, Sequence]) -> Func:
+def euclidean_distance(*args: str | Column | Func | Sequence) -> Func:
     """
     Returns the Euclidean distance between two vectors.
 
@@ -115,7 +115,7 @@ def euclidean_distance(*args: Union[str, Column, Func, Sequence]) -> Func:
     )
 
 
-def length(arg: Union[str, Column, Func, Sequence]) -> Func:
+def length(arg: str | Column | Func | Sequence) -> Func:
     """
     Returns the length of the array.
 
@@ -151,7 +151,7 @@ def length(arg: Union[str, Column, Func, Sequence]) -> Func:
     return Func("length", inner=array.length, cols=cols, args=args, result_type=int)
 
 
-def contains(arr: Union[str, Column, Func, Sequence], elem: Any) -> Func:
+def contains(arr: str | Column | Func | Sequence, elem: Any) -> Func:
     """
     Checks whether the array contains the specified element.
 
@@ -196,9 +196,9 @@ def contains(arr: Union[str, Column, Func, Sequence], elem: Any) -> Func:
 
 
 def slice(
-    arr: Union[str, Column, Func, Sequence],
+    arr: str | Column | Func | Sequence,
     offset: int,
-    length: Optional[int] = None,
+    length: int | None = None,
 ) -> Func:
     """
     Returns a slice of the array starting from the specified offset.
@@ -272,7 +272,7 @@ def slice(
 
 
 def join(
-    arr: Union[str, Column, Func, Sequence],
+    arr: str | Column | Func | Sequence,
     sep: str = "",
 ) -> Func:
     """
@@ -322,7 +322,7 @@ def join(
     )
 
 
-def get_element(arg: Union[str, Column, Func, Sequence], index: int) -> Func:
+def get_element(arg: str | Column | Func | Sequence, index: int) -> Func:
     """
     Returns the element at the given index from the array.
     If the index is out of bounds, it returns None or columns default value.
@@ -359,8 +359,8 @@ def get_element(arg: Union[str, Column, Func, Sequence], index: int) -> Func:
                 return str  # if the array is empty, return str as default type
         return None
 
-    cols: Optional[Union[str, Column, Func, Sequence]]
-    args: Union[str, Column, Func, Sequence, int]
+    cols: str | Column | Func | Sequence | None
+    args: str | Column | Func | Sequence | int
 
     if isinstance(arg, (str, Column, Func)):
         cols = [arg]
@@ -379,7 +379,7 @@ def get_element(arg: Union[str, Column, Func, Sequence], index: int) -> Func:
     )
 
 
-def sip_hash_64(arg: Union[str, Column, Func, Sequence]) -> Func:
+def sip_hash_64(arg: str | Column | Func | Sequence) -> Func:
     """
     Returns the SipHash-64 hash of the array.
 

datachain/func/base.py

@@ -1,5 +1,6 @@
 from abc import ABCMeta, abstractmethod
-from typing import TYPE_CHECKING, Optional
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from sqlalchemy import TableClause
@@ -12,12 +13,14 @@ class Function:
     __metaclass__ = ABCMeta
 
     name: str
+    cols: Sequence
+    args: Sequence
 
     @abstractmethod
     def get_column(
         self,
-        signals_schema: Optional["SignalSchema"] = None,
-        label: Optional[str] = None,
-        table: Optional["TableClause"] = None,
+        signals_schema: "SignalSchema | None" = None,
+        label: str | None = None,
+        table: "TableClause | None" = None,
     ) -> "Column":
         pass

datachain/func/conditional.py

@@ -1,5 +1,3 @@
-from typing import Optional, Union
-
 from sqlalchemy import ColumnElement
 from sqlalchemy import and_ as sql_and
 from sqlalchemy import case as sql_case
@@ -12,10 +10,10 @@ from datachain.sql.functions import conditional
 
 from .func import Func
 
-CaseT = Union[int, float, complex, bool, str, Func, ColumnElement]
+CaseT = int | float | complex | bool | str | Func | ColumnElement
 
 
-def greatest(*args: Union[str, Column, Func, float]) -> Func:
+def greatest(*args: str | Column | Func | float) -> Func:
     """
     Returns the greatest (largest) value from the given input values.
 
@@ -56,7 +54,7 @@ def greatest(*args: Union[str, Column, Func, float]) -> Func:
     )
 
 
-def least(*args: Union[str, Column, Func, float]) -> Func:
+def least(*args: str | Column | Func | float) -> Func:
     """
     Returns the least (smallest) value from the given input values.
 
@@ -94,7 +92,7 @@ def least(*args: Union[str, Column, Func, float]) -> Func:
 
 
 def case(
-    *args: tuple[Union[ColumnElement, Func, bool], CaseT], else_: Optional[CaseT] = None
+    *args: tuple[ColumnElement | Func | bool, CaseT], else_: CaseT | None = None
 ) -> Func:
     """
     Returns a case expression that evaluates a list of conditions and returns
@@ -163,9 +161,7 @@ def case(
     return Func("case", inner=sql_case, cols=args, kwargs=kwargs, result_type=type_)
 
 
-def ifelse(
-    condition: Union[ColumnElement, Func], if_val: CaseT, else_val: CaseT
-) -> Func:
+def ifelse(condition: ColumnElement | Func, if_val: CaseT, else_val: CaseT) -> Func:
     """
     Returns an if-else expression that evaluates a condition and returns one
     of two values based on the result. Values can be Python primitives
@@ -193,7 +189,7 @@ def ifelse(
     return case((condition, if_val), else_=else_val)
 
 
-def isnone(col: Union[str, ColumnElement]) -> Func:
+def isnone(col: str | ColumnElement) -> Func:
     """
     Returns a function that checks if the column value is `None` (NULL in DB).
 
@@ -221,7 +217,7 @@ def isnone(col: Union[str, ColumnElement]) -> Func:
     return case((col.is_(None) if col is not None else True, True), else_=False)
 
 
-def or_(*args: Union[ColumnElement, Func]) -> Func:
+def or_(*args: ColumnElement | Func) -> Func:
     """
     Returns the function that produces conjunction of expressions joined by OR
     logical operator.
@@ -256,7 +252,7 @@ def or_(*args: Union[ColumnElement, Func]) -> Func:
     return Func("or", inner=sql_or, cols=cols, args=func_args, result_type=bool)
 
 
-def and_(*args: Union[ColumnElement, Func]) -> Func:
+def and_(*args: ColumnElement | Func) -> Func:
     """
     Returns the function that produces conjunction of expressions joined by AND
     logical operator.
@@ -291,7 +287,7 @@ def and_(*args: Union[ColumnElement, Func]) -> Func:
     return Func("and", inner=sql_and, cols=cols, args=func_args, result_type=bool)
 
 
-def not_(arg: Union[ColumnElement, Func]) -> Func:
+def not_(arg: ColumnElement | Func) -> Func:
     """
     Returns the function that produces NOT of the given expressions.
 

datachain/func/func.py

@@ -1,6 +1,6 @@
 import inspect
-from collections.abc import Sequence
-from typing import TYPE_CHECKING, Any, Callable, Optional, Union, get_args, get_origin
+from collections.abc import Callable, Sequence
+from typing import TYPE_CHECKING, Any, Union, get_args, get_origin
 
 from sqlalchemy import BindParameter, Case, ColumnElement, Integer, cast, desc
 from sqlalchemy.sql import func as sa_func
@@ -22,26 +22,29 @@ if TYPE_CHECKING:
     from .window import Window
 
 
-ColT = Union[str, Column, ColumnElement, "Func", tuple]
+ColT = Union[str, tuple, Column, ColumnElement, "Func"]
 
 
 class Func(Function):  # noqa: PLW1641
     """Represents a function to be applied to a column in a SQL query."""
 
+    cols: Sequence[ColT]
+    args: Sequence[Any]
+
     def __init__(
         self,
         name: str,
         inner: Callable,
-        cols: Optional[Sequence[ColT]] = None,
-        args: Optional[Sequence[Any]] = None,
-        kwargs: Optional[dict[str, Any]] = None,
-        result_type: Optional["DataType"] = None,
-        type_from_args: Optional[Callable[..., "DataType"]] = None,
+        cols: Sequence[ColT] | None = None,
+        args: Sequence[Any] | None = None,
+        kwargs: dict[str, Any] | None = None,
+        result_type: "DataType | None" = None,
+        type_from_args: Callable[..., "DataType"] | None = None,
         is_array: bool = False,
         from_array: bool = False,
         is_window: bool = False,
-        window: Optional["Window"] = None,
-        label: Optional[str] = None,
+        window: "Window | None" = None,
+        label: str | None = None,
     ) -> None:
         self.name = name
         self.inner = inner
@@ -95,7 +98,7 @@ class Func(Function):  # noqa: PLW1641
             else []
         )
 
-    def _db_col_type(self, signals_schema: "SignalSchema") -> Optional["DataType"]:
+    def _db_col_type(self, signals_schema: "SignalSchema") -> "DataType | None":
         if not self._db_cols:
             return None
 
@@ -125,51 +128,51 @@ class Func(Function):  # noqa: PLW1641
 
         return list[col_type] if self.is_array else col_type  # type: ignore[valid-type]
 
-    def __add__(self, other: Union[ColT, float]) -> "Func":
+    def __add__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func("add", lambda a: a + other, [self])
         return Func("add", lambda a1, a2: a1 + a2, [self, other])
 
-    def __radd__(self, other: Union[ColT, float]) -> "Func":
+    def __radd__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func("add", lambda a: other + a, [self])
         return Func("add", lambda a1, a2: a1 + a2, [other, self])
 
-    def __sub__(self, other: Union[ColT, float]) -> "Func":
+    def __sub__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func("sub", lambda a: a - other, [self])
         return Func("sub", lambda a1, a2: a1 - a2, [self, other])
 
-    def __rsub__(self, other: Union[ColT, float]) -> "Func":
+    def __rsub__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func("sub", lambda a: other - a, [self])
         return Func("sub", lambda a1, a2: a1 - a2, [other, self])
 
-    def __mul__(self, other: Union[ColT, float]) -> "Func":
+    def __mul__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func("mul", lambda a: a * other, [self])
         return Func("mul", lambda a1, a2: a1 * a2, [self, other])
 
-    def __rmul__(self, other: Union[ColT, float]) -> "Func":
+    def __rmul__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func("mul", lambda a: other * a, [self])
         return Func("mul", lambda a1, a2: a1 * a2, [other, self])
 
-    def __truediv__(self, other: Union[ColT, float]) -> "Func":
+    def __truediv__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func("div", lambda a: _truediv(a, other), [self], result_type=float)
         return Func(
             "div", lambda a1, a2: _truediv(a1, a2), [self, other], result_type=float
         )
 
-    def __rtruediv__(self, other: Union[ColT, float]) -> "Func":
+    def __rtruediv__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func("div", lambda a: _truediv(other, a), [self], result_type=float)
         return Func(
             "div", lambda a1, a2: _truediv(a1, a2), [other, self], result_type=float
         )
 
-    def __floordiv__(self, other: Union[ColT, float]) -> "Func":
+    def __floordiv__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func(
                 "floordiv", lambda a: _floordiv(a, other), [self], result_type=int
@@ -178,7 +181,7 @@ class Func(Function):  # noqa: PLW1641
             "floordiv", lambda a1, a2: _floordiv(a1, a2), [self, other], result_type=int
         )
 
-    def __rfloordiv__(self, other: Union[ColT, float]) -> "Func":
+    def __rfloordiv__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func(
                 "floordiv", lambda a: _floordiv(other, a), [self], result_type=int
@@ -187,17 +190,17 @@ class Func(Function):  # noqa: PLW1641
             "floordiv", lambda a1, a2: _floordiv(a1, a2), [other, self], result_type=int
         )
 
-    def __mod__(self, other: Union[ColT, float]) -> "Func":
+    def __mod__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func("mod", lambda a: a % other, [self], result_type=int)
         return Func("mod", lambda a1, a2: a1 % a2, [self, other], result_type=int)
 
-    def __rmod__(self, other: Union[ColT, float]) -> "Func":
+    def __rmod__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func("mod", lambda a: other % a, [self], result_type=int)
         return Func("mod", lambda a1, a2: a1 % a2, [other, self], result_type=int)
 
-    def __and__(self, other: Union[ColT, float]) -> "Func":
+    def __and__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func(
                 "and", lambda a: numeric.bit_and(a, other), [self], result_type=int
@@ -209,7 +212,7 @@ class Func(Function):  # noqa: PLW1641
             result_type=int,
         )
 
-    def __rand__(self, other: Union[ColT, float]) -> "Func":
+    def __rand__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func(
                 "and", lambda a: numeric.bit_and(other, a), [self], result_type=int
@@ -221,7 +224,7 @@ class Func(Function):  # noqa: PLW1641
             result_type=int,
         )
 
-    def __or__(self, other: Union[ColT, float]) -> "Func":
+    def __or__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func(
                 "or", lambda a: numeric.bit_or(a, other), [self], result_type=int
@@ -230,7 +233,7 @@ class Func(Function):  # noqa: PLW1641
             "or", lambda a1, a2: numeric.bit_or(a1, a2), [self, other], result_type=int
         )
 
-    def __ror__(self, other: Union[ColT, float]) -> "Func":
+    def __ror__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func(
                 "or", lambda a: numeric.bit_or(other, a), [self], result_type=int
@@ -239,7 +242,7 @@ class Func(Function):  # noqa: PLW1641
             "or", lambda a1, a2: numeric.bit_or(a1, a2), [other, self], result_type=int
         )
 
-    def __xor__(self, other: Union[ColT, float]) -> "Func":
+    def __xor__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func(
                 "xor", lambda a: numeric.bit_xor(a, other), [self], result_type=int
@@ -251,7 +254,7 @@ class Func(Function):  # noqa: PLW1641
             result_type=int,
         )
 
-    def __rxor__(self, other: Union[ColT, float]) -> "Func":
+    def __rxor__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func(
                 "xor", lambda a: numeric.bit_xor(other, a), [self], result_type=int
@@ -263,7 +266,7 @@ class Func(Function):  # noqa: PLW1641
             result_type=int,
         )
 
-    def __rshift__(self, other: Union[ColT, float]) -> "Func":
+    def __rshift__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func(
                 "rshift",
@@ -278,7 +281,7 @@ class Func(Function):  # noqa: PLW1641
             result_type=int,
         )
 
-    def __rrshift__(self, other: Union[ColT, float]) -> "Func":
+    def __rrshift__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func(
                 "rshift",
@@ -293,7 +296,7 @@ class Func(Function):  # noqa: PLW1641
             result_type=int,
         )
 
-    def __lshift__(self, other: Union[ColT, float]) -> "Func":
+    def __lshift__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func(
                 "lshift",
@@ -308,7 +311,7 @@ class Func(Function):  # noqa: PLW1641
             result_type=int,
         )
 
-    def __rlshift__(self, other: Union[ColT, float]) -> "Func":
+    def __rlshift__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func(
                 "lshift",
@@ -323,12 +326,12 @@ class Func(Function):  # noqa: PLW1641
             result_type=int,
         )
 
-    def __lt__(self, other: Union[ColT, float]) -> "Func":
+    def __lt__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func("lt", lambda a: a < other, [self], result_type=bool)
         return Func("lt", lambda a1, a2: a1 < a2, [self, other], result_type=bool)
 
-    def __le__(self, other: Union[ColT, float]) -> "Func":
+    def __le__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func("le", lambda a: a <= other, [self], result_type=bool)
         return Func("le", lambda a1, a2: a1 <= a2, [self, other], result_type=bool)
@@ -343,12 +346,12 @@ class Func(Function):  # noqa: PLW1641
             return Func("ne", lambda a: a != other, [self], result_type=bool)
         return Func("ne", lambda a1, a2: a1 != a2, [self, other], result_type=bool)
 
-    def __gt__(self, other: Union[ColT, float]) -> "Func":
+    def __gt__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func("gt", lambda a: a > other, [self], result_type=bool)
         return Func("gt", lambda a1, a2: a1 > a2, [self, other], result_type=bool)
 
-    def __ge__(self, other: Union[ColT, float]) -> "Func":
+    def __ge__(self, other: ColT | float) -> "Func":
         if isinstance(other, (int, float)):
             return Func("ge", lambda a: a >= other, [self], result_type=bool)
         return Func("ge", lambda a1, a2: a1 >= a2, [self, other], result_type=bool)
@@ -369,7 +372,7 @@ class Func(Function):  # noqa: PLW1641
             label,
         )
 
-    def get_col_name(self, label: Optional[str] = None) -> str:
+    def get_col_name(self, label: str | None = None) -> str:
         if label:
             return label
         if self.col_label:
@@ -384,7 +387,7 @@ class Func(Function):  # noqa: PLW1641
         return self.name
 
     def get_result_type(
-        self, signals_schema: Optional["SignalSchema"] = None
+        self, signals_schema: "SignalSchema | None" = None
     ) -> "DataType":
         if self.result_type:
             return self.result_type
@@ -408,9 +411,9 @@ class Func(Function):  # noqa: PLW1641
 
     def get_column(
         self,
-        signals_schema: Optional["SignalSchema"] = None,
-        label: Optional[str] = None,
-        table: Optional["TableClause"] = None,
+        signals_schema: "SignalSchema | None" = None,
+        label: str | None = None,
+        table: "TableClause | None" = None,
     ) -> Column:
         col_type = self.get_result_type(signals_schema)
         sql_type = python_to_sql(col_type)