graphique 1.3__tar.gz → 1.5__tar.gz

{graphique-1.3 → graphique-1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: graphique
-Version: 1.3
+Version: 1.5
 Summary: GraphQL service for arrow tables and parquet data sets.
 Author-email: Aric Coady <aric.coady@gmail.com>
 License: Copyright 2022 Aric Coady
@@ -28,20 +28,24 @@ Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Database :: Database Engines/Servers
 Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
 Classifier: Topic :: Internet :: WWW/HTTP :: Indexing/Search
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: pyarrow>=15
+Requires-Dist: strawberry-graphql[asgi,cli]>=0.198
 Provides-Extra: server
+Requires-Dist: uvicorn[standard]; extra == "server"
 Provides-Extra: cli
-License-File: LICENSE.txt
+Requires-Dist: tqdm; extra == "cli"
 
 [![image](https://img.shields.io/pypi/v/graphique.svg)](https://pypi.org/project/graphique/)
 ![image](https://img.shields.io/pypi/pyversions/graphique.svg)
@@ -50,8 +54,8 @@ License-File: LICENSE.txt
 [![image](https://github.com/coady/graphique/workflows/build/badge.svg)](https://github.com/coady/graphique/actions)
 [![image](https://codecov.io/gh/coady/graphique/branch/main/graph/badge.svg)](https://codecov.io/gh/coady/graphique/)
 [![image](https://github.com/coady/graphique/workflows/codeql/badge.svg)](https://github.com/coady/graphique/security/code-scanning)
-[![image](https://img.shields.io/badge/code%20style-black-000000.svg)](https://pypi.org/project/black/)
-[![image](http://mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
+[![image](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![image](https://mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
 
 [GraphQL](https://graphql.org) service for [arrow](https://arrow.apache.org) tables and [parquet](https://parquet.apache.org) data sets. The schema for a query API is derived automatically.
 
@@ -140,7 +144,7 @@ If index columns are detected in the schema metadata, then an initial `filter` w
 ```
 
 ## Dependencies
-* pyarrow >=13
+* pyarrow
 * strawberry-graphql[asgi,cli]
 * uvicorn (or other [ASGI server](https://asgi.readthedocs.io/en/latest/implementations.html))
 

{graphique-1.3 → graphique-1.5}/README.md

@@ -5,8 +5,8 @@
 [![image](https://github.com/coady/graphique/workflows/build/badge.svg)](https://github.com/coady/graphique/actions)
 [![image](https://codecov.io/gh/coady/graphique/branch/main/graph/badge.svg)](https://codecov.io/gh/coady/graphique/)
 [![image](https://github.com/coady/graphique/workflows/codeql/badge.svg)](https://github.com/coady/graphique/security/code-scanning)
-[![image](https://img.shields.io/badge/code%20style-black-000000.svg)](https://pypi.org/project/black/)
-[![image](http://mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
+[![image](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![image](https://mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
 
 [GraphQL](https://graphql.org) service for [arrow](https://arrow.apache.org) tables and [parquet](https://parquet.apache.org) data sets. The schema for a query API is derived automatically.
 
@@ -95,7 +95,7 @@ If index columns are detected in the schema metadata, then an initial `filter` w
 ```
 
 ## Dependencies
-* pyarrow >=13
+* pyarrow
 * strawberry-graphql[asgi,cli]
 * uvicorn (or other [ASGI server](https://asgi.readthedocs.io/en/latest/implementations.html))
 

{graphique-1.3 → graphique-1.5}/graphique/__init__.py

@@ -1,3 +1,3 @@
 from .middleware import GraphQL  # noqa: F401
 
-__version__ = '1.3'
+__version__ = '1.5'

{graphique-1.3 → graphique-1.5}/graphique/core.py

@@ -4,6 +4,7 @@ Core utilities that add pandas-esque features to arrow arrays and tables.
 Arrow forbids subclassing, so the classes are for logical grouping.
 Their methods are called as functions.
 """
+
 import bisect
 import contextlib
 import functools
@@ -11,12 +12,15 @@ import inspect
 import itertools
 import operator
 import json
+from collections.abc import Callable, Iterable, Iterator, Sequence
 from dataclasses import dataclass
-from typing import Callable, Iterable, Iterator, Optional, Sequence, Union, get_type_hints
+from typing import Optional, Union, get_type_hints
 import numpy as np  # type: ignore
 import pyarrow as pa
+import pyarrow.acero as ac
 import pyarrow.compute as pc
 import pyarrow.dataset as ds
+from typing_extensions import Self
 
 Array = Union[pa.Array, pa.ChunkedArray]
 Batch = Union[pa.RecordBatch, pa.Table]
@@ -49,7 +53,7 @@ class Agg:
     }
 
     associatives = {'all', 'any', 'first', 'last', 'max', 'min', 'one', 'product', 'sum'}
-    associatives |= {'count', 'distinct', 'list'}  # transformed to be associative
+    associatives |= {'count'}  # transformed to be associative
 
     def __init__(self, name: str, alias: str = '', **options):
         self.name = name
@@ -57,11 +61,10 @@ class Agg:
         self.options = options
 
     def astuple(self, func: str) -> tuple:
-        options = self.option_map[func](**self.options)
-        return self.name, func, options
+        options = self.option_map[func.rpartition('hash_')[-1]](**self.options)
+        return self.name, func, options, self.alias
 
-    first = one = operator.itemgetter(0)
-    last = operator.itemgetter(-1)
+    one = operator.itemgetter(0)
     list = staticmethod(lambda array: array)
 
     @staticmethod
@@ -91,25 +94,23 @@ def sort_key(name: str) -> tuple:
     return name.lstrip('-'), ('descending' if name.startswith('-') else 'ascending')
 
 
-def decode(array: pa.Array) -> pa.Array:
-    """Decode dictionary array."""
-    return array.dictionary_decode() if isinstance(array, pa.DictionaryArray) else array
-
-
-def register(func: Callable) -> pc.Function:
-    """Register user defined scalar function."""
+def register(func: Callable, kind: str = 'scalar') -> pc.Function:
+    """Register user defined function by kind."""
     doc = inspect.getdoc(func)
     doc = {'summary': doc.splitlines()[0], 'description': doc}  # type: ignore
     annotations = dict(get_type_hints(func))
     result = annotations.pop('return')
     with contextlib.suppress(pa.ArrowKeyError):  # apache/arrow#{31611,31612}
-        pc.register_scalar_function(func, func.__name__, doc, annotations, result)
+        getattr(pc, f'register_{kind}_function')(func, func.__name__, doc, annotations, result)
     return pc.get_function(func.__name__)
 
 
 @register
 def digitize(
-    ctx, array: pa.float64(), bins: pa.list_(pa.float64()), right: pa.bool_()  # type: ignore
+    ctx,
+    array: pa.float64(),  # type: ignore
+    bins: pa.list_(pa.float64()),  # type: ignore
+    right: pa.bool_(),  # type: ignore
 ) -> pa.int64():  # type: ignore
     """Return the indices of the bins to which each value in input array belongs."""
     return pa.array(np.digitize(array, bins.values, right.as_py()))
@@ -283,6 +284,13 @@ class Column(pa.ChunkedArray):
         mask = predicate(Column.diff(self), *args) if args else Column.diff(self, predicate)
         return pc.indices_nonzero(pa.chunked_array(ends + mask.chunks + ends))
 
+    def first_last(self, **options):
+        if not pa.types.is_dictionary(self.type):
+            return pc.first_last(self, **options).as_py()
+        self = self.combine_chunks()
+        indices = pc.first_last(self.indices, **options).as_py().items()
+        return {key: None if index is None else self.dictionary[index] for key, index in indices}
+
     def min_max(self, **options):
         if pa.types.is_dictionary(self.type):
             self = self.unique().dictionary_decode()
@@ -343,7 +351,7 @@ class Table(pa.Table):
         """Return table with union of columns."""
         columns: dict = {}
         for table in tables:
-            columns.update(Table.columns(table))
+            columns |= Table.columns(table)
         return type(tables[0]).from_pydict(columns)
 
     def range(self, name: str, lower=None, upper=None, **includes) -> pa.Table:
@@ -403,70 +411,31 @@ class Table(pa.Table):
         table = Table.union(scalars, Table.from_offsets(lists, offsets))
         return table, Column.diff(offsets)
 
-    def group(
-        self,
-        *names: str,
-        counts: str = '',
-        first: Sequence[Agg] = (),
-        last: Sequence[Agg] = (),
-        **funcs: Sequence[Agg],
-    ) -> Union[pa.Table, pa.RecordBatch]:
+    def group(self, *names: str, counts: str = '', **funcs: Sequence[Agg]) -> pa.Table:
         """Group by and aggregate.
 
         Args:
             *names: columns to group by
             counts: alias for optional row counts
-            first: columns to take first value
-            last: columns to take last value
             **funcs: aggregate funcs with columns options
         """
         if isinstance(self, pa.Table):
             self = self.unify_dictionaries()
-        columns = Table.columns(self)
-        aliases, args = {}, []  # type: ignore
+        prefix = 'hash_' if names else ''
+        aggs = [agg.astuple(prefix + func) for func in funcs for agg in funcs[func]]
         if counts:
-            aliases['count_all'] = counts
-            args.append(([], 'count_all'))
-        if first or last:
-            columns[''] = np.arange(len(self))
-            args.append(('', 'min_max'))
-        lists: Sequence[Agg] = []
-        list_cols = [self[agg.name] for agg in funcs.get('list', [])]
-        if any(pa.types.is_dictionary(col.type) or Column.is_list_type(col) for col in list_cols):
-            columns[''] = np.arange(len(self))
-            args.append(('', 'list'))
-            lists = funcs.pop('list')
-        for func, aggs in funcs.items():
-            aliases.update({f'{agg.name}_{func}': agg.alias for agg in aggs})
-            args += (agg.astuple(func) for agg in aggs)  # type: ignore
-        table = pa.table(columns).group_by(list(names)).aggregate(args)
-        columns = {name: table[name].combine_chunks() for name in table.schema.names}
-        if first or last:
-            for aggs, indices in zip([first, last], columns.pop('_min_max').flatten()):
-                columns.update({agg.alias: self[agg.name].take(indices) for agg in aggs})
-        if lists:
-            indices = columns.pop('_list')
-            table = self.select({agg.name for agg in lists}).take(indices.values)
-            table = Table.from_offsets(table, indices.offsets)
-            columns.update({agg.alias: table[agg.name] for agg in lists})
-        columns.update({name: decode(columns[name]) for name in names})
-        columns = {aliases.get(name, name): columns[name] for name in columns}
-        return type(self).from_pydict(columns)
+            aggs.append(([], 'hash_count_all', None, counts))
+        return Declarations(self).aggregate(aggs, names).to_table()
 
     def aggregate(self, counts: str = '', **funcs: Sequence[Agg]) -> dict:
         """Return aggregated scalars as a row of data."""
         row = {counts: len(self)} if counts else {}
-        aliases, args = {}, []  # type: ignore
-        for key in funcs:
-            if hasattr(pc, key) and key not in ('first', 'last'):
-                aliases.update({f'{agg.name}_{key}': agg.alias for agg in funcs[key]})
-                args += (agg.astuple(key) for agg in funcs[key])
-            else:
-                func = getattr(Agg, key)
-                row.update({agg.alias: func(self[agg.name], **agg.options) for agg in funcs[key]})
-        if args:
-            table = self.group_by([]).aggregate(args)
-            row.update({aliases[name]: table[name][0] for name in table.schema.names})
+        for key in ('one', 'list', 'distinct'):  # hash only functions
+            func, aggs = getattr(Agg, key), funcs.pop(key, [])
+            row |= {agg.alias: func(self[agg.name], **agg.options) for agg in aggs}
+        if funcs:
+            table = Table.group(self, **funcs)  # type: ignore
+            row |= {name: table[name][0] for name in table.schema.names}
         for name, value in row.items():
             if isinstance(value, pa.ChunkedArray):
                 row[name] = value.combine_chunks()
@@ -649,7 +618,7 @@ class Table(pa.Table):
                 yield None
             else:
                 row = {name: pa.repeat(self[name][index], count) for name in scalars}
-                row.update({name: self[name][index].values for name in lists})
+                row |= {name: self[name][index].values for name in lists}
                 yield pa.RecordBatch.from_pydict(row)
 
     def size(self) -> str:
@@ -658,3 +627,36 @@ class Table(pa.Table):
         for prefix in itertools.takewhile(lambda _: size >= 1e3, 'kMGT'):
             size /= 1e3
         return f'{size:n} {prefix}B'
+
+
+class Declarations(list):
+    """[Acero](https://arrow.apache.org/docs/python/api/acero.html) engine declarations."""
+
+    option_map = {
+        'table_source': ac.TableSourceNodeOptions,
+        'scan': ac.ScanNodeOptions,
+        'filter': ac.FilterNodeOptions,
+        'project': ac.ProjectNodeOptions,
+        'aggregate': ac.AggregateNodeOptions,
+        'order_by': ac.OrderByNodeOptions,
+        'hashjoin': ac.HashJoinNodeOptions,
+    }
+
+    def __init__(self, source: Union[pa.Table, ds.Dataset]):
+        if isinstance(source, ds.Dataset):
+            expr = source._scan_options.get('filter')
+            self.scan(source, filter=expr)
+            if expr is not None:
+                self.filter(expr)
+        else:
+            self.table_source(source)
+
+    def apply(self, name: str, *args, **kwargs) -> Self:
+        self.append(ac.Declaration(name, self.option_map[name](*args, **kwargs)))
+        return self
+
+    def __getattr__(self, name: str) -> Callable:
+        return functools.partial(self.apply, name)
+
+    def to_table(self, use_threads: bool = False) -> pa.Table:
+        return ac.Declaration.from_sequence(self).to_table(use_threads)

{graphique-1.3 → graphique-1.5}/graphique/inputs.py

@@ -1,12 +1,14 @@
 """
 GraphQL input types.
 """
+
 import functools
 import inspect
 import operator
+from collections.abc import Callable, Iterable
 from datetime import date, datetime, time, timedelta
 from decimal import Decimal
-from typing import Callable, Generic, Iterable, List, Optional, TypeVar, no_type_check
+from typing import Generic, Optional, TypeVar, no_type_check
 import pyarrow as pa
 import pyarrow.compute as pc
 import pyarrow.dataset as ds
@@ -18,7 +20,7 @@ from strawberry.schema_directive import Location
 from strawberry.field import StrawberryField
 from strawberry.scalars import JSON
 from typing_extensions import Self
-from .core import Agg, ListChunk
+from .core import Agg
 from .scalars import Long
 
 T = TypeVar('T')
@@ -81,7 +83,7 @@ def default_field(
 
 @strawberry.input(description="predicates for scalars")
 class Filter(Generic[T], Input):
-    eq: Optional[List[Optional[T]]] = default_field(
+    eq: Optional[list[Optional[T]]] = default_field(
         description="== or `isin`; `null` is equivalent to arrow `is_null`.", nullable=True
     )
     ne: Optional[T] = default_field(
@@ -143,7 +145,7 @@ class Mode(Field):
 
 @strawberry.input
 class Quantile(Field):
-    q: List[float] = (0.5,)  # type: ignore
+    q: list[float] = (0.5,)  # type: ignore
     interpolation: str = 'linear'
     skip_nulls: bool = True
     min_count: int = 1
@@ -158,13 +160,13 @@ class Rank(Field):
 
 @strawberry.input
 class Sort:
-    by: List[str]
+    by: list[str]
     length: Optional[Long] = None
 
 
 @strawberry.input
 class Ranked:
-    by: List[str]
+    by: list[str]
     max: int = 1
 
 
@@ -200,41 +202,45 @@ class VarianceAggregate(ScalarAggregate):
 
 @strawberry.input(description=f"options for tdigest [aggregation]({links.compute}#aggregations)")
 class TDigestAggregate(ScalarAggregate):
-    q: List[float] = (0.5,)  # type: ignore
+    q: list[float] = (0.5,)  # type: ignore
     delta: int = 100
     buffer_size: int = 500
 
 
 @strawberry.input
 class ScalarAggregates(Input):
-    all: List[ScalarAggregate] = default_field([], func=pc.all)
-    any: List[ScalarAggregate] = default_field([], func=pc.any)
-    approximate_median: List[ScalarAggregate] = default_field([], func=pc.approximate_median)
-    count: List[CountAggregate] = default_field([], func=pc.count)
-    count_distinct: List[CountAggregate] = default_field([], func=pc.count_distinct)
-    max: List[ScalarAggregate] = default_field([], func=pc.max)
-    mean: List[ScalarAggregate] = default_field([], func=pc.mean)
-    min: List[ScalarAggregate] = default_field([], func=pc.min)
-    min_max: List[ScalarAggregate] = default_field([], func=pc.min_max)
-    product: List[ScalarAggregate] = default_field([], func=pc.product)
-    stddev: List[VarianceAggregate] = default_field([], func=pc.stddev)
-    sum: List[ScalarAggregate] = default_field([], func=pc.sum)
-    tdigest: List[TDigestAggregate] = default_field([], func=pc.tdigest)
-    variance: List[VarianceAggregate] = default_field([], func=pc.variance)
+    all: list[ScalarAggregate] = default_field([], func=pc.all)
+    any: list[ScalarAggregate] = default_field([], func=pc.any)
+    approximate_median: list[ScalarAggregate] = default_field([], func=pc.approximate_median)
+    count: list[CountAggregate] = default_field([], func=pc.count)
+    count_distinct: list[CountAggregate] = default_field([], func=pc.count_distinct)
+    first: list[ScalarAggregate] = default_field([], func=pc.first)
+    first_last: list[ScalarAggregate] = default_field([], func=pc.first_last)
+    last: list[ScalarAggregate] = default_field([], func=pc.last)
+    max: list[ScalarAggregate] = default_field([], func=pc.max)
+    mean: list[ScalarAggregate] = default_field([], func=pc.mean)
+    min: list[ScalarAggregate] = default_field([], func=pc.min)
+    min_max: list[ScalarAggregate] = default_field([], func=pc.min_max)
+    product: list[ScalarAggregate] = default_field([], func=pc.product)
+    stddev: list[VarianceAggregate] = default_field([], func=pc.stddev)
+    sum: list[ScalarAggregate] = default_field([], func=pc.sum)
+    tdigest: list[TDigestAggregate] = default_field([], func=pc.tdigest)
+    variance: list[VarianceAggregate] = default_field([], func=pc.variance)
 
     def keys(self):
-        return (key for key in super().keys() if self[key])
+        return (key.rstrip('_') for key in super().keys() if self[key])
+
+    def __getitem__(self, name):
+        return super().__getitem__('list_' if name == 'list' else name)
 
 
 @strawberry.input
 class HashAggregates(ScalarAggregates):
-    distinct: List[CountAggregate] = default_field(
+    distinct: list[CountAggregate] = default_field(
         [], description="distinct values within each scalar"
     )
-    first: List[Field] = default_field([], func=ListChunk.first)
-    last: List[Field] = default_field([], func=ListChunk.last)
-    list: List[Field] = default_field([], description="all values within each scalar")
-    one: List[Field] = default_field([], description="arbitrary value within each scalar")
+    list_: list[Field] = default_field([], name='list', description="all values within each scalar")
+    one: list[Field] = default_field([], description="arbitrary value within each scalar")
 
 
 @use_doc(strawberry.input)
@@ -266,7 +272,7 @@ class Expression:
     * `ne` with a `null` scalar is equivalent to `is_valid`
     """
 
-    name: List[str] = default_field([], description="field name(s)")
+    name: list[str] = default_field([], description="field name(s)")
     cast: str = strawberry.field(default='', description=f"cast as {links.type}")
     safe: bool = strawberry.field(default=True, description="check for conversion errors on cast")
     value: Optional[JSON] = default_field(
@@ -275,29 +281,29 @@ class Expression:
     kleene: bool = strawberry.field(default=False, description="use kleene logic for booleans")
     checked: bool = strawberry.field(default=False, description="check for overflow errors")
 
-    base64: List[bytes] = default_field([])
-    date_: List[date] = default_field([], name='date')
-    datetime_: List[datetime] = default_field([], name='datetime')
-    decimal: List[Decimal] = default_field([])
-    duration: List[timedelta] = default_field([])
-    time_: List[time] = default_field([], name='time')
-
-    eq: List['Expression'] = default_field([], description="==")
-    ne: List['Expression'] = default_field([], description="!=")
-    lt: List['Expression'] = default_field([], description="<")
-    le: List['Expression'] = default_field([], description="<=")
-    gt: List['Expression'] = default_field([], description=r"\>")
-    ge: List['Expression'] = default_field([], description=r"\>=")
+    base64: list[bytes] = default_field([])
+    date_: list[date] = default_field([], name='date')
+    datetime_: list[datetime] = default_field([], name='datetime')
+    decimal: list[Decimal] = default_field([])
+    duration: list[timedelta] = default_field([])
+    time_: list[time] = default_field([], name='time')
+
+    eq: list['Expression'] = default_field([], description="==")
+    ne: list['Expression'] = default_field([], description="!=")
+    lt: list['Expression'] = default_field([], description="<")
+    le: list['Expression'] = default_field([], description="<=")
+    gt: list['Expression'] = default_field([], description=r"\>")
+    ge: list['Expression'] = default_field([], description=r"\>=")
     inv: Optional['Expression'] = default_field(description="~")
 
     abs: Optional['Expression'] = default_field(func=pc.abs)
-    add: List['Expression'] = default_field([], func=pc.add)
-    divide: List['Expression'] = default_field([], func=pc.divide)
-    multiply: List['Expression'] = default_field([], func=pc.multiply)
+    add: list['Expression'] = default_field([], func=pc.add)
+    divide: list['Expression'] = default_field([], func=pc.divide)
+    multiply: list['Expression'] = default_field([], func=pc.multiply)
     negate: Optional['Expression'] = default_field(func=pc.negate)
-    power: List['Expression'] = default_field([], func=pc.power)
+    power: list['Expression'] = default_field([], func=pc.power)
     sign: Optional['Expression'] = default_field(func=pc.sign)
-    subtract: List['Expression'] = default_field([], func=pc.subtract)
+    subtract: list['Expression'] = default_field([], func=pc.subtract)
 
     bit_wise: Optional['BitWise'] = default_field(description="bit-wise functions")
     rounding: Optional['Rounding'] = default_field(description="rounding functions")
@@ -307,10 +313,10 @@ class Expression:
         description="element-wise aggregate functions"
     )
 
-    and_: List['Expression'] = default_field([], name='and', description="&")
-    and_not: List['Expression'] = default_field([], func=pc.and_not)
-    or_: List['Expression'] = default_field([], name='or', description="|")
-    xor: List['Expression'] = default_field([], func=pc.xor)
+    and_: list['Expression'] = default_field([], name='and', description="&")
+    and_not: list['Expression'] = default_field([], func=pc.and_not)
+    or_: list['Expression'] = default_field([], name='or', description="|")
+    xor: list['Expression'] = default_field([], func=pc.xor)
 
     utf8: Optional['Utf8'] = default_field(description="utf8 string functions")
     string_is_ascii: Optional['Expression'] = default_field(func=pc.string_is_ascii)
@@ -324,14 +330,14 @@ class Expression:
     is_nan: Optional['Expression'] = default_field(func=pc.is_nan)
     true_unless_null: Optional['Expression'] = default_field(func=pc.true_unless_null)
 
-    case_when: List['Expression'] = default_field([], func=pc.case_when)
-    choose: List['Expression'] = default_field([], func=pc.choose)
-    coalesce: List['Expression'] = default_field([], func=pc.coalesce)
-    if_else: List['Expression'] = default_field([], func=pc.if_else)
+    case_when: list['Expression'] = default_field([], func=pc.case_when)
+    choose: list['Expression'] = default_field([], func=pc.choose)
+    coalesce: list['Expression'] = default_field([], func=pc.coalesce)
+    if_else: list['Expression'] = default_field([], func=pc.if_else)
 
     temporal: Optional['Temporal'] = default_field(description="temporal functions")
 
-    replace_with_mask: List['Expression'] = default_field([], func=pc.replace_with_mask)
+    replace_with_mask: list['Expression'] = default_field([], func=pc.replace_with_mask)
 
     list: Optional['Lists'] = default_field(description="list array functions")
 
@@ -438,12 +444,12 @@ class Fields:
 
 @strawberry.input(description="Bit-wise functions.")
 class BitWise(Fields):
-    and_: List[Expression] = default_field([], name='and', func=pc.bit_wise_and)
-    not_: List[Expression] = default_field([], name='not', func=pc.bit_wise_not)
-    or_: List[Expression] = default_field([], name='or', func=pc.bit_wise_or)
-    xor: List[Expression] = default_field([], func=pc.bit_wise_xor)
-    shift_left: List[Expression] = default_field([], func=pc.shift_left)
-    shift_right: List[Expression] = default_field([], func=pc.shift_right)
+    and_: list[Expression] = default_field([], name='and', func=pc.bit_wise_and)
+    not_: list[Expression] = default_field([], name='not', func=pc.bit_wise_not)
+    or_: list[Expression] = default_field([], name='or', func=pc.bit_wise_or)
+    xor: list[Expression] = default_field([], func=pc.bit_wise_xor)
+    shift_left: list[Expression] = default_field([], func=pc.shift_left)
+    shift_right: list[Expression] = default_field([], func=pc.shift_right)
 
     def getfunc(self, name):
         return getattr(pc, name if name.startswith('shift') else 'bit_wise_' + name.rstrip('_'))
@@ -470,7 +476,7 @@ class Rounding(Fields):
 class Log(Fields):
     ln: Optional[Expression] = default_field(func=pc.ln)
     log1p: Optional[Expression] = default_field(func=pc.log1p)
-    logb: List[Expression] = default_field([], func=pc.logb)
+    logb: list[Expression] = default_field([], func=pc.logb)
 
 
 @strawberry.input(description="Trigonometry functions.")
@@ -480,7 +486,7 @@ class Trig(Fields):
     acos: Optional[Expression] = default_field(func=pc.acos)
     asin: Optional[Expression] = default_field(func=pc.asin)
     atan: Optional[Expression] = default_field(func=pc.atan)
-    atan2: List[Expression] = default_field([], func=pc.atan2)
+    atan2: list[Expression] = default_field([], func=pc.atan2)
     cos: Optional[Expression] = default_field(func=pc.cos)
     sin: Optional[Expression] = default_field(func=pc.sin)
     tan: Optional[Expression] = default_field(func=pc.tan)
@@ -491,8 +497,8 @@ class Trig(Fields):
 
 @strawberry.input(description="Element-wise aggregate functions.")
 class ElementWise(Fields):
-    min_element_wise: List[Expression] = default_field([], name='min', func=pc.min_element_wise)
-    max_element_wise: List[Expression] = default_field([], name='max', func=pc.max_element_wise)
+    min_element_wise: list[Expression] = default_field([], name='min', func=pc.min_element_wise)
+    max_element_wise: list[Expression] = default_field([], name='max', func=pc.max_element_wise)
     skip_nulls: bool = True
 
 
@@ -544,11 +550,11 @@ class Utf8(Fields):
 @strawberry.input(description="Binary functions.")
 class Binary(Fields):
     length: Optional[Expression] = default_field(func=pc.binary_length)
-    repeat: List[Expression] = default_field([], func=pc.binary_repeat)
+    repeat: list[Expression] = default_field([], func=pc.binary_repeat)
     reverse: Optional[Expression] = default_field(func=pc.binary_reverse)
 
-    join: List[Expression] = default_field([], func=pc.binary_join)
-    join_element_wise: List[Expression] = default_field([], func=pc.binary_join_element_wise)
+    join: list[Expression] = default_field([], func=pc.binary_join)
+    join_element_wise: list[Expression] = default_field([], func=pc.binary_join_element_wise)
     null_handling: str = 'emit_null'
     null_replacement: str = ''
 
@@ -609,23 +615,23 @@ class Temporal(Fields):
     year: Optional[Expression] = default_field(func=pc.year)
     year_month_day: Optional[Expression] = default_field(func=pc.year_month_day)
 
-    day_time_interval_between: List[Expression] = default_field(
+    day_time_interval_between: list[Expression] = default_field(
         [], func=pc.day_time_interval_between
     )
-    days_between: List[Expression] = default_field([], func=pc.days_between)
-    hours_between: List[Expression] = default_field([], func=pc.hours_between)
-    microseconds_between: List[Expression] = default_field([], func=pc.microseconds_between)
-    milliseconds_between: List[Expression] = default_field([], func=pc.milliseconds_between)
-    minutes_between: List[Expression] = default_field([], func=pc.minutes_between)
-    month_day_nano_interval_between: List[Expression] = default_field(
+    days_between: list[Expression] = default_field([], func=pc.days_between)
+    hours_between: list[Expression] = default_field([], func=pc.hours_between)
+    microseconds_between: list[Expression] = default_field([], func=pc.microseconds_between)
+    milliseconds_between: list[Expression] = default_field([], func=pc.milliseconds_between)
+    minutes_between: list[Expression] = default_field([], func=pc.minutes_between)
+    month_day_nano_interval_between: list[Expression] = default_field(
         [], func=pc.month_day_nano_interval_between
     )
-    month_interval_between: List[Expression] = default_field([], func=pc.month_interval_between)
-    nanoseconds_between: List[Expression] = default_field([], func=pc.nanoseconds_between)
-    quarters_between: List[Expression] = default_field([], func=pc.quarters_between)
-    seconds_between: List[Expression] = default_field([], func=pc.seconds_between)
-    weeks_between: List[Expression] = default_field([], func=pc.weeks_between)
-    years_between: List[Expression] = default_field([], func=pc.years_between)
+    month_interval_between: list[Expression] = default_field([], func=pc.month_interval_between)
+    nanoseconds_between: list[Expression] = default_field([], func=pc.nanoseconds_between)
+    quarters_between: list[Expression] = default_field([], func=pc.quarters_between)
+    seconds_between: list[Expression] = default_field([], func=pc.seconds_between)
+    weeks_between: list[Expression] = default_field([], func=pc.weeks_between)
+    years_between: list[Expression] = default_field([], func=pc.years_between)
 
     ceil_temporal: Optional[Expression] = default_field(name='ceil', func=pc.ceil_temporal)
     floor_temporal: Optional[Expression] = default_field(name='floor', func=pc.floor_temporal)
@@ -657,8 +663,8 @@ class Temporal(Fields):
 
 @strawberry.input(description="Set lookup functions.")
 class SetLookup(Fields):
-    index_in: List[Expression] = default_field([], func=pc.index_in)
-    digitize: List[Expression] = default_field(
+    index_in: list[Expression] = default_field([], func=pc.index_in)
+    digitize: list[Expression] = default_field(
         [],
         description="numpy [digitize](https://numpy.org/doc/stable/reference/generated/numpy.digitize.html)",
     )
@@ -677,7 +683,7 @@ class SetLookup(Fields):
 
 @strawberry.input(description="List array functions.")
 class Lists(Fields):
-    element: List[Expression] = default_field([], func=pc.list_element)
+    element: list[Expression] = default_field([], func=pc.list_element)
     value_length: Optional[Expression] = default_field(func=pc.list_value_length)
     # user defined functions
     all: Optional[Expression] = default_field(func=pc.all)