graphique 1.8__tar.gz → 1.9__tar.gz

{graphique-1.8 → graphique-1.9}/PKG-INFO

@@ -1,22 +1,9 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: graphique
-Version: 1.8
+Version: 1.9
 Summary: GraphQL service for arrow tables and parquet data sets.
 Author-email: Aric Coady <aric.coady@gmail.com>
-License: Copyright 2022 Aric Coady
-        
-           Licensed under the Apache License, Version 2.0 (the "License");
-           you may not use this file except in compliance with the License.
-           You may obtain a copy of the License at
-        
-             http://www.apache.org/licenses/LICENSE-2.0
-        
-           Unless required by applicable law or agreed to in writing, software
-           distributed under the License is distributed on an "AS IS" BASIS,
-           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-           See the License for the specific language governing permissions and
-           limitations under the License.
-        
+License: Apache-2.0
 Project-URL: Homepage, https://github.com/coady/graphique
 Project-URL: Documentation, https://coady.github.io/graphique
 Project-URL: Changelog, https://github.com/coady/graphique/blob/main/CHANGELOG.md
@@ -25,10 +12,8 @@ Keywords: graphql,arrow,parquet
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 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.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -38,10 +23,10 @@ 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.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: pyarrow>=18
+Requires-Dist: pyarrow>=20
 Requires-Dist: strawberry-graphql[asgi,cli]>=0.236
 Requires-Dist: numpy
 Requires-Dist: isodate>=0.7
@@ -49,6 +34,7 @@ Provides-Extra: server
 Requires-Dist: uvicorn[standard]; extra == "server"
 Provides-Extra: cli
 Requires-Dist: tqdm; extra == "cli"
+Dynamic: license-file
 
 [![image](https://img.shields.io/pypi/v/graphique.svg)](https://pypi.org/project/graphique/)
 ![image](https://img.shields.io/pypi/pyversions/graphique.svg)

{graphique-1.8 → graphique-1.9}/graphique/core.py

@@ -14,7 +14,7 @@ import operator
 import json
 from collections.abc import Callable, Iterable, Iterator, Mapping
 from dataclasses import dataclass
-from typing import Optional, Union, get_type_hints
+from typing import TypeAlias, get_type_hints
 import numpy as np
 import pyarrow as pa
 import pyarrow.acero as ac
@@ -22,8 +22,8 @@ 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]
+Array: TypeAlias = pa.Array | pa.ChunkedArray
+Batch: TypeAlias = pa.RecordBatch | pa.Table
 bit_any = functools.partial(functools.reduce, operator.or_)
 bit_all = functools.partial(functools.reduce, operator.and_)
 
@@ -64,12 +64,11 @@ class Agg:
         return self.option_map[func.removeprefix('hash_')](**self.options)
 
 
-@dataclass(frozen=True)
+@dataclass(frozen=True, slots=True)
 class Compare:
     """Comparable wrapper for bisection search."""
 
     value: object
-    __slots__ = ('value',)  # slots keyword in Python >=3.10
 
     def __lt__(self, other):
         return self.value < other.as_py()
@@ -152,7 +151,7 @@ class ListChunk(pa.lib.BaseListArray):
         offsets = self.values.offsets.take(self.offsets)
         return type(self).from_arrays(offsets, self.values.values)
 
-    def aggregate(self, **funcs: Optional[pc.FunctionOptions]) -> pa.RecordBatch:
+    def aggregate(self, **funcs: pc.FunctionOptions | None) -> pa.RecordBatch:
         """Return aggregated scalars by grouping each hash function on the parent indices.
 
         If there are empty or null scalars, then the result must be padded with null defaults and
@@ -241,7 +240,7 @@ class Column(pa.ChunkedArray):
         if not pa.types.is_dictionary(self.type):
             return self
         array = self if isinstance(self, pa.Array) else self.combine_chunks()
-        return pc.rank(array.dictionary, 'ascending').take(array.indices)
+        return pc.rank(array.dictionary).take(array.indices)
 
     def pairwise_diff(self, period: int = 1) -> Array:
         """`pairwise_diff` with chunked array support."""
@@ -391,7 +390,7 @@ class Table(pa.Table):
         return Table.union(self, Table.from_counts(table, counts))
 
     def sort_indices(
-        self, *names: str, length: Optional[int] = None, null_placement: str = 'at_end'
+        self, *names: str, length: int | None = None, null_placement: str = 'at_end'
     ) -> pa.Array:
         """Return indices which would sort the table by columns, optimized for fixed length."""
         func = functools.partial(pc.sort_indices, null_placement=null_placement)
@@ -404,7 +403,7 @@ class Table(pa.Table):
     def sort(
         self,
         *names: str,
-        length: Optional[int] = None,
+        length: int | None = None,
         indices: str = '',
         null_placement: str = 'at_end',
     ) -> Batch:
@@ -521,7 +520,7 @@ class Table(pa.Table):
             offset += len(batch)
             yield pa.RecordBatch.from_pydict(columns)
 
-    def split(self) -> Iterator[Optional[pa.RecordBatch]]:
+    def split(self) -> Iterator[pa.RecordBatch | None]:
         """Generate tables from splitting list scalars."""
         lists = Table.list_fields(self)
         scalars = set(self.schema.names) - lists

{graphique-1.8 → graphique-1.9}/graphique/inputs.py

@@ -2,13 +2,14 @@
 GraphQL input types.
 """
 
+from __future__ import annotations
 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 Generic, Optional, TypeVar, no_type_check
+from typing import Generic, TypeVar, no_type_check
 import pyarrow as pa
 import pyarrow.compute as pc
 import pyarrow.dataset as ds
@@ -71,7 +72,7 @@ class provisional:
 
 
 def default_field(
-    default=UNSET, func: Optional[Callable] = None, nullable: bool = False, **kwargs
+    default=UNSET, func: Callable | None = None, nullable: bool = False, **kwargs
 ) -> StrawberryField:
     """Use dataclass `default_factory` for `UNSET` or mutables."""
     if func is not None:
@@ -83,16 +84,16 @@ def default_field(
 
 @strawberry.input(description="predicates for scalars")
 class Filter(Generic[T], Input):
-    eq: Optional[list[Optional[T]]] = default_field(
+    eq: list[T | None] | None = default_field(
         description="== or `isin`; `null` is equivalent to arrow `is_null`.", nullable=True
     )
-    ne: Optional[T] = default_field(
+    ne: T | None = default_field(
         description="!=; `null` is equivalent to arrow `is_valid`.", nullable=True
     )
-    lt: Optional[T] = default_field(description="<")
-    le: Optional[T] = default_field(description="<=")
-    gt: Optional[T] = default_field(description=r"\>")
-    ge: Optional[T] = default_field(description=r"\>=")
+    lt: T | None = default_field(description="<")
+    le: T | None = default_field(description="<=")
+    gt: T | None = default_field(description=r"\>")
+    ge: T | None = default_field(description=r"\>=")
 
     nullables = {'eq', 'ne'}
 
@@ -133,7 +134,7 @@ class Pairwise(Field):
 class Index(Field):
     value: JSON
     start: Long = 0
-    end: Optional[Long] = None
+    end: Long | None = None
 
 
 @strawberry.input
@@ -152,16 +153,20 @@ class Quantile(Field):
 
 
 @strawberry.input
-class Rank(Field):
+class RankQuantile(Field):
     sort_keys: str = 'ascending'
     null_placement: str = 'at_end'
+
+
+@strawberry.input
+class Rank(RankQuantile):
     tiebreaker: str = 'first'
 
 
 @strawberry.input
 class Sort:
     by: list[str]
-    length: Optional[Long] = None
+    length: Long | None = None
 
 
 @strawberry.input
@@ -174,12 +179,12 @@ class Ranked:
 class ListFunction(Input):
     deprecation = "List scalar functions will be moved to `scan(...: {list: ...})`"
 
-    filter: 'Expression' = default_field({}, description="filter within list scalars")
-    sort: Optional[Sort] = default_field(description="sort within list scalars")
-    rank: Optional[Ranked] = default_field(description="select by dense rank within list scalars")
-    index: Optional[Index] = default_field(func=pc.index, deprecation_reason=deprecation)
-    mode: Optional[Mode] = default_field(func=pc.mode, deprecation_reason=deprecation)
-    quantile: Optional[Quantile] = default_field(func=pc.quantile, deprecation_reason=deprecation)
+    filter: Expression = default_field({}, description="filter within list scalars")
+    sort: Sort | None = default_field(description="sort within list scalars")
+    rank: Ranked | None = default_field(description="select by dense rank within list scalars")
+    index: Index | None = default_field(func=pc.index, deprecation_reason=deprecation)
+    mode: Mode | None = default_field(func=pc.mode, deprecation_reason=deprecation)
+    quantile: Quantile | None = default_field(func=pc.quantile, deprecation_reason=deprecation)
 
     def keys(self):
         return set(super().keys()) - {'filter', 'sort', 'rank'}
@@ -252,10 +257,10 @@ class Diff(Input):
     """
 
     name: str
-    less: Optional[float] = default_field(name='lt', description="<", nullable=True)
-    less_equal: Optional[float] = default_field(name='le', description="<=", nullable=True)
-    greater: Optional[float] = default_field(name='gt', description=r"\>", nullable=True)
-    greater_equal: Optional[float] = default_field(name='ge', description=r"\>=", nullable=True)
+    less: float | None = default_field(name='lt', description="<", nullable=True)
+    less_equal: float | None = default_field(name='le', description="<=", nullable=True)
+    greater: float | None = default_field(name='gt', description=r"\>", nullable=True)
+    greater_equal: float | None = default_field(name='ge', description=r"\>=", nullable=True)
 
     nullables = {'less', 'less_equal', 'greater', 'greater_equal'}
 
@@ -275,7 +280,7 @@ class Expression:
     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(
+    value: JSON | None = default_field(
         description="JSON scalar; also see typed scalars", nullable=True
     )
     kleene: bool = strawberry.field(default=False, description="use kleene logic for booleans")
@@ -288,58 +293,56 @@ class Expression:
     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)
-    negate: Optional['Expression'] = default_field(func=pc.negate)
-    power: list['Expression'] = default_field([], func=pc.power)
-    sign: Optional['Expression'] = default_field(func=pc.sign)
-    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")
-    log: Optional['Log'] = default_field(description="logarithmic functions")
-    trig: Optional['Trig'] = default_field(description="trigonometry functions")
-    element_wise: Optional['ElementWise'] = default_field(
-        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)
-
-    utf8: Optional['Utf8'] = default_field(description="utf8 string functions")
-    string_is_ascii: Optional['Expression'] = default_field(func=pc.string_is_ascii)
-    substring: Optional['MatchSubstring'] = default_field(description="match substring functions")
-
-    binary: Optional['Binary'] = default_field(description="binary functions")
-    set_lookup: Optional['SetLookup'] = default_field(description="set lookup functions")
-
-    is_finite: Optional['Expression'] = default_field(func=pc.is_finite)
-    is_inf: Optional['Expression'] = default_field(func=pc.is_inf)
-    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)
-
-    temporal: Optional['Temporal'] = default_field(description="temporal functions")
-
-    replace_with_mask: list['Expression'] = default_field([], func=pc.replace_with_mask)
-
-    list: Optional['Lists'] = default_field(description="list array functions")
+    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: Expression | None = default_field(description="~")
+
+    abs: Expression | None = 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)
+    negate: Expression | None = default_field(func=pc.negate)
+    power: list[Expression] = default_field([], func=pc.power)
+    sign: Expression | None = default_field(func=pc.sign)
+    subtract: list[Expression] = default_field([], func=pc.subtract)
+
+    bit_wise: BitWise | None = default_field(description="bit-wise functions")
+    rounding: Rounding | None = default_field(description="rounding functions")
+    log: Log | None = default_field(description="logarithmic functions")
+    trig: Trig | None = default_field(description="trigonometry functions")
+    element_wise: ElementWise | None = default_field(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)
+
+    utf8: Utf8 | None = default_field(description="utf8 string functions")
+    string_is_ascii: Expression | None = default_field(func=pc.string_is_ascii)
+    substring: MatchSubstring | None = default_field(description="match substring functions")
+
+    binary: Binary | None = default_field(description="binary functions")
+    set_lookup: SetLookup | None = default_field(description="set lookup functions")
+
+    is_finite: Expression | None = default_field(func=pc.is_finite)
+    is_inf: Expression | None = default_field(func=pc.is_inf)
+    is_nan: Expression | None = default_field(func=pc.is_nan)
+    true_unless_null: Expression | None = 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)
+
+    temporal: Temporal | None = default_field(description="temporal functions")
+
+    replace_with_mask: list[Expression] = default_field([], func=pc.replace_with_mask)
+
+    list: Lists | None = default_field(description="list array functions")
 
     unaries = ('inv', 'abs', 'negate', 'sign', 'string_is_ascii', 'is_finite', 'is_inf', 'is_nan')
     associatives = ('add', 'multiply', 'and_', 'or_', 'xor')
@@ -349,7 +352,7 @@ class Expression:
     groups = ('bit_wise', 'rounding', 'log', 'trig', 'element_wise', 'utf8', 'substring', 'binary')
     groups += ('set_lookup', 'temporal', 'list')  # type: ignore
 
-    def to_arrow(self) -> Optional[ds.Expression]:
+    def to_arrow(self) -> ds.Expression | None:
         """Transform GraphQL expression into a dataset expression."""
         fields = []
         if self.name:
@@ -457,11 +460,11 @@ class BitWise(Fields):
 
 @strawberry.input(description="Rounding functions.")
 class Rounding(Fields):
-    ceil: Optional[Expression] = default_field(func=pc.ceil)
-    floor: Optional[Expression] = default_field(func=pc.floor)
-    trunc: Optional[Expression] = default_field(func=pc.trunc)
+    ceil: Expression | None = default_field(func=pc.ceil)
+    floor: Expression | None = default_field(func=pc.floor)
+    trunc: Expression | None = default_field(func=pc.trunc)
 
-    round: Optional[Expression] = default_field(func=pc.round)
+    round: Expression | None = default_field(func=pc.round)
     ndigits: int = 0
     round_mode: str = 'half_to_even'
     multiple: float = 1.0
@@ -474,8 +477,8 @@ class Rounding(Fields):
 
 @strawberry.input(description="Logarithmic functions.")
 class Log(Fields):
-    ln: Optional[Expression] = default_field(func=pc.ln)
-    log1p: Optional[Expression] = default_field(func=pc.log1p)
+    ln: Expression | None = default_field(func=pc.ln)
+    log1p: Expression | None = default_field(func=pc.log1p)
     logb: list[Expression] = default_field([], func=pc.logb)
 
 
@@ -483,13 +486,13 @@ class Log(Fields):
 class Trig(Fields):
     checked: bool = strawberry.field(default=False, description="check for overflow errors")
 
-    acos: Optional[Expression] = default_field(func=pc.acos)
-    asin: Optional[Expression] = default_field(func=pc.asin)
-    atan: Optional[Expression] = default_field(func=pc.atan)
+    acos: Expression | None = default_field(func=pc.acos)
+    asin: Expression | None = default_field(func=pc.asin)
+    atan: Expression | None = default_field(func=pc.atan)
     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)
+    cos: Expression | None = default_field(func=pc.cos)
+    sin: Expression | None = default_field(func=pc.sin)
+    tan: Expression | None = default_field(func=pc.tan)
 
     def getfunc(self, name):
         return getattr(pc, name + ('_checked' * self.checked))
@@ -504,40 +507,40 @@ class ElementWise(Fields):
 
 @strawberry.input(description="Utf8 string functions.")
 class Utf8(Fields):
-    is_alnum: Optional[Expression] = default_field(func=pc.utf8_is_alnum)
-    is_alpha: Optional[Expression] = default_field(func=pc.utf8_is_alpha)
-    is_decimal: Optional[Expression] = default_field(func=pc.utf8_is_decimal)
-    is_digit: Optional[Expression] = default_field(func=pc.utf8_is_digit)
-    is_lower: Optional[Expression] = default_field(func=pc.utf8_is_lower)
-    is_numeric: Optional[Expression] = default_field(func=pc.utf8_is_numeric)
-    is_printable: Optional[Expression] = default_field(func=pc.utf8_is_printable)
-    is_space: Optional[Expression] = default_field(func=pc.utf8_is_space)
-    is_title: Optional[Expression] = default_field(func=pc.utf8_is_title)
-    is_upper: Optional[Expression] = default_field(func=pc.utf8_is_upper)
-
-    capitalize: Optional[Expression] = default_field(func=pc.utf8_capitalize)
-    length: Optional[Expression] = default_field(func=pc.utf8_length)
-    lower: Optional[Expression] = default_field(func=pc.utf8_lower)
-    reverse: Optional[Expression] = default_field(func=pc.utf8_reverse)
-    swapcase: Optional[Expression] = default_field(func=pc.utf8_swapcase)
-    title: Optional[Expression] = default_field(func=pc.utf8_title)
-    upper: Optional[Expression] = default_field(func=pc.utf8_upper)
-
-    ltrim: Optional[Expression] = default_field(func=pc.utf8_ltrim)
-    rtrim: Optional[Expression] = default_field(func=pc.utf8_rtrim)
-    trim: Optional[Expression] = default_field(func=pc.utf8_trim)
+    is_alnum: Expression | None = default_field(func=pc.utf8_is_alnum)
+    is_alpha: Expression | None = default_field(func=pc.utf8_is_alpha)
+    is_decimal: Expression | None = default_field(func=pc.utf8_is_decimal)
+    is_digit: Expression | None = default_field(func=pc.utf8_is_digit)
+    is_lower: Expression | None = default_field(func=pc.utf8_is_lower)
+    is_numeric: Expression | None = default_field(func=pc.utf8_is_numeric)
+    is_printable: Expression | None = default_field(func=pc.utf8_is_printable)
+    is_space: Expression | None = default_field(func=pc.utf8_is_space)
+    is_title: Expression | None = default_field(func=pc.utf8_is_title)
+    is_upper: Expression | None = default_field(func=pc.utf8_is_upper)
+
+    capitalize: Expression | None = default_field(func=pc.utf8_capitalize)
+    length: Expression | None = default_field(func=pc.utf8_length)
+    lower: Expression | None = default_field(func=pc.utf8_lower)
+    reverse: Expression | None = default_field(func=pc.utf8_reverse)
+    swapcase: Expression | None = default_field(func=pc.utf8_swapcase)
+    title: Expression | None = default_field(func=pc.utf8_title)
+    upper: Expression | None = default_field(func=pc.utf8_upper)
+
+    ltrim: Expression | None = default_field(func=pc.utf8_ltrim)
+    rtrim: Expression | None = default_field(func=pc.utf8_rtrim)
+    trim: Expression | None = default_field(func=pc.utf8_trim)
     characters: str = default_field('', description="trim options; by default trims whitespace")
 
-    replace_slice: Optional[Expression] = default_field(func=pc.utf8_replace_slice)
-    slice_codeunits: Optional[Expression] = default_field(func=pc.utf8_slice_codeunits)
+    replace_slice: Expression | None = default_field(func=pc.utf8_replace_slice)
+    slice_codeunits: Expression | None = default_field(func=pc.utf8_slice_codeunits)
     start: int = 0
-    stop: Optional[int] = UNSET
+    stop: int | None = UNSET
     step: int = 1
     replacement: str = ''
 
-    center: Optional[Expression] = default_field(func=pc.utf8_center)
-    lpad: Optional[Expression] = default_field(func=pc.utf8_lpad)
-    rpad: Optional[Expression] = default_field(func=pc.utf8_rpad)
+    center: Expression | None = default_field(func=pc.utf8_center)
+    lpad: Expression | None = default_field(func=pc.utf8_lpad)
+    rpad: Expression | None = default_field(func=pc.utf8_rpad)
     width: int = 0
     padding: str = ''
 
@@ -549,16 +552,16 @@ class Utf8(Fields):
 
 @strawberry.input(description="Binary functions.")
 class Binary(Fields):
-    length: Optional[Expression] = default_field(func=pc.binary_length)
+    length: Expression | None = default_field(func=pc.binary_length)
     repeat: list[Expression] = default_field([], func=pc.binary_repeat)
-    reverse: Optional[Expression] = default_field(func=pc.binary_reverse)
+    reverse: Expression | None = 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)
     null_handling: str = 'emit_null'
     null_replacement: str = ''
 
-    replace_slice: Optional[Expression] = default_field(func=pc.binary_replace_slice)
+    replace_slice: Expression | None = default_field(func=pc.binary_replace_slice)
     start: int = 0
     stop: int = 0
     replacement: bytes = b''
@@ -568,22 +571,20 @@ class Binary(Fields):
 
 @strawberry.input(description="Match substring functions.")
 class MatchSubstring(Fields):
-    count_substring: Optional[Expression] = default_field(name='count', func=pc.count_substring)
-    ends_with: Optional[Expression] = default_field(func=pc.ends_with)
-    find_substring: Optional[Expression] = default_field(name='find', func=pc.find_substring)
-    match_substring: Optional[Expression] = default_field(name='match', func=pc.match_substring)
-    starts_with: Optional[Expression] = default_field(func=pc.starts_with)
-    replace_substring: Optional[Expression] = default_field(
-        name='replace', func=pc.replace_substring
-    )
-    split_pattern: Optional[Expression] = default_field(name='split', func=pc.split_pattern)
-    extract: Optional[Expression] = default_field(func=pc.extract_regex)
+    count_substring: Expression | None = default_field(name='count', func=pc.count_substring)
+    ends_with: Expression | None = default_field(func=pc.ends_with)
+    find_substring: Expression | None = default_field(name='find', func=pc.find_substring)
+    match_substring: Expression | None = default_field(name='match', func=pc.match_substring)
+    starts_with: Expression | None = default_field(func=pc.starts_with)
+    replace_substring: Expression | None = default_field(name='replace', func=pc.replace_substring)
+    split_pattern: Expression | None = default_field(name='split', func=pc.split_pattern)
+    extract: Expression | None = default_field(func=pc.extract_regex)
     pattern: str = ''
     ignore_case: bool = False
     regex: bool = False
     replacement: str = ''
-    max_replacements: Optional[int] = None
-    max_splits: Optional[int] = None
+    max_replacements: int | None = None
+    max_splits: int | None = None
     reverse: bool = False
 
     def getfunc(self, name):
@@ -594,26 +595,26 @@ class MatchSubstring(Fields):
 
 @strawberry.input(description="Temporal functions.")
 class Temporal(Fields):
-    day: Optional[Expression] = default_field(func=pc.day)
-    day_of_year: Optional[Expression] = default_field(func=pc.day_of_year)
-    hour: Optional[Expression] = default_field(func=pc.hour)
-    iso_week: Optional[Expression] = default_field(func=pc.iso_week)
-    iso_year: Optional[Expression] = default_field(func=pc.iso_year)
-    iso_calendar: Optional[Expression] = default_field(func=pc.iso_calendar)
-    is_leap_year: Optional[Expression] = default_field(func=pc.is_leap_year)
-
-    microsecond: Optional[Expression] = default_field(func=pc.microsecond)
-    millisecond: Optional[Expression] = default_field(func=pc.millisecond)
-    minute: Optional[Expression] = default_field(func=pc.minute)
-    month: Optional[Expression] = default_field(func=pc.month)
-    nanosecond: Optional[Expression] = default_field(func=pc.nanosecond)
-    quarter: Optional[Expression] = default_field(func=pc.quarter)
-    second: Optional[Expression] = default_field(func=pc.second)
-    subsecond: Optional[Expression] = default_field(func=pc.subsecond)
-    us_week: Optional[Expression] = default_field(func=pc.us_week)
-    us_year: Optional[Expression] = default_field(func=pc.us_year)
-    year: Optional[Expression] = default_field(func=pc.year)
-    year_month_day: Optional[Expression] = default_field(func=pc.year_month_day)
+    day: Expression | None = default_field(func=pc.day)
+    day_of_year: Expression | None = default_field(func=pc.day_of_year)
+    hour: Expression | None = default_field(func=pc.hour)
+    iso_week: Expression | None = default_field(func=pc.iso_week)
+    iso_year: Expression | None = default_field(func=pc.iso_year)
+    iso_calendar: Expression | None = default_field(func=pc.iso_calendar)
+    is_leap_year: Expression | None = default_field(func=pc.is_leap_year)
+
+    microsecond: Expression | None = default_field(func=pc.microsecond)
+    millisecond: Expression | None = default_field(func=pc.millisecond)
+    minute: Expression | None = default_field(func=pc.minute)
+    month: Expression | None = default_field(func=pc.month)
+    nanosecond: Expression | None = default_field(func=pc.nanosecond)
+    quarter: Expression | None = default_field(func=pc.quarter)
+    second: Expression | None = default_field(func=pc.second)
+    subsecond: Expression | None = default_field(func=pc.subsecond)
+    us_week: Expression | None = default_field(func=pc.us_week)
+    us_year: Expression | None = default_field(func=pc.us_year)
+    year: Expression | None = default_field(func=pc.year)
+    year_month_day: Expression | None = default_field(func=pc.year_month_day)
 
     day_time_interval_between: list[Expression] = default_field(
         [], func=pc.day_time_interval_between
@@ -633,29 +634,29 @@ class Temporal(Fields):
     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)
-    round_temporal: Optional[Expression] = default_field(name='round', func=pc.round_temporal)
+    ceil_temporal: Expression | None = default_field(name='ceil', func=pc.ceil_temporal)
+    floor_temporal: Expression | None = default_field(name='floor', func=pc.floor_temporal)
+    round_temporal: Expression | None = default_field(name='round', func=pc.round_temporal)
     multiple: int = 1
     unit: str = 'day'
     week_starts_monday: bool = True
     ceil_is_strictly_greater: bool = False
     calendar_based_origin: bool = False
 
-    week: Optional[Expression] = default_field(func=pc.week)
-    count_from_zero: Optional[bool] = UNSET
+    week: Expression | None = default_field(func=pc.week)
+    count_from_zero: bool | None = UNSET
     first_week_is_fully_in_year: bool = False
 
-    day_of_week: Optional[Expression] = default_field(func=pc.day_of_week)
+    day_of_week: Expression | None = default_field(func=pc.day_of_week)
     week_start: int = 1
 
-    strftime: Optional[Expression] = default_field(func=pc.strftime)
-    strptime: Optional[Expression] = default_field(func=pc.strptime)
+    strftime: Expression | None = default_field(func=pc.strftime)
+    strptime: Expression | None = default_field(func=pc.strptime)
     format: str = '%Y-%m-%dT%H:%M:%S'
     locale: str = 'C'
     error_is_null: bool = False
 
-    assume_timezone: Optional[Expression] = default_field(func=pc.assume_timezone)
+    assume_timezone: Expression | None = default_field(func=pc.assume_timezone)
     timezone: str = ''
     ambiguous: str = 'raise'
     nonexistent: str = 'raise'
@@ -684,16 +685,16 @@ class SetLookup(Fields):
 @strawberry.input(description="List array functions.")
 class Lists(Fields):
     element: list[Expression] = default_field([], func=pc.list_element)
-    value_length: Optional[Expression] = default_field(func=pc.list_value_length)
+    value_length: Expression | None = default_field(func=pc.list_value_length)
     # user defined functions
-    all: Optional[Expression] = default_field(func=pc.all)
-    any: Optional[Expression] = default_field(func=pc.any)
+    all: Expression | None = default_field(func=pc.all)
+    any: Expression | None = default_field(func=pc.any)
 
-    slice: Optional[Expression] = default_field(func=pc.list_slice)
+    slice: Expression | None = default_field(func=pc.list_slice)
     start: int = 0
-    stop: Optional[int] = None
+    stop: int | None = None
     step: int = 1
-    return_fixed_size_list: Optional[bool] = None
+    return_fixed_size_list: bool | None = None
 
     prefix = 'list_'
 

{graphique-1.8 → graphique-1.9}/graphique/interface.py

@@ -10,7 +10,7 @@ import inspect
 import itertools
 from collections.abc import Callable, Iterable, Iterator, Mapping, Sized
 from datetime import timedelta
-from typing import Annotated, Optional, Union, no_type_check
+from typing import Annotated, TypeAlias, no_type_check
 import pyarrow as pa
 import pyarrow.compute as pc
 import pyarrow.dataset as ds
@@ -20,12 +20,12 @@ from strawberry.extensions.utils import get_path_from_info
 from typing_extensions import Self
 from .core import Agg, Batch, Column as C, ListChunk, Nodes, Table as T
 from .inputs import CountAggregate, Cumulative, Diff, Expression, Field, Filter
-from .inputs import HashAggregates, ListFunction, Pairwise, Projection, Rank
+from .inputs import HashAggregates, ListFunction, Pairwise, Projection, Rank, RankQuantile
 from .inputs import ScalarAggregate, TDigestAggregate, VarianceAggregate, links, provisional
 from .models import Column, doc_field
 from .scalars import Long
 
-Source = Union[ds.Dataset, Nodes, ds.Scanner, pa.Table]
+Source: TypeAlias = ds.Dataset | Nodes | ds.Scanner | pa.Table
 
 
 def references(field) -> Iterator:
@@ -83,7 +83,7 @@ class Dataset:
             return self.source.select(names)
         return Nodes.scan(self.source, names)
 
-    def to_table(self, info: Info, length: Optional[int] = None) -> pa.Table:
+    def to_table(self, info: Info, length: int | None = None) -> pa.Table:
         """Return table with only the rows and columns necessary to proceed."""
         source = self.select(info)
         if isinstance(source, pa.Table):
@@ -163,7 +163,7 @@ class Dataset:
         )  # type: ignore
 
     @doc_field
-    def optional(self) -> Optional[Self]:
+    def optional(self) -> Self | None:
         """Nullable field to stop error propagation, enabling partial query results.
 
         Will be replaced by client controlled nullability.
@@ -192,7 +192,7 @@ class Dataset:
         return len(table) >= length
 
     @doc_field
-    def size(self) -> Optional[Long]:
+    def size(self) -> Long | None:
         """buffer size in bytes; null if table is not loaded"""
         return getattr(self.source, 'nbytes', None)
 
@@ -203,7 +203,7 @@ class Dataset:
     )
     def column(
         self, info: Info, name: list[str], cast: str = '', safe: bool = True
-    ) -> Optional[Column]:
+    ) -> Column | None:
         """Return column of any type by name.
 
         This is typically only needed for aliased or casted columns.
@@ -222,14 +222,14 @@ class Dataset:
         reverse="reverse order after slicing; forces a copy",
     )
     def slice(
-        self, info: Info, offset: Long = 0, length: Optional[Long] = None, reverse: bool = False
+        self, info: Info, offset: Long = 0, length: Long | None = None, reverse: bool = False
     ) -> Self:
         """Return zero-copy slice of table.
 
-        Can also be sued to force loading a dataset.
+        Can also be used to force loading a dataset.
         """
         table = self.to_table(info, length and (offset + length if offset >= 0 else None))
-        table = table[offset:][:length]  # `slice` bug: ARROW-15412
+        table = table[offset:][:length]  # `slice` bug: apache/arrow#30894
         return type(self)(table[::-1] if reverse else table)
 
     @doc_field(
@@ -301,7 +301,7 @@ class Dataset:
         self,
         info: Info,
         by: list[str],
-        length: Optional[Long] = None,
+        length: Long | None = None,
         null_placement: str = 'at_end',
     ) -> Self:
         """Return table slice sorted by specified columns.
@@ -362,6 +362,8 @@ class Dataset:
         fill_null_forward: doc_argument(list[Field], func=pc.fill_null_forward) = [],
         pairwise_diff: doc_argument(list[Pairwise], func=pc.pairwise_diff) = [],
         rank: doc_argument(list[Rank], func=pc.rank) = [],
+        rank_quantile: doc_argument(list[RankQuantile], func=pc.rank_quantile) = [],
+        rank_normal: doc_argument(list[RankQuantile], func=pc.rank_normal) = [],
         list_: Annotated[
             ListFunction,
             strawberry.argument(name='list', description="functions for list arrays."),
@@ -377,7 +379,7 @@ class Dataset:
         columns = {}
         funcs = pc.cumulative_max, pc.cumulative_mean, pc.cumulative_min, pc.cumulative_prod
         funcs += pc.cumulative_sum, C.fill_null_backward, C.fill_null_forward, C.pairwise_diff
-        funcs += (pc.rank,)
+        funcs += pc.rank, pc.rank_quantile, pc.rank_normal
         for func in funcs:
             for field in locals()[func.__name__]:
                 callable = func
@@ -396,7 +398,7 @@ class Dataset:
         return type(self)(self.add_metric(info, table, mode='batch'))
 
     @doc_field
-    def tables(self, info: Info) -> list[Optional[Self]]:  # type: ignore
+    def tables(self, info: Info) -> list[Self | None]:  # type: ignore
         """Return a list of tables by splitting list columns.
 
         At least one list column must be referenced, and all list columns must have the same lengths.
@@ -477,7 +479,7 @@ class Dataset:
         info: Info,
         right: str,
         keys: list[str],
-        right_keys: Optional[list[str]] = None,
+        right_keys: list[str] | None = None,
         join_type: str = 'left outer',
         left_suffix: str = '',
         right_suffix: str = '',

{graphique-1.8 → graphique-1.9}/graphique/middleware.py

@@ -6,7 +6,6 @@ import warnings
 from collections.abc import Iterable, Mapping
 from datetime import timedelta
 from keyword import iskeyword
-from typing import Optional
 import pyarrow.dataset as ds
 import strawberry.asgi
 from strawberry import Info, UNSET
@@ -33,7 +32,7 @@ class MetricsExtension(tracing.ApolloTracingExtension):
         return {'metrics': metrics}
 
     @staticmethod
-    def duration(data: dict) -> Optional[str]:
+    def duration(data: dict) -> str | None:
         return data['duration'] and str(timedelta(microseconds=data['duration'] / 1e3))
 
 
@@ -87,12 +86,12 @@ def implemented(root: Source, name: str = '', keys: Iterable = ()):
     prefix = to_camel_case(name.title())
 
     namespace = {name: strawberry.field(default=UNSET, name=name) for name in types}
-    annotations = {name: Optional[Column.registry[types[name]]] for name in types}
+    annotations = {name: Column.registry[types[name]] | None for name in types}
     cls = type(prefix + 'Columns', (), dict(namespace, __annotations__=annotations))
     Columns = strawberry.type(cls, description="fields for each column")
 
     namespace = {name: strawberry.field(default=UNSET, name=name) for name in types}
-    annotations = {name: Optional[Column if cls is list else cls] for name, cls in types.items()}
+    annotations = {name: (Column if cls is list else cls) | None for name, cls in types.items()}
     cls = type(prefix + 'Row', (), dict(namespace, __annotations__=annotations))
     Row = strawberry.type(cls, description="scalar fields")
 
@@ -104,7 +103,7 @@ def implemented(root: Source, name: str = '', keys: Iterable = ()):
             """fields for each column"""
             return Columns(**super().columns(info))
 
-        def row(self, info: Info, index: Long = 0) -> Optional[Row]:  # type: ignore
+        def row(self, info: Info, index: Long = 0) -> Row | None:  # type: ignore
             """Return scalar values at index."""
             row = super().row(info, index)
             for name, value in row.items():

{graphique-1.8 → graphique-1.9}/graphique/models.py

@@ -2,12 +2,13 @@
 GraphQL output types and resolvers.
 """
 
+from __future__ import annotations
 import functools
 import inspect
 from collections.abc import Callable
 from datetime import date, datetime, time, timedelta
 from decimal import Decimal
-from typing import Annotated, Generic, Optional, TypeVar, TYPE_CHECKING, get_args
+from typing import Annotated, Generic, TypeVar, TYPE_CHECKING, get_args
 import pyarrow as pa
 import pyarrow.compute as pc
 import strawberry
@@ -27,7 +28,7 @@ def selections(*fields) -> set:
     return {selection.name for field in fields for selection in field.selections}
 
 
-def doc_field(func: Optional[Callable] = None, **kwargs: str) -> StrawberryField:
+def doc_field(func: Callable | None = None, **kwargs: str) -> StrawberryField:
     """Return strawberry field with argument and docstring descriptions."""
     if func is None:
         return functools.partial(doc_field, **kwargs)  # type: ignore
@@ -77,12 +78,12 @@ class Column:
         return self.array.nbytes
 
     @classmethod
-    def cast(cls, array: pa.ChunkedArray) -> 'Column':
+    def cast(cls, array: pa.ChunkedArray) -> Column:
         """Return typed column based on array type."""
         return cls.registry[py_type(array.type)](array)
 
     @classmethod
-    def fromscalar(cls, scalar: pa.ListScalar) -> Optional['Column']:
+    def fromscalar(cls, scalar: pa.ListScalar) -> Column | None:
         return None if scalar.values is None else cls.cast(pa.chunked_array([scalar.values]))
 
     @compute_field
@@ -105,7 +106,7 @@ class Set(Generic[T]):
         self.array, self.counts = array, counts.to_pylist()
 
     @doc_field
-    def values(self) -> list[Optional[T]]:
+    def values(self) -> list[T | None]:
         """list of values"""
         return self.array.to_pylist()
 
@@ -126,7 +127,7 @@ class NominalColumn(Generic[T], Column):
         return Set(self.array.unique())
 
     @doc_field
-    def value(self, index: Long = 0) -> Optional[T]:
+    def value(self, index: Long = 0) -> T | None:
         """scalar value at index"""
         return self.array[index].as_py()
 
@@ -139,23 +140,23 @@ class NominalColumn(Generic[T], Column):
 @strawberry.type(name='Column', description="column of ordinal values")
 class OrdinalColumn(NominalColumn[T]):
     @compute_field
-    def first(self, skip_nulls: bool = True, min_count: int = 0) -> Optional[T]:
+    def first(self, skip_nulls: bool = True, min_count: int = 0) -> T | None:
         return pc.first(self.array, skip_nulls=skip_nulls, min_count=min_count).as_py()
 
     @compute_field
-    def last(self, skip_nulls: bool = True, min_count: int = 0) -> Optional[T]:
+    def last(self, skip_nulls: bool = True, min_count: int = 0) -> T | None:
         return pc.last(self.array, skip_nulls=skip_nulls, min_count=min_count).as_py()
 
     @compute_field
-    def min(self, skip_nulls: bool = True, min_count: int = 0) -> Optional[T]:
+    def min(self, skip_nulls: bool = True, min_count: int = 0) -> T | None:
         return pc.min(self.array, skip_nulls=skip_nulls, min_count=min_count).as_py()
 
     @compute_field
-    def max(self, skip_nulls: bool = True, min_count: int = 0) -> Optional[T]:
+    def max(self, skip_nulls: bool = True, min_count: int = 0) -> T | None:
         return pc.max(self.array, skip_nulls=skip_nulls, min_count=min_count).as_py()
 
     @compute_field
-    def index(self, value: T, start: Long = 0, end: Optional[Long] = None) -> Long:
+    def index(self, value: T, start: Long = 0, end: Long | None = None) -> Long:
         return C.index(self.array, value, start, end)
 
     @compute_field
@@ -175,15 +176,15 @@ class IntervalColumn(OrdinalColumn[T]):
         return Set(*pc.mode(self.array, n, skip_nulls=skip_nulls, min_count=min_count).flatten())
 
     @compute_field
-    def sum(self, skip_nulls: bool = True, min_count: int = 0) -> Optional[T]:
+    def sum(self, skip_nulls: bool = True, min_count: int = 0) -> T | None:
         return pc.sum(self.array, skip_nulls=skip_nulls, min_count=min_count).as_py()
 
     @compute_field
-    def product(self, skip_nulls: bool = True, min_count: int = 0) -> Optional[T]:
+    def product(self, skip_nulls: bool = True, min_count: int = 0) -> T | None:
         return pc.product(self.array, skip_nulls=skip_nulls, min_count=min_count).as_py()
 
     @compute_field
-    def mean(self, skip_nulls: bool = True, min_count: int = 0) -> Optional[float]:
+    def mean(self, skip_nulls: bool = True, min_count: int = 0) -> float | None:
         return pc.mean(self.array, skip_nulls=skip_nulls, min_count=min_count).as_py()
 
     @compute_field
@@ -195,13 +196,11 @@ class IntervalColumn(OrdinalColumn[T]):
 @strawberry.type(name='Column', description="column of floats or decimals")
 class RatioColumn(IntervalColumn[T]):
     @compute_field
-    def stddev(self, ddof: int = 0, skip_nulls: bool = True, min_count: int = 0) -> Optional[float]:
+    def stddev(self, ddof: int = 0, skip_nulls: bool = True, min_count: int = 0) -> float | None:
         return pc.stddev(self.array, ddof=ddof, skip_nulls=skip_nulls, min_count=min_count).as_py()
 
     @compute_field
-    def variance(
-        self, ddof: int = 0, skip_nulls: bool = True, min_count: int = 0
-    ) -> Optional[float]:
+    def variance(self, ddof: int = 0, skip_nulls: bool = True, min_count: int = 0) -> float | None:
         options = {'skip_nulls': skip_nulls, 'min_count': min_count}
         return pc.variance(self.array, ddof=ddof, **options).as_py()
 
@@ -212,7 +211,7 @@ class RatioColumn(IntervalColumn[T]):
         interpolation: str = 'linear',
         skip_nulls: bool = True,
         min_count: int = 0,
-    ) -> list[Optional[float]]:
+    ) -> list[float | None]:
         options = {'skip_nulls': skip_nulls, 'min_count': min_count}
         return pc.quantile(self.array, q=q, interpolation=interpolation, **options).to_pylist()
 
@@ -224,7 +223,7 @@ class RatioColumn(IntervalColumn[T]):
         buffer_size: int = 500,
         skip_nulls: bool = True,
         min_count: int = 0,
-    ) -> list[Optional[float]]:
+    ) -> list[float | None]:
         options = {'buffer_size': buffer_size, 'skip_nulls': skip_nulls, 'min_count': min_count}
         return pc.tdigest(self.array, q=q, delta=delta, **options).to_pylist()
 
@@ -233,11 +232,11 @@ class RatioColumn(IntervalColumn[T]):
 @strawberry.type(name='eanColumn', description="column of booleans")
 class BooleanColumn(IntervalColumn[T]):
     @compute_field
-    def any(self, skip_nulls: bool = True, min_count: int = 1) -> Optional[bool]:
+    def any(self, skip_nulls: bool = True, min_count: int = 1) -> bool | None:
         return pc.any(self.array, skip_nulls=skip_nulls, min_count=min_count).as_py()
 
     @compute_field
-    def all(self, skip_nulls: bool = True, min_count: int = 1) -> Optional[bool]:
+    def all(self, skip_nulls: bool = True, min_count: int = 1) -> bool | None:
         return pc.all(self.array, skip_nulls=skip_nulls, min_count=min_count).as_py()
 
 
@@ -247,7 +246,7 @@ class IntColumn(RatioColumn[T]):
     @doc_field
     def take_from(
         self, info: Info, field: str
-    ) -> Optional[Annotated['Dataset', strawberry.lazy('.interface')]]:
+    ) -> Annotated['Dataset', strawberry.lazy('.interface')] | None:
         """Select indices from a table on the root Query type."""
         root = getattr(info.root_value, field)
         return type(root)(root.select(info).take(self.array.combine_chunks()))
@@ -257,12 +256,12 @@ class IntColumn(RatioColumn[T]):
 @strawberry.type(description="column of lists")
 class ListColumn(Column):
     @doc_field
-    def value(self, index: Long = 0) -> Optional[Column]:
+    def value(self, index: Long = 0) -> Column | None:
         """scalar column at index"""
         return self.fromscalar(self.array[index])
 
     @doc_field
-    def values(self) -> list[Optional[Column]]:
+    def values(self) -> list[Column | None]:
         """list of columns"""
         return list(map(self.fromscalar, self.array))
 
@@ -280,7 +279,7 @@ class ListColumn(Column):
 @strawberry.type(description="column of structs")
 class StructColumn(Column):
     @doc_field
-    def value(self, index: Long = 0) -> Optional[dict]:
+    def value(self, index: Long = 0) -> dict | None:
         """scalar json object at index"""
         return self.array[index].as_py()
 
@@ -290,6 +289,6 @@ class StructColumn(Column):
         return [field.name for field in self.array.type]
 
     @doc_field(name="field name(s); multiple names access nested fields")
-    def column(self, name: list[str]) -> Optional[Column]:
+    def column(self, name: list[str]) -> Column | None:
         """Return struct field as a column."""
         return self.cast(pc.struct_field(self.array, name))

{graphique-1.8 → graphique-1.9}/graphique/scalars.py

@@ -5,7 +5,6 @@ GraphQL scalars.
 import functools
 from datetime import date, datetime, time, timedelta
 from decimal import Decimal
-from typing import Union
 import isodate
 import pyarrow as pa
 import strawberry
@@ -39,7 +38,7 @@ def _(mdn: pa.MonthDayNano) -> str:
 
 Long = strawberry.scalar(int, name='Long', description="64-bit int", parse_value=parse_long)
 Duration = strawberry.scalar(
-    Union[timedelta, pa.MonthDayNano],
+    timedelta | pa.MonthDayNano,
     name='Duration',
     description="Duration (isoformat)",
     specified_by_url="https://en.wikipedia.org/wiki/ISO_8601#Durations",
@@ -66,6 +65,8 @@ type_map = {
     pa.lib.Type_HALF_FLOAT: float,
     pa.lib.Type_FLOAT: float,
     pa.lib.Type_DOUBLE: float,
+    pa.lib.Type_DECIMAL32: Decimal,
+    pa.lib.Type_DECIMAL64: Decimal,
     pa.lib.Type_DECIMAL128: Decimal,
     pa.lib.Type_DECIMAL256: Decimal,
     pa.lib.Type_DATE32: date,

{graphique-1.8 → graphique-1.9}/graphique/shell.py

@@ -12,7 +12,7 @@ progress on the second pass.
 import operator
 import shutil
 from pathlib import Path
-from typing import Annotated, Callable, Optional
+from typing import Annotated, Callable
 import numpy as np
 import pyarrow.compute as pc
 import pyarrow.dataset as ds
@@ -43,7 +43,7 @@ def write_batches(
             pbar.update(len(batch))
 
 
-def write_fragments(dataset: ds.Dataset, base_dir: str, func: Optional[Callable] = None, **options):
+def write_fragments(dataset: ds.Dataset, base_dir: str, func: Callable | None = None, **options):
     """Rewrite partition files by fragment to consolidate, optionally transforming."""
     options['format'] = 'parquet'
     exprs = {Path(frag.path).parent: frag.partition_expression for frag in dataset.get_fragments()}

{graphique-1.8 → graphique-1.9}/graphique.egg-info/PKG-INFO

@@ -1,22 +1,9 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: graphique
-Version: 1.8
+Version: 1.9
 Summary: GraphQL service for arrow tables and parquet data sets.
 Author-email: Aric Coady <aric.coady@gmail.com>
-License: Copyright 2022 Aric Coady
-        
-           Licensed under the Apache License, Version 2.0 (the "License");
-           you may not use this file except in compliance with the License.
-           You may obtain a copy of the License at
-        
-             http://www.apache.org/licenses/LICENSE-2.0
-        
-           Unless required by applicable law or agreed to in writing, software
-           distributed under the License is distributed on an "AS IS" BASIS,
-           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-           See the License for the specific language governing permissions and
-           limitations under the License.
-        
+License: Apache-2.0
 Project-URL: Homepage, https://github.com/coady/graphique
 Project-URL: Documentation, https://coady.github.io/graphique
 Project-URL: Changelog, https://github.com/coady/graphique/blob/main/CHANGELOG.md
@@ -25,10 +12,8 @@ Keywords: graphql,arrow,parquet
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 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.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -38,10 +23,10 @@ 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.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: pyarrow>=18
+Requires-Dist: pyarrow>=20
 Requires-Dist: strawberry-graphql[asgi,cli]>=0.236
 Requires-Dist: numpy
 Requires-Dist: isodate>=0.7
@@ -49,6 +34,7 @@ Provides-Extra: server
 Requires-Dist: uvicorn[standard]; extra == "server"
 Provides-Extra: cli
 Requires-Dist: tqdm; extra == "cli"
+Dynamic: license-file
 
 [![image](https://img.shields.io/pypi/v/graphique.svg)](https://pypi.org/project/graphique/)
 ![image](https://img.shields.io/pypi/pyversions/graphique.svg)

{graphique-1.8 → graphique-1.9}/graphique.egg-info/requires.txt

@@ -1,4 +1,4 @@
-pyarrow>=18
+pyarrow>=20
 strawberry-graphql[asgi,cli]>=0.236
 numpy
 isodate>=0.7

{graphique-1.8 → graphique-1.9}/pyproject.toml

@@ -4,22 +4,20 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graphique"
-version = "1.8"
+version = "1.9"
 dynamic = ["dependencies"]
 description = "GraphQL service for arrow tables and parquet data sets."
 readme = "README.md"
-requires-python = ">=3.9"
-license = {file = "LICENSE.txt"}
+requires-python = ">=3.10"
+license = {text = "Apache-2.0"}
 authors = [{name = "Aric Coady", email = "aric.coady@gmail.com"}]
 keywords = ["graphql", "arrow", "parquet"]
 classifiers = [
     "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Developers",
     "Intended Audience :: Science/Research",
-    "License :: OSI Approved :: Apache Software License",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",

{graphique-1.8 → graphique-1.9}/requirements.in

@@ -1,4 +1,4 @@
-pyarrow>=18
+pyarrow>=20
 strawberry-graphql[asgi,cli]>=0.236
 numpy
 isodate>=0.7

{graphique-1.8 → graphique-1.9}/tests/test_core.py

@@ -187,3 +187,5 @@ def test_not_implemented():
         pa.table({'': list('aba')}).group_by([]).aggregate([('', 'first'), ('', 'last')])
     with pytest.raises(ValueError):
         pc.pairwise_diff(pa.chunked_array([[0]]))
+    with pytest.raises(NotImplementedError):
+        pc.rank(pa.table({'': array}), [('', 'ascending')])