graphique 1.4__tar.gz → 1.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: graphique
-Version: 1.4
+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
@@ -40,7 +40,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: pyarrow>=14
+Requires-Dist: pyarrow>=15
 Requires-Dist: strawberry-graphql[asgi,cli]>=0.198
 Provides-Extra: server
 Requires-Dist: uvicorn[standard]; extra == "server"
@@ -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.5}/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.5}/graphique/__init__.py

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

{graphique-1.4 → 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
@@ -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:
@@ -428,10 +432,10 @@ class Table(pa.Table):
         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()
@@ -614,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:

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

@@ -1,6 +1,7 @@
 """
 GraphQL input types.
 """
+
 import functools
 import inspect
 import operator

{graphique-1.4 → graphique-1.5}/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
@@ -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.5}/graphique/middleware.py

@@ -1,9 +1,11 @@
 """
 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
@@ -94,7 +96,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.5}/graphique/models.py

@@ -1,6 +1,7 @@
 """
 GraphQL output types and resolvers.
 """
+
 import collections
 import functools
 import inspect
@@ -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
 
@@ -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.4 → graphique-1.5}/graphique/scalars.py

@@ -1,6 +1,7 @@
 """
 GraphQL scalars.
 """
+
 from datetime import date, datetime, time, timedelta
 from decimal import Decimal
 import pyarrow as pa

{graphique-1.4 → graphique-1.5}/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.5}/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 collections.abc import Iterable
 from pathlib import Path
 import pyarrow.dataset as ds
 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,24 +33,31 @@ 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
+    scanner: ds.Scanner,
+    base_dir: str,
+    *partitioning: str,
+    fragments: bool = False,
+    sort: Iterable[str] = (),
+    **options,
 ):
     """Partition dataset by keys."""
     temp = Path(base_dir) / 'temp'
     write_batches(scanner, str(temp), *partitioning)
     dataset = ds.dataset(temp, partitioning='hive')
-    if fragments:
-        write_fragments(dataset, base_dir, **options)
+    if fragments or sort:
+        write_fragments(dataset, base_dir, tuple(map(sort_key, sort)), **options)
     else:
         options.update(partitioning_flavor='hive', existing_data_behavior='overwrite_or_ignore')
         with tqdm(desc="Partitions"):
@@ -60,8 +70,9 @@ 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")
+parser.add_argument('--sort', nargs='*', default=(), help="sort keys; will load 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(dataset, args.dest, *args.partitioning, fragments=args.fragments, sort=args.sort)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: graphique
-Version: 1.4
+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
@@ -40,7 +40,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: pyarrow>=14
+Requires-Dist: pyarrow>=15
 Requires-Dist: strawberry-graphql[asgi,cli]>=0.198
 Provides-Extra: server
 Requires-Dist: uvicorn[standard]; extra == "server"
@@ -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.5}/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.4 → graphique-1.5}/graphique.egg-info/requires.txt

@@ -1,4 +1,4 @@
-pyarrow>=14
+pyarrow>=15
 strawberry-graphql[asgi,cli]>=0.198
 
 [cli]

{graphique-1.4 → graphique-1.5}/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,16 +44,18 @@ 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.*"]

graphique-1.5/requirements.in

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

{graphique-1.4 → graphique-1.5}/tests/test_dataset.py

@@ -39,20 +39,14 @@ def test_search(dsclient):
     assert data == {'filter': {'length': 41700}}
     data = dsclient.execute('{ filter(zipcode: {}) { row { zipcode } } }')
     assert data == {'filter': {'row': {'zipcode': 501}}}
-    data = dsclient.execute(
-        '''{ filter(zipcode: {gt: 90000}) { filter(state: {eq: "CA"}) {
-        length } } }'''
-    )
+    data = dsclient.execute("""{ filter(zipcode: {gt: 90000}) { filter(state: {eq: "CA"}) {
+        length } } }""")
     assert data == {'filter': {'filter': {'length': 2647}}}
-    data = dsclient.execute(
-        '''{ filter(zipcode: {gt: 90000}) { filter(state: {eq: "CA"}) {
-        length row { zipcode } } } }'''
-    )
+    data = dsclient.execute("""{ filter(zipcode: {gt: 90000}) { filter(state: {eq: "CA"}) {
+        length row { zipcode } } } }""")
     assert data == {'filter': {'filter': {'length': 2647, 'row': {'zipcode': 90001}}}}
-    data = dsclient.execute(
-        '''{ filter(zipcode: {lt: 90000}) { filter(state: {eq: "CA"}) {
-        group(by: "county") { length } } } }'''
-    )
+    data = dsclient.execute("""{ filter(zipcode: {lt: 90000}) { filter(state: {eq: "CA"}) {
+        group(by: "county") { length } } } }""")
     assert data == {'filter': {'filter': {'group': {'length': 0}}}}
 
 
@@ -75,13 +69,11 @@ def test_slice(dsclient):
 
 def test_group(dsclient):
     data = dsclient.execute(
-        '''{ group(by: ["state"], aggregate: {min: {name: "county"}}) { row { state county } } }'''
+        """{ group(by: ["state"], aggregate: {min: {name: "county"}}) { row { state county } } }"""
     )
     assert data == {'group': {'row': {'state': 'NY', 'county': 'Albany'}}}
-    data = dsclient.execute(
-        '''{ group(by: ["state"], counts: "c") { slice(length: 1) {
-        column(name: "c") { ... on LongColumn { values } } } } }'''
-    )
+    data = dsclient.execute("""{ group(by: ["state"], counts: "c") { slice(length: 1) {
+        column(name: "c") { ... on LongColumn { values } } } } }""")
     assert data == {'group': {'slice': {'column': {'values': [2205]}}}}
     data = dsclient.execute(
         '{ group(by: ["state"], aggregate: {first: {name: "county"}}) { row { county } } }'
@@ -92,37 +84,31 @@ def test_group(dsclient):
     )
     assert data['group']['row']['county']
     data = dsclient.execute(
-        '''{ group(by: ["state"], aggregate: {mean: {name: "zipcode"}}) { slice(length: 1) {
-        column(name: "zipcode") { ... on FloatColumn { values } } } } }'''
-    )
+        """{ group(by: ["state"], aggregate: {mean: {name: "zipcode"}}) { slice(length: 1) {
+        column(name: "zipcode") { ... on FloatColumn { values } } } } }""")
     assert data == {'group': {'slice': {'column': {'values': [pytest.approx(12614.62721)]}}}}
     data = dsclient.execute(
-        '''{ group(by: ["state"], aggregate: {list: {name: "zipcode"}}) { aggregate(mean: {name: "zipcode"}) {
-        slice(length: 1) { column(name: "zipcode") { ... on FloatColumn { values } } } } } }'''
-    )
+        """{ group(by: ["state"], aggregate: {list: {name: "zipcode"}}) { aggregate(mean: {name: "zipcode"}) {
+        slice(length: 1) { column(name: "zipcode") { ... on FloatColumn { values } } } } } }""")
     assert data == {
         'group': {'aggregate': {'slice': {'column': {'values': [pytest.approx(12614.62721)]}}}}
     }
-    data = dsclient.execute(
-        '''{ group(aggregate: {min: {alias: "st", name: "state"}}) {
-        column(name: "st") { ... on StringColumn { values } } } }'''
-    )
+    data = dsclient.execute("""{ group(aggregate: {min: {alias: "st", name: "state"}}) {
+        column(name: "st") { ... on StringColumn { values } } } }""")
     assert data == {'group': {'column': {'values': ['AK']}}}
 
 
 def test_list(partclient):
     data = partclient.execute(
-        '''{ group(by: "state", aggregate: {distinct: {alias: "counties", name: "county"}}) {
-        tables { row { state } column(name: "counties") { length } } } } '''
-    )
+        """{ group(by: "state", aggregate: {distinct: {alias: "counties", name: "county"}}) {
+        tables { row { state } column(name: "counties") { length } } } } """)
     (table,) = [table for table in data['group']['tables'] if table['row']['state'] == 'PR']
     assert table == {'row': {'state': 'PR'}, 'column': {'length': 78}}
-    data = partclient.execute(
-        '''{ group(by: "north", aggregate: {distinct: {name: "west"}}) {
-        tables { row { north } columns { west { length } } } } }'''
-    )
-    table = data['group']['tables'][0]
-    assert table == {'row': {'north': 0}, 'columns': {'west': {'length': 2}}}
+    data = partclient.execute("""{ group(by: "north", aggregate: {distinct: {name: "west"}}) {
+        tables { row { north } columns { west { length } } } } }""")
+    tables = data['group']['tables']
+    assert {table['row']['north'] for table in tables} == {0, 1}
+    assert [table['columns'] for table in tables] == [{'west': {'length': 2}}] * 2
 
 
 def test_fragments(partclient):
@@ -146,14 +132,11 @@ def test_fragments(partclient):
     )
     assert data == {'group': {'length': 1, 'row': {'state': 'AK'}}}
     data = partclient.execute(
-        '''{ group(by: ["north", "west"], aggregate: {distinct: {name: "city"}, mean: {name: "zipcode"}}) {
-        length column(name: "city") { type } } }'''
-    )
+        """{ group(by: ["north", "west"], aggregate: {distinct: {name: "city"}, mean: {name: "zipcode"}}) {
+        length column(name: "city") { type } } }""")
     assert data == {'group': {'length': 4, 'column': {'type': 'large_list<item: string>'}}}
-    data = partclient.execute(
-        '''{ group(by: "north", aggregate: {countDistinct: {name: "west"}}) { 
-        column(name: "west") { ... on LongColumn { values } } } }'''
-    )
+    data = partclient.execute("""{ group(by: "north", aggregate: {countDistinct: {name: "west"}}) { 
+        column(name: "west") { ... on LongColumn { values } } } }""")
     assert data == {'group': {'column': {'values': [2, 2]}}}
     data = partclient.execute(
         '{ group(by: "north", counts: "c") { column(name: "c") { ... on LongColumn { values } } } }'
@@ -202,16 +185,12 @@ def test_scan(dsclient):
         dsclient.execute('{ scan(filter: {name: "state", value: "CA"}) { length } }')
     with pytest.raises(ValueError, match="name or alias"):
         dsclient.execute('{ scan(columns: {}) { length } }')
-    data = dsclient.execute(
-        '''{ scan(filter: {eq: [{name: "state"}, {value: "CA"}]})
+    data = dsclient.execute("""{ scan(filter: {eq: [{name: "state"}, {value: "CA"}]})
         { scan(filter: {eq: [{name: "county"}, {value: "Santa Clara"}]})
-        { length row { county } } } }'''
-    )
+        { length row { county } } } }""")
     assert data == {'scan': {'scan': {'length': 108, 'row': {'county': 'Santa Clara'}}}}
-    data = dsclient.execute(
-        '''{ scan(filter: {or: [{eq: [{name: "state"}, {value: "CA"}]},
-        {eq: [{name: "county"}, {value: "Santa Clara"}]}]}) { length } }'''
-    )
+    data = dsclient.execute("""{ scan(filter: {or: [{eq: [{name: "state"}, {value: "CA"}]},
+        {eq: [{name: "county"}, {value: "Santa Clara"}]}]}) { length } }""")
     assert data == {'scan': {'length': 2647}}
 
 
@@ -254,32 +233,26 @@ def test_federation(fedclient):
     assert data['zipcodes'] == {'__typename': 'ZipcodesTable', 'length': 41700}
     assert data['zipDb'] == {'__typename': 'ZipDbTable', 'length': 42724}
 
-    data = fedclient.execute(
-        '''{ zipcodes { scan(columns: {name: "zipcode", cast: "int64"}) {
-        join(right: "zip_db", keys: "zipcode", rightKeys: "zip") { length schema { names } } } } }'''
-    )
+    data = fedclient.execute("""{ zipcodes { scan(columns: {name: "zipcode", cast: "int64"}) {
+        join(right: "zip_db", keys: "zipcode", rightKeys: "zip") { length schema { names } } } } }""")
     table = data['zipcodes']['scan']['join']
     assert table['length'] == 41700
     assert set(table['schema']['names']) > {'zipcode', 'timezone', 'latitude'}
     data = fedclient.execute(
-        '''{ zipcodes { scan(columns: {alias: "zip", name: "zipcode", cast: "int64"}) {
-        join(right: "zip_db", keys: "zip", joinType: "right outer") { length schema { names } } } } }'''
-    )
+        """{ zipcodes { scan(columns: {alias: "zip", name: "zipcode", cast: "int64"}) {
+        join(right: "zip_db", keys: "zip", joinType: "right outer") { length schema { names } } } } }""")
     table = data['zipcodes']['scan']['join']
     assert table['length'] == 42724
     assert set(table['schema']['names']) > {'zip', 'timezone', 'latitude'}
 
     data = fedclient.execute(
-        '''{ _entities(representations: {__typename: "ZipcodesTable", zipcode: 90001}) {
-        ... on ZipcodesTable { length row { state } schema { names } } } }'''
-    )
+        """{ _entities(representations: {__typename: "ZipcodesTable", zipcode: 90001}) {
+        ... on ZipcodesTable { length row { state } schema { names } } } }""")
     assert data == {
         '_entities': [{'length': 1, 'row': {'state': 'CA'}, 'schema': {'names': ['state']}}]
     }
-    data = fedclient.execute(
-        '''{ states { filter(state: {eq: "CA"}) { columns { indices {
-        takeFrom(field: "zipcodes") { __typename column(name: "state") { length } } } } } } }'''
-    )
+    data = fedclient.execute("""{ states { filter(state: {eq: "CA"}) { columns { indices {
+        takeFrom(field: "zipcodes") { __typename column(name: "state") { length } } } } } } }""")
     table = data['states']['filter']['columns']['indices']['takeFrom']
     assert table == {'__typename': 'ZipcodesTable', 'column': {'length': 2647}}