graphique 1.4__tar.gz → 1.6__tar.gz

{graphique-1.4 → graphique-1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: graphique
-Version: 1.4
+Version: 1.6
 Summary: GraphQL service for arrow tables and parquet data sets.
 Author-email: Aric Coady <aric.coady@gmail.com>
 License: Copyright 2022 Aric Coady
@@ -40,8 +40,8 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: pyarrow>=14
-Requires-Dist: strawberry-graphql[asgi,cli]>=0.198
+Requires-Dist: pyarrow>=16
+Requires-Dist: strawberry-graphql[asgi,cli]>=0.221
 Provides-Extra: server
 Requires-Dist: uvicorn[standard]; extra == "server"
 Provides-Extra: cli
@@ -54,7 +54,6 @@ Requires-Dist: tqdm; extra == "cli"
 [![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](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/)
 

{graphique-1.4 → graphique-1.6}/README.md

@@ -5,7 +5,6 @@
 [![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](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/)
 

{graphique-1.4 → graphique-1.6}/graphique/__init__.py

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

{graphique-1.4 → graphique-1.6}/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
@@ -14,7 +15,7 @@ import json
 from collections.abc import Callable, Iterable, Iterator, Sequence
 from dataclasses import dataclass
 from typing import Optional, Union, get_type_hints
-import numpy as np  # type: ignore
+import numpy as np
 import pyarrow as pa
 import pyarrow.acero as ac
 import pyarrow.compute as pc
@@ -106,7 +107,10 @@ def register(func: Callable, kind: str = 'scalar') -> pc.Function:
 
 @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()))
@@ -347,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:
@@ -398,10 +402,10 @@ class Table(pa.Table):
                 if the predicate has args, it will be called on the differences
         """
         offsets = pa.chunked_array(
-            Column.run_offsets(self[name], *predicates.get(name, (pc.not_equal,)))
+            Column.run_offsets(self[name], *predicates.get(name, ()))
             for name in names + tuple(predicates)
-        ).unique()
-        offsets = offsets.take(pc.sort_indices(offsets))
+        )
+        offsets = offsets.unique().sort()
         scalars = self.select(names).take(offsets[:-1])
         lists = self.select(set(self.schema.names) - set(names))
         table = Table.union(scalars, Table.from_offsets(lists, offsets))
@@ -419,19 +423,20 @@ class Table(pa.Table):
             self = self.unify_dictionaries()
         prefix = 'hash_' if names else ''
         aggs = [agg.astuple(prefix + func) for func in funcs for agg in funcs[func]]
+        columns = list(names) + [agg[0] for agg in aggs]
         if counts:
             aggs.append(([], 'hash_count_all', None, counts))
-        return Declarations(self).aggregate(aggs, names).to_table()
+        return Declarations(self, columns).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 {}
         for key in ('one', 'list', 'distinct'):  # hash only functions
             func, aggs = getattr(Agg, key), funcs.pop(key, [])
-            row.update({agg.alias: func(self[agg.name], **agg.options) for agg in aggs})
+            row |= {agg.alias: func(self[agg.name], **agg.options) for agg in aggs}
         if funcs:
             table = Table.group(self, **funcs)  # type: ignore
-            row.update({name: table[name][0] for name in table.schema.names})
+            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()
@@ -464,7 +469,7 @@ class Table(pa.Table):
         func = functools.partial(pc.sort_indices, null_placement=null_placement)
         if length is not None and length < len(self):
             func = functools.partial(pc.select_k_unstable, k=length)
-        keys = dict(map(sort_key, names))  # type: ignore
+        keys = dict(map(sort_key, names))
         table = pa.table({name: Column.sort_values(self[name]) for name in keys})
         return func(table, sort_keys=keys.items()) if table else pa.array([], 'int64')
 
@@ -556,7 +561,7 @@ class Table(pa.Table):
             dense: use dense rank; false indicates sorting
         """
         schema = set(Table.fragment_keys(self))
-        keys = dict(itertools.takewhile(lambda key: key[0] in schema, map(sort_key, names)))  # type: ignore
+        keys = dict(itertools.takewhile(lambda key: key[0] in schema, map(sort_key, names)))
         if not keys:
             return None, names
         parts = []
@@ -614,7 +619,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:
@@ -638,10 +643,10 @@ class Declarations(list):
         'hashjoin': ac.HashJoinNodeOptions,
     }
 
-    def __init__(self, source: Union[pa.Table, ds.Dataset]):
+    def __init__(self, source: Union[pa.Table, ds.Dataset], columns=None):
         if isinstance(source, ds.Dataset):
             expr = source._scan_options.get('filter')
-            self.scan(source, filter=expr)
+            self.scan(source, filter=expr, columns=columns)
             if expr is not None:
                 self.filter(expr)
         else:

{graphique-1.4 → graphique-1.6}/graphique/inputs.py

@@ -1,6 +1,7 @@
 """
 GraphQL input types.
 """
+
 import functools
 import inspect
 import operator
@@ -376,11 +377,11 @@ class Expression:
                 fields.append(field)
         for group in operator.attrgetter(*self.groups)(self):
             if group is not UNSET:
-                fields += group.to_fields()  # type: ignore
+                fields += group.to_fields()
         for op in self.unaries:
             expr = getattr(self, op)
             if expr is not UNSET:
-                fields.append(self.getfunc(op)(expr.to_arrow()))  # type: ignore
+                fields.append(self.getfunc(op)(expr.to_arrow()))
         if not fields:
             return None
         if len(fields) > 1:

{graphique-1.4 → graphique-1.6}/graphique/interface.py

@@ -3,6 +3,7 @@ Primary Dataset interface.
 
 Doesn't require knowledge of the schema.
 """
+
 # mypy: disable-error-code=valid-type
 import collections
 import inspect
@@ -14,8 +15,8 @@ import pyarrow as pa
 import pyarrow.compute as pc
 import pyarrow.dataset as ds
 import strawberry.asgi
+from strawberry import Info
 from strawberry.extensions.utils import get_path_from_info
-from strawberry.types import Info
 from typing_extensions import Self
 from .core import Batch, Column as C, ListChunk, Table as T
 from .inputs import CountAggregate, Cumulative, Diff, Expression, Field, Filter
@@ -234,7 +235,11 @@ class Dataset:
         aggregate="aggregation functions applied to other columns",
     )
     def group(
-        self, info: Info, by: list[str] = [], counts: str = '', aggregate: HashAggregates = {}  # type: ignore
+        self,
+        info: Info,
+        by: list[str] = [],
+        counts: str = '',
+        aggregate: HashAggregates = {},  # type: ignore
     ) -> Self:
         """Return table grouped by columns.
 
@@ -277,11 +282,11 @@ class Dataset:
             row = ds.get_partition_keys(fragment.partition_expression)
             if projection:
                 table = fragment.to_table(columns=projection)
-                row.update(T.aggregate(table, counts=counts, **aggs))
+                row |= T.aggregate(table, counts=counts, **aggs)
             elif counts:
                 row[counts] = fragment.count_rows()
             arrays = {name: value for name, value in row.items() if isinstance(value, pa.Array)}
-            row.update(T.columns(pa.RecordBatch.from_pydict(arrays)))
+            row |= T.columns(pa.RecordBatch.from_pydict(arrays))
             for name in row:
                 columns[name].append(row[name])
         for name, values in columns.items():
@@ -289,7 +294,7 @@ class Dataset:
                 columns[name] = C.from_scalars(values)
             elif isinstance(values[0], pa.Array):
                 columns[name] = ListChunk.from_scalars(values)
-        columns.update({field.name: pa.array(columns[field.name], field.type) for field in schema})
+        columns |= {field.name: pa.array(columns[field.name], field.type) for field in schema}
         return self.add_metric(info, pa.table(columns), mode='fragment')
 
     @doc_field(
@@ -482,7 +487,7 @@ class Dataset:
     def project(self, info: Info, columns: list[Projection]) -> dict:
         """Return projected columns, including all references from below fields."""
         projection = {name: pc.field(name) for name in self.references(info, level=1)}
-        projection.update({col.alias or '.'.join(col.name): col.to_arrow() for col in columns})
+        projection |= {col.alias or '.'.join(col.name): col.to_arrow() for col in columns}
         if '' in projection:
             raise ValueError(f"projected columns need a name or alias: {projection['']}")
         return projection
@@ -497,9 +502,7 @@ class Dataset:
         return scanner
 
     @doc_field(filter="selected rows", columns="projected columns")
-    def scan(
-        self, info: Info, filter: Expression = {}, columns: list[Projection] = []  # type: ignore
-    ) -> Self:
+    def scan(self, info: Info, filter: Expression = {}, columns: list[Projection] = []) -> Self:  # type: ignore
         """Select rows and project columns without memory usage."""
         expr = filter.to_arrow()
         if expr is not None and not columns and isinstance(self.table, ds.Dataset):

{graphique-1.4 → graphique-1.6}/graphique/middleware.py

@@ -1,16 +1,17 @@
 """
 ASGI GraphQL utilities.
 """
+
 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 UNSET
+from strawberry import Info, UNSET
 from strawberry.extensions import tracing
 from strawberry.utils.str_converters import to_camel_case
-from strawberry.types import Info
 from .core import Column as C
 from .inputs import Filter
 from .interface import Dataset, Root
@@ -94,7 +95,7 @@ def implemented(root: Root, name: str = '', keys: Iterable = ()):
     """Return type which extends the Dataset interface with knowledge of the schema."""
     schema = root.projected_schema if isinstance(root, ds.Scanner) else root.schema
     types = {field.name: type_map[C.scalar_type(field).id] for field in schema}
-    types = {name: types[name] for name in types if name.isidentifier()}
+    types = {name: types[name] for name in types if name.isidentifier() and not iskeyword(name)}
     if invalid := set(schema.names) - set(types):
         warnings.warn(f'invalid field names: {invalid}')
     prefix = to_camel_case(name.title())

{graphique-1.4 → graphique-1.6}/graphique/models.py

@@ -1,6 +1,7 @@
 """
 GraphQL output types and resolvers.
 """
+
 import collections
 import functools
 import inspect
@@ -12,11 +13,11 @@ from typing import Annotated, Generic, Optional, TypeVar, TYPE_CHECKING, get_arg
 import pyarrow as pa
 import pyarrow.compute as pc
 import strawberry
+from strawberry import Info
 from strawberry.field import StrawberryField
-from strawberry.types import Info
 from .core import Column as C
 from .inputs import links
-from .scalars import Interval, Long, scalar_map, type_map
+from .scalars import Long, scalar_map, type_map
 
 if TYPE_CHECKING:  # pragma: no cover
     from .interface import Dataset
@@ -67,7 +68,7 @@ class Column:
         if cls is Column:
             return lambda cls: cls.register(*scalars) or cls
         # strawberry#1921: scalar python names are prepended to column name
-        generic = cls.__strawberry_definition__.is_generic
+        generic = issubclass(cls, Generic)
         for scalar in scalars:
             cls.registry[scalar] = cls[scalar_map.get(scalar, scalar)] if generic else cls
 
@@ -119,7 +120,7 @@ class Set(Generic[T]):
         return self.array.to_pylist()
 
 
-@Column.register(timedelta, Interval)
+@Column.register(timedelta, pa.MonthDayNano)
 @strawberry.type(name='Column', description="column of elapsed times")
 class NominalColumn(Generic[T], Column):
     values = doc_field(Set.values)
@@ -174,8 +175,7 @@ class OrdinalColumn(NominalColumn[T]):
 
 @Column.register(str)
 @strawberry.type(name='ingColumn', description="column of strings")
-class StringColumn(OrdinalColumn[T]):
-    ...
+class StringColumn(OrdinalColumn[T]): ...
 
 
 @strawberry.type

graphique-1.6/graphique/scalars.py

@@ -0,0 +1,105 @@
+"""
+GraphQL scalars.
+"""
+
+import functools
+import re
+from datetime import date, datetime, time, timedelta
+from decimal import Decimal
+from typing import Union, no_type_check
+import pyarrow as pa
+import strawberry
+
+
+def parse_long(value) -> int:
+    if isinstance(value, int):
+        return value
+    raise TypeError(f"Long cannot represent value: {value}")
+
+
+@no_type_check
+def parse_duration(value: str):
+    months = days = seconds = 0
+    d_val, _, t_val = value.partition('T')
+    parts = re.split(r'(-?\d+\.?\d*)', d_val.lower() + t_val)
+    if parts.pop(0) != 'p':
+        raise ValueError("Duration format must start with `P`")
+    for num, key in zip(parts[::2], parts[1::2]):
+        if n := float(num) if '.' in num else int(num):
+            if key in 'ym':
+                months += n * 12 if key == 'y' else n
+            elif key in 'wd':
+                days += n * 7 if key == 'w' else n
+            elif key in 'HMS':
+                seconds += n * {'H': 3600, 'M': 60, 'S': 1}[key]
+            else:
+                raise ValueError(f"Invalid duration field: {key.upper()}")
+    if months:
+        return pa.MonthDayNano([months, days, int(seconds * 1_000_000_000)])
+    return timedelta(days, seconds)
+
+
+@functools.singledispatch
+def duration_isoformat(td: timedelta) -> str:
+    days = f'{td.days}D' if td.days else ''
+    fraction = f'.{td.microseconds:06}' if td.microseconds else ''
+    return f'P{days}T{td.seconds}{fraction}S'
+
+
+@duration_isoformat.register
+def _(mdn: pa.MonthDayNano) -> str:
+    months = f'{mdn.months}M' if mdn.months else ''
+    days = f'{mdn.days}D' if mdn.days else ''
+    seconds, nanoseconds = divmod(mdn.nanoseconds, 1_000_000_000)
+    fraction = f'.{nanoseconds:09}' if nanoseconds else ''
+    return f'P{months}{days}T{seconds}{fraction}S'
+
+
+Long = strawberry.scalar(int, name='Long', description="64-bit int", parse_value=parse_long)
+Duration = strawberry.scalar(
+    Union[timedelta, pa.MonthDayNano],
+    name='Duration',
+    description="Duration (isoformat)",
+    specified_by_url="https://en.wikipedia.org/wiki/ISO_8601#Durations",
+    serialize=duration_isoformat,
+    parse_value=parse_duration,
+)
+scalar_map = {
+    bytes: strawberry.scalars.Base64,
+    dict: strawberry.scalars.JSON,
+    timedelta: Duration,
+    pa.MonthDayNano: Duration,
+}
+
+type_map = {
+    pa.lib.Type_BOOL: bool,
+    pa.lib.Type_UINT8: int,
+    pa.lib.Type_INT8: int,
+    pa.lib.Type_UINT16: int,
+    pa.lib.Type_INT16: int,
+    pa.lib.Type_UINT32: Long,
+    pa.lib.Type_INT32: int,
+    pa.lib.Type_UINT64: Long,
+    pa.lib.Type_INT64: Long,
+    pa.lib.Type_HALF_FLOAT: float,
+    pa.lib.Type_FLOAT: float,
+    pa.lib.Type_DOUBLE: float,
+    pa.lib.Type_DECIMAL128: Decimal,
+    pa.lib.Type_DECIMAL256: Decimal,
+    pa.lib.Type_DATE32: date,
+    pa.lib.Type_DATE64: date,
+    pa.lib.Type_TIMESTAMP: datetime,
+    pa.lib.Type_TIME32: time,
+    pa.lib.Type_TIME64: time,
+    pa.lib.Type_DURATION: timedelta,
+    pa.lib.Type_INTERVAL_MONTH_DAY_NANO: pa.MonthDayNano,
+    pa.lib.Type_BINARY: bytes,
+    pa.lib.Type_FIXED_SIZE_BINARY: bytes,
+    pa.lib.Type_LARGE_BINARY: bytes,
+    pa.lib.Type_STRING: str,
+    pa.lib.Type_LARGE_STRING: str,
+    pa.lib.Type_LIST: list,
+    pa.lib.Type_FIXED_SIZE_LIST: list,
+    pa.lib.Type_LARGE_LIST: list,
+    pa.lib.Type_STRUCT: dict,
+}

{graphique-1.4 → graphique-1.6}/graphique/service.py

@@ -6,6 +6,7 @@ Copy and customize as needed. Demonstrates:
 * datasets, scanners, and tables
 * filtering and projection
 """
+
 import json
 from pathlib import Path
 import pyarrow.dataset as ds
@@ -13,7 +14,7 @@ from starlette.config import Config
 from graphique.inputs import Expression
 from graphique import GraphQL
 
-config = Config('.env')
+config = Config('.env' if Path('.env').is_file() else None)
 PARQUET_PATH = Path(config('PARQUET_PATH')).resolve()
 FEDERATED = config('FEDERATED', default='')
 DEBUG = config('DEBUG', cast=bool, default=False)

{graphique-1.4 → graphique-1.6}/graphique/shell.py

@@ -8,21 +8,24 @@ Second, the partitioned dataset is rewritten to merge parts. Often the built-in
 sufficient once partitioned, but there is a `fragments` option to optimize for memory or show
 progress on the second pass.
 """
-import argparse
+
 import shutil
 from pathlib import Path
+from typing import Annotated
 import pyarrow.dataset as ds
+import typer  # type: ignore
 from tqdm import tqdm  # type: ignore
 
 
+def sort_key(name: str) -> tuple:
+    """Parse sort order."""
+    return name.lstrip('-'), ('descending' if name.startswith('-') else 'ascending')
+
+
 def write_batches(scanner: ds.Scanner, base_dir: str, *partitioning: str, **options):
     """Partition dataset by batches."""
-    options.update(
-        format=options.get('format', 'parquet'),
-        partitioning=partitioning,
-        partitioning_flavor=options.get('partitioning_flavor', 'hive'),
-        existing_data_behavior='overwrite_or_ignore',
-    )
+    options.update(format='parquet', partitioning=partitioning)
+    options.update(partitioning_flavor='hive', existing_data_behavior='overwrite_or_ignore')
     with tqdm(total=scanner.count_rows(), desc="Batches") as pbar:
         for index, batch in enumerate(scanner.to_batches()):
             options['basename_template'] = f'part-{index}-{{i}}.parquet'
@@ -30,38 +33,37 @@ def write_batches(scanner: ds.Scanner, base_dir: str, *partitioning: str, **opti
             pbar.update(len(batch))
 
 
-def write_fragments(dataset: ds.Dataset, base_dir: str, **options):
+def write_fragments(dataset: ds.Dataset, base_dir: str, sorting=(), **options):
     """Rewrite partition files by fragment to consolidate."""
+    options['format'] = 'parquet'
     exprs = {Path(frag.path).parent: frag.partition_expression for frag in dataset.get_fragments()}
     offset = len(dataset.partitioning.schema)
     for path in tqdm(exprs, desc="Fragments"):
         part_dir = Path(base_dir, *path.parts[-offset:])
-        ds.write_dataset(dataset.filter(exprs[path]), part_dir, **options)
+        part = dataset.filter(exprs[path])
+        ds.write_dataset(part.sort_by(sorting) if sorting else part, part_dir, **options)
 
 
 def partition(
-    scanner: ds.Scanner, base_dir: str, *partitioning: str, fragments: bool = False, **options
+    src: Annotated[str, typer.Argument(help="source path")],
+    dest: Annotated[str, typer.Argument(help="destination path")],
+    partitioning: Annotated[list[str], typer.Argument(help="partition keys")],
+    fragments: Annotated[bool, typer.Option(help="iterate over fragments")] = False,
+    sort: Annotated[list[str], typer.Option(help="sort keys; will load fragments")] = [],
 ):
     """Partition dataset by keys."""
-    temp = Path(base_dir) / 'temp'
-    write_batches(scanner, str(temp), *partitioning)
+    temp = Path(dest) / 'temp'
+    write_batches(ds.dataset(src, partitioning='hive'), str(temp), *partitioning)
     dataset = ds.dataset(temp, partitioning='hive')
-    if fragments:
-        write_fragments(dataset, base_dir, **options)
+    options = dict(partitioning_flavor='hive', existing_data_behavior='overwrite_or_ignore')
+    if fragments or sort:
+        write_fragments(dataset, dest, tuple(map(sort_key, sort)))
     else:
-        options.update(partitioning_flavor='hive', existing_data_behavior='overwrite_or_ignore')
         with tqdm(desc="Partitions"):
-            ds.write_dataset(dataset, base_dir, partitioning=partitioning, **options)
+            ds.write_dataset(dataset, dest, partitioning=partitioning, **options)
     shutil.rmtree(temp)
 
 
-parser = argparse.ArgumentParser(description=__doc__)
-parser.add_argument('src', help="source path")
-parser.add_argument('dest', help="destination path")
-parser.add_argument('partitioning', nargs='+', help="partition keys")
-parser.add_argument('--fragments', action='store_true', help="iterate over fragments")
-
 if __name__ == '__main__':
-    args = parser.parse_args()
-    dataset = ds.dataset(args.src, partitioning='hive')
-    partition(dataset, args.dest, *args.partitioning, fragments=args.fragments)
+    partition.__doc__ = __doc__
+    typer.run(partition)

{graphique-1.4 → graphique-1.6}/graphique.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: graphique
-Version: 1.4
+Version: 1.6
 Summary: GraphQL service for arrow tables and parquet data sets.
 Author-email: Aric Coady <aric.coady@gmail.com>
 License: Copyright 2022 Aric Coady
@@ -40,8 +40,8 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: pyarrow>=14
-Requires-Dist: strawberry-graphql[asgi,cli]>=0.198
+Requires-Dist: pyarrow>=16
+Requires-Dist: strawberry-graphql[asgi,cli]>=0.221
 Provides-Extra: server
 Requires-Dist: uvicorn[standard]; extra == "server"
 Provides-Extra: cli
@@ -54,7 +54,6 @@ Requires-Dist: tqdm; extra == "cli"
 [![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](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/)
 

{graphique-1.4 → graphique-1.6}/graphique.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 LICENSE.txt
 README.md
 pyproject.toml
+requirements.in
 graphique/__init__.py
 graphique/core.py
 graphique/inputs.py

graphique-1.6/graphique.egg-info/requires.txt

@@ -0,0 +1,8 @@
+pyarrow>=16
+strawberry-graphql[asgi,cli]>=0.221
+
+[cli]
+tqdm
+
+[server]
+uvicorn[standard]

{graphique-1.4 → graphique-1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graphique"
-dynamic = ["version"]
+dynamic = ["version", "dependencies"]
 description = "GraphQL service for arrow tables and parquet data sets."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -28,7 +28,6 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
     "Typing :: Typed",
 ]
-dependencies = ["pyarrow>=14", "strawberry-graphql[asgi,cli]>=0.198"]
 
 [project.urls]
 Homepage = "https://github.com/coady/graphique"
@@ -45,19 +44,21 @@ packages = ["graphique"]
 
 [tool.setuptools.dynamic]
 version = {attr = "graphique.__version__"}
+dependencies = {file = "requirements.in"}
 
 [tool.setuptools.package-data]
 graphique = ["py.typed"]
 
-[tool.black]
+[tool.ruff]
 line-length = 100
-skip-string-normalization = true
+extend-include = ["*.ipynb"]
 
-[tool.ruff]
-ignore = ["E501"]
+[tool.ruff.format]
+preview = true
+quote-style = "preserve"
 
 [[tool.mypy.overrides]]
-module = ["pyarrow.*", "strawberry.*", "starlette.*"]
+module = ["numpy.*", "pyarrow.*", "strawberry.*", "starlette.*"]
 ignore_missing_imports = true
 
 [tool.coverage.run]

graphique-1.6/requirements.in

@@ -0,0 +1,2 @@
+pyarrow>=16
+strawberry-graphql[asgi,cli]>=0.221

{graphique-1.4 → graphique-1.6}/tests/test_core.py

@@ -2,6 +2,24 @@ import pyarrow as pa
 import pyarrow.compute as pc
 import pytest
 from graphique.core import Agg, ListChunk, Column as C, Table as T
+from graphique.scalars import parse_duration, duration_isoformat
+
+
+def test_duration():
+    assert duration_isoformat(parse_duration('P1Y1M1DT1H1M1.1S')) == 'P13M1DT3661.100000000S'
+    assert duration_isoformat(parse_duration('P1M1DT1H1M1.1S')) == 'P1M1DT3661.100000000S'
+    assert duration_isoformat(parse_duration('P1DT1H1M1.1S')) == 'P1DT3661.100000S'
+    assert duration_isoformat(parse_duration('PT1H1M1.1S')) == 'PT3661.100000S'
+    assert duration_isoformat(parse_duration('PT1M1.1S')) == 'PT61.100000S'
+    assert duration_isoformat(parse_duration('PT1.1S')) == 'PT1.100000S'
+    assert duration_isoformat(parse_duration('PT1S')) == 'PT1S'
+    assert duration_isoformat(parse_duration('P0D')) == 'PT0S'
+    assert duration_isoformat(parse_duration('PT0S')) == 'PT0S'
+    assert duration_isoformat(parse_duration('P-1DT-1H')) == 'P-2DT82800S'
+    with pytest.raises(ValueError):
+        duration_isoformat(parse_duration('T1H'))
+    with pytest.raises(ValueError):
+        duration_isoformat(parse_duration('P1H'))
 
 
 def test_dictionary(table):