graphique 2.0.1__tar.gz → 2.0.2__tar.gz

{graphique-2.0.1 → graphique-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphique
-Version: 2.0.1
+Version: 2.0.2
 Summary: GraphQL service for python dataframes and parquet datasets.
 Author-email: Aric Coady <aric.coady@gmail.com>
 License-Expression: Apache-2.0
@@ -14,7 +14,6 @@ Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
@@ -24,11 +23,11 @@ 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.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: pyarrow>=20
-Requires-Dist: strawberry-graphql[asgi,cli]>=0.285
+Requires-Dist: strawberry-graphql[asgi,cli]>=0.288
 Requires-Dist: ibis-framework>=10.7
 Requires-Dist: pyarrow-hotfix
 Requires-Dist: isodate>=0.7
@@ -47,7 +46,7 @@ Dynamic: license-file
 [![image](https://codecov.io/gh/coady/graphique/branch/main/graph/badge.svg)](https://codecov.io/gh/coady/graphique/)
 [![CodeQL](https://github.com/coady/graphique/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/coady/graphique/actions/workflows/github-code-scanning/codeql)
 [![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/)
+[![ty](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ty/main/assets/badge/v0.json)](https://github.com/astral-sh/ty)
 
 [GraphQL](https://graphql.org) service for [ibis](https://ibis-project.org) dataframes, [arrow](https://arrow.apache.org) tables, and [parquet](https://parquet.apache.org) datasets. The schema for a query API is derived automatically.
 

{graphique-2.0.1 → graphique-2.0.2}/README.md

@@ -6,7 +6,7 @@
 [![image](https://codecov.io/gh/coady/graphique/branch/main/graph/badge.svg)](https://codecov.io/gh/coady/graphique/)
 [![CodeQL](https://github.com/coady/graphique/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/coady/graphique/actions/workflows/github-code-scanning/codeql)
 [![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/)
+[![ty](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ty/main/assets/badge/v0.json)](https://github.com/astral-sh/ty)
 
 [GraphQL](https://graphql.org) service for [ibis](https://ibis-project.org) dataframes, [arrow](https://arrow.apache.org) tables, and [parquet](https://parquet.apache.org) datasets. The schema for a query API is derived automatically.
 

{graphique-2.0.1 → graphique-2.0.2}/graphique/core.py

@@ -22,9 +22,9 @@ def getitems(obj, *keys):
     return obj
 
 
-def order_key(name: str) -> ibis.Deferred:
+def order_key(name: str) -> ibis.Value:
     """Parse sort order."""
-    return (ibis.desc if name.startswith('-') else ibis.asc)(ibis._[name.lstrip('-')])
+    return (ibis.desc if name.startswith("-") else ibis.asc)(ibis._[name.lstrip("-")])
 
 
 class Parquet(ds.Dataset):
@@ -32,24 +32,24 @@ class Parquet(ds.Dataset):
 
     def schema(self) -> pa.Schema:
         """partition schema"""
-        return self.partitioning.schema if hasattr(self, 'partitioning') else pa.schema([])
+        return self.partitioning.schema if hasattr(self, "partitioning") else pa.schema([])
 
     def keys(self, *names) -> list:
         """Return prefix of matching partition keys."""
         keys = set(Parquet.schema(self).names)
-        return list(itertools.takewhile(lambda name: name.lstrip('-') in keys, names))
+        return list(itertools.takewhile(lambda name: name.lstrip("-") in keys, names))
 
-    def fragments(self, counts: str = '') -> ibis.Table:
+    def fragments(self, counts: str = "") -> ibis.Table:
         """Return partition fragments as a table."""
         parts = []
-        for frag in self._get_fragments(self._scan_options.get('filter')):
+        for frag in self._get_fragments(self._scan_options.get("filter")):
             parts.append(ds.get_partition_keys(frag.partition_expression))
-            parts[-1]['__path__'] = frag.path
+            parts[-1]["__path__"] = frag.path
             if counts:
                 parts[-1][counts] = frag.count_rows()
         return ibis.memtable(pa.Table.from_pylist(parts))
 
-    def group(self, *names, counts: str = '') -> ibis.Table:
+    def group(self, *names, counts: str = "") -> ibis.Table:
         """Return grouped partitions as a table."""
         table = Parquet.fragments(self, counts)
         agg = {counts: table[counts].sum()} if counts else {}
@@ -65,19 +65,19 @@ class Parquet(ds.Dataset):
 
     def to_table(self) -> ibis.Table:
         """Return ibis `Table` from filtered dataset."""
-        paths = [frag.path for frag in self._get_fragments(self._scan_options.get('filter'))]
+        paths = [frag.path for frag in self._get_fragments(self._scan_options.get("filter"))]
         hive = isinstance(self.partitioning, ds.HivePartitioning)
         return ibis.read_parquet(paths, hive_partitioning=hive)
 
     def rank(self, limit: int, *names: str, dense: bool = False) -> ibis.Table:
         """Return ordered limited partitions as a table."""
-        keys = {name.strip('-'): order_key(name) for name in names}
-        table = Parquet.fragments(self, counts='_').order_by(*keys.values()).cache()
-        groups = table.aggregate(count=ibis._.count(), total=table['_'].sum(), by=list(keys))
+        keys = {name.strip("-"): order_key(name) for name in names}
+        table = Parquet.fragments(self, counts="_").order_by(*keys.values()).cache()
+        groups = table.aggregate(count=ibis._.count(), total=table["_"].sum(), by=list(keys))
         groups = groups.order_by(*keys.values()).cache()
         if not dense:
-            totals = itertools.accumulate(groups['total'].to_list())
-            limit = next((index for index, total in enumerate(totals, 1) if total >= limit), None)  # type: ignore
-        limit = groups[:limit]['count'].sum().to_pyarrow().as_py()
+            totals = itertools.accumulate(groups["total"].to_list())
+            limit = next((index for index, total in enumerate(totals, 1) if total >= limit), None)
+        limit = groups[:limit]["count"].sum().to_pyarrow().as_py()
         hive = isinstance(self.partitioning, ds.HivePartitioning)
-        return ibis.read_parquet(table[:limit]['__path__'].to_list(), hive_partitioning=hive)
+        return ibis.read_parquet(table[:limit]["__path__"].to_list(), hive_partitioning=hive)

{graphique-2.0.1 → graphique-2.0.2}/graphique/inputs.py

@@ -7,8 +7,8 @@ from __future__ import annotations
 import functools
 import inspect
 import operator
-from collections.abc import Callable, Iterable
-from datetime import date, datetime, time, timedelta
+from collections.abc import Callable, Iterable, Iterator
+from datetime import date, datetime, time
 from decimal import Decimal
 from typing import Generic, TypeVar
 
@@ -25,8 +25,9 @@ from strawberry.types.arguments import StrawberryArgument
 from strawberry.types.field import StrawberryField
 
 from .core import getitems, links, order_key
+from .scalars import Duration
 
-T = TypeVar('T')
+T = TypeVar("T")
 
 
 def use_doc(decorator: Callable, **kwargs):
@@ -53,9 +54,9 @@ def default_field(
 ) -> StrawberryField:
     """Use dataclass `default_factory` for `UNSET` or mutables."""
     if func is not None:
-        kwargs['description'] = inspect.getdoc(func).splitlines()[0]  # type: ignore
+        kwargs["description"] = inspect.getdoc(func).splitlines()[0]
     if not nullable and default is UNSET:
-        kwargs.setdefault('directives', []).append(optional())
+        kwargs.setdefault("directives", []).append(optional())
     return strawberry.field(default_factory=type(default), **kwargs)
 
 
@@ -74,7 +75,7 @@ class Filter(Generic[T]):
     gt: T | None = default_field(description=r"\>")
     ge: T | None = default_field(description=r"\>=")
 
-    def __iter__(self) -> Iterable[tuple]:
+    def __iter__(self) -> Iterator[tuple]:
         for name, value in self.__dict__.items():
             if value is not UNSET:
                 yield name, value
@@ -87,18 +88,18 @@ class Filter(Generic[T]):
             if types[name] not in (list, dict):
                 yield StrawberryArgument(name, name, annotation, default={})
         annotation = StrawberryAnnotation(Expression | None)
-        yield StrawberryArgument('where', None, annotation, default=None)
+        yield StrawberryArgument("where", None, annotation, default=None)
 
     @staticmethod
     def to_exprs(**queries: Filter) -> Iterable[ibis.Deferred]:
         """Transform query syntax into ibis expressions."""
         for name, query in queries.items():
             field = ibis._[name]
-            for op, value in query:  # type: ignore
+            for op, value in query:
                 match value, op:
-                    case list(), 'eq':
+                    case list(), "eq":
                         yield field.isin(value)
-                    case list(), 'ne':
+                    case list(), "ne":
                         yield field.notin(value)
                     case _:
                         yield getattr(operator, op)(field, value)
@@ -109,10 +110,10 @@ class Filter(Generic[T]):
         exprs = []
         for name, query in queries.items():
             field = pc.field(name)
-            for op, value in dict(query).items():  # type: ignore
+            for op, value in dict(query).items():
                 if isinstance(value, list):
                     expr = pc.is_in(field, pa.array(value))
-                    exprs.append(pc.invert(expr) if op == 'ne' else expr)
+                    exprs.append(pc.invert(expr) if op == "ne" else expr)
                 else:
                     exprs.append(getattr(operator, op)(field, value))
         return functools.reduce(operator.and_, exprs or [None])
@@ -121,11 +122,11 @@ class Filter(Generic[T]):
 @strawberry.input(description="name and optional alias for aggregation")
 class Aggregate:
     name: str = strawberry.field(description="column name")
-    alias: str = strawberry.field(default='', description="output column name")
+    alias: str = strawberry.field(default="", description="output column name")
     where: Expression | None = None
 
     def to_ibis(self, func: str, **options) -> tuple:
-        options['where'] = self.where and self.where.to_ibis()
+        options["where"] = self.where and self.where.to_ibis()
         return (self.alias or self.name), getattr(ibis._[self.name], func)(**options)
 
 
@@ -133,8 +134,8 @@ class Aggregate:
 class UniqueAggregate(Aggregate):
     approx: bool = False
 
-    def to_ibis(self, func: str, **options) -> tuple:  # type: ignore
-        return super().to_ibis('approx_' + func if self.approx else func, **options)
+    def to_ibis(self, func: str, **options) -> tuple:
+        return super().to_ibis("approx_" + func if self.approx else func, **options)
 
 
 @strawberry.input
@@ -152,9 +153,9 @@ class OrderAggregate(Aggregate):
 
 @strawberry.input
 class VarAggregate(Aggregate):
-    how: str = 'sample'
+    how: str = "sample"
 
-    def to_ibis(self, func: str) -> tuple:  # type: ignore
+    def to_ibis(self, func: str, **_) -> tuple:
         return super().to_ibis(func, how=self.how)
 
 
@@ -162,7 +163,7 @@ class VarAggregate(Aggregate):
 class QuantileAggregate(UniqueAggregate):
     q: float = 0.5
 
-    def to_ibis(self, func: str) -> tuple:  # type: ignore
+    def to_ibis(self, func: str, **_) -> tuple:
         return super().to_ibis(func, quantile=self.q)
 
 
@@ -170,7 +171,7 @@ class QuantileAggregate(UniqueAggregate):
 class CollectAggregate(OrderAggregate):
     distinct: bool = False
 
-    def to_ibis(self, func: str) -> tuple:  # type: ignore
+    def to_ibis(self, func: str, **_) -> tuple:
         return super().to_ibis(func, distinct=self.distinct)
 
 
@@ -199,11 +200,11 @@ class Aggregates:
 
 @strawberry.input(description="typed scalars")
 class Scalars:
-    base64: bytes | None = default_field(description="binary scalar")
+    base64: strawberry.scalars.Base64 | None = default_field(description="binary scalar")
     date: date | None = default_field(description="date scalar")
     datetime: datetime | None = default_field(description="datetime scalar")
     decimal: Decimal | None = default_field(description="decimal scalar")
-    duration: timedelta | None = default_field(description="duration scalar")
+    duration: Duration | None = default_field(description="duration scalar")
     time: time | None = default_field(description="time scalar")
 
     def __iter__(self):
@@ -229,14 +230,14 @@ class Expression:
     notin: list[Expression] = default_field([], func=ibis.Column.notin)
 
     inv: Expression | None = default_field(description="~")
-    and_: list[Expression] = default_field([], name='and', description="&")
-    or_: list[Expression] = default_field([], name='or', description="|")
+    and_: list[Expression] = default_field([], name="and", description="&")
+    or_: list[Expression] = default_field([], name="or", description="|")
     xor: list[Expression] = default_field([], description="^")
 
     add: list[Expression] = default_field([], description="+")
     sub: list[Expression] = default_field([], description="-")
     mul: list[Expression] = default_field([], description="*")
-    truediv: list[Expression] = default_field([], name='div', description="/")
+    truediv: list[Expression] = default_field([], name="div", description="/")
 
     coalesce: list[Expression] = default_field([], func=ibis.Column.coalesce)
     cume_dist: Expression | None = default_field(func=ibis.Column.cume_dist)
@@ -271,18 +272,18 @@ class Expression:
             yield ibis.row_number()
         for name, (expr, *args) in self.items():
             match name:
-                case 'eq' | 'ne' | 'lt' | 'le' | 'gt' | 'ge' | 'inv' | 'and_' | 'or_' | 'xor':
+                case "eq" | "ne" | "lt" | "le" | "gt" | "ge" | "inv" | "and_" | "or_" | "xor":
                     yield getattr(operator, name)(expr, *args)
-                case 'add' | 'sub' | 'mul' | 'truediv':
+                case "add" | "sub" | "mul" | "truediv":
                     yield getattr(operator, name)(expr, *args)
                 case _:
                     yield getattr(expr, name)(*args)
         for field in (self.array, self.numeric, self.string, self.temporal, self.window):
             if field:
-                yield from field  # type: ignore
+                yield from field
 
     def to_ibis(self) -> ibis.Deferred | None:
-        fields = list(self) or [None]  # type: ignore
+        fields = list(self) or [None]
         if len(fields) == 1:
             return fields[0]
         raise ValueError(f"conflicting inputs: {', '.join(map(str, fields))}")
@@ -290,10 +291,10 @@ class Expression:
 
 @strawberry.input(description="an `Expression` with an optional alias")
 class Projection(Expression):
-    alias: str = strawberry.field(default='', description="name of projected column")
+    alias: str = strawberry.field(default="", description="name of projected column")
 
-    def to_ibis(self) -> tuple:
-        name = self.alias or '.'.join(self.name)
+    def to_ibis(self) -> tuple:  # type: ignore
+        name = self.alias or ".".join(self.name)
         if name:
             return name, super().to_ibis()
         raise ValueError(f"projected fields require a name or alias: {self}")
@@ -319,12 +320,12 @@ class Arrays:
     offset: int = 0
     limit: int | None = None
 
-    def __iter__(self) -> Iterable[ibis.Deferred]:
-        for name, (expr, *args) in Expression.items(self):  # type: ignore
+    def __iter__(self) -> Iterator[ibis.Deferred]:
+        for name, (expr, *args) in Expression.items(self):
             match name:
-                case 'slice':
+                case "slice":
                     yield expr[self.offset :][: self.limit]
-                case 'value':
+                case "value":
                     yield expr[self.offset]
                 case _:
                     yield getattr(expr, name)(*args)
@@ -356,15 +357,15 @@ class Numeric:
     cumsum: Expression | None = default_field(func=ibis.expr.types.NumericColumn.cumsum)
 
     buckets: list[JSON] = default_field([])
-    closed: str = 'left'
+    closed: str = "left"
     close_extreme: bool = True
     include_under: bool = False
     include_over: bool = False
 
-    def __iter__(self) -> Iterable[ibis.Deferred]:
-        for name, (expr, *args) in Expression.items(self):  # type: ignore
+    def __iter__(self) -> Iterator[ibis.Deferred]:
+        for name, (expr, *args) in Expression.items(self):
             match name:
-                case 'bucket':
+                case "bucket":
                     yield expr.bucket(
                         self.buckets,
                         closed=self.closed,
@@ -398,8 +399,8 @@ class Strings:
     strip: list[Expression] = default_field([], func=ibis.expr.types.StringColumn.strip)
     upper: Expression | None = default_field(func=ibis.expr.types.StringColumn.upper)
 
-    def __iter__(self) -> Iterable[ibis.Deferred]:
-        for name, (expr, *args) in Expression.items(self):  # type: ignore
+    def __iter__(self) -> Iterator[ibis.Deferred]:
+        for name, (expr, *args) in Expression.items(self):
             yield getattr(expr, name)(*args)
 
 
@@ -427,17 +428,17 @@ class Temporal:
     )
     year: Expression | None = default_field(func=ibis.expr.types.TimestampColumn.year)
 
-    format_str: str = ''
-    unit: str = ''
+    format_str: str = ""
+    unit: str = ""
 
-    def __iter__(self) -> Iterable[ibis.Deferred]:
-        for name, (expr, *args) in Expression.items(self):  # type: ignore
+    def __iter__(self) -> Iterator[ibis.Deferred]:
+        for name, (expr, *args) in Expression.items(self):
             match name:
-                case 'delta':
+                case "delta":
                     yield expr.delta(*args, unit=self.unit)
-                case 'truncate':
+                case "truncate":
                     yield expr.truncate(self.unit)
-                case 'strftime':
+                case "strftime":
                     yield expr.strftime(self.format_str)
                 case _:
                     yield getattr(expr, name)(*args)
@@ -462,11 +463,11 @@ class Window:
     default: JSON | None = default_field(None, description="default JSON scalar")
     scalar: Scalars | None = default_field(description="default typed scalar")
 
-    def __iter__(self) -> Iterable[ibis.Deferred]:
+    def __iter__(self) -> Iterator[ibis.Deferred]:
         (default,) = self.scalar or [self.default]
-        for name, (expr,) in Expression.items(self):  # type: ignore
+        for name, (expr,) in Expression.items(self):
             match name:
-                case 'lag' | 'lead':
+                case "lag" | "lead":
                     yield getattr(expr, name)(self.offset, default)
                 case _:
                     yield getattr(operator, name)(expr, expr.lag(self.offset)).fill_null(default)

{graphique-2.0.1 → graphique-2.0.2}/graphique/interface.py

@@ -7,14 +7,13 @@ Doesn't require knowledge of the schema.
 import itertools
 import operator
 from collections.abc import Iterable, Iterator, Mapping
-from typing import TypeAlias, no_type_check
+from typing import Self, TypeAlias, no_type_check
 
 import ibis
 import pyarrow.dataset as ds
 import strawberry
 from strawberry import UNSET, Info
 from strawberry.scalars import JSON
-from typing_extensions import Self
 
 from .core import Parquet, getitems, order_key
 from .inputs import Aggregates, Expression, Field, Filter, Projection, Scalars, provisional
@@ -27,7 +26,7 @@ Source: TypeAlias = ibis.Table | ds.Dataset
 def references(field) -> Iterator:
     """Generate every possible column reference from strawberry `SelectedField`."""
     if isinstance(field, str):
-        yield field.lstrip('-')
+        yield field.lstrip("-")
     elif isinstance(field, Iterable):
         for value in field:
             yield from references(value)
@@ -35,7 +34,7 @@ def references(field) -> Iterator:
             for value in field.values():
                 yield from references(value)
     else:
-        for name in ('name', 'arguments', 'selections'):
+        for name in ("name", "arguments", "selections"):
             yield from references(getattr(field, name, []))
 
 
@@ -63,7 +62,7 @@ class Dataset:
     def resolve(self, info: Info, source: ibis.Table) -> Self:
         """Cache the table if it will be reused."""
         counts = selections(*info.selected_fields)
-        counts['type'] = counts['schema'] = 0
+        counts["type"] = counts["schema"] = 0
         if counts.total() > 1 and isinstance(source, ibis.Table):
             if names := self.select(info, source):
                 source = source.select(*names).cache()
@@ -109,7 +108,7 @@ class Dataset:
 
         Schema derived fields provide syntax for simple queries; `where` supports complex queries.
         """
-        exprs: list = [] if where is None else list(where)  # type: ignore
+        exprs: list = [] if where is None else list(where)
         source = Parquet.filter(self.source, Filter.to_arrow(**queries))
         if source is None:
             exprs += Filter.to_exprs(**queries)
@@ -156,7 +155,7 @@ class Dataset:
         return self.source.count_rows()
 
     @doc_field
-    def any(self, limit: BigInt = 1) -> bool:
+    def any(self, limit: BigInt = BigInt(1)) -> bool:
         """Whether there are at least `limit` rows.
 
         May be significantly faster than `count` for out-of-core data.
@@ -168,7 +167,7 @@ class Dataset:
         cast=f"cast expression to indicated {links.types}",
         try_="return null if cast fails",
     )
-    def column(self, name: list[str], cast: str = '', try_: bool = False) -> Column | None:
+    def column(self, name: list[str], cast: str = "", try_: bool = False) -> Column | None:
         """Column of any type by name.
 
         If the column is in the schema, `columns` can be used instead.
@@ -182,7 +181,7 @@ class Dataset:
         offset="number of rows to skip; negative value skips from the end",
         limit="maximum number of rows to return",
     )
-    def slice(self, info: Info, offset: BigInt = 0, limit: BigInt | None = None) -> Self:
+    def slice(self, info: Info, offset: BigInt = BigInt(0), limit: BigInt | None = None) -> Self:
         """[Limit](https://ibis-project.org/reference/expression-tables#ibis.expr.types.relations.Table.limit) row selection."""
         return self.resolve(info, self.table[offset:][:limit])
 
@@ -196,9 +195,9 @@ class Dataset:
         self,
         info: Info,
         on: list[str] | None = None,
-        keep: str | None = 'first',
-        counts: str = '',
-        order: str = '',
+        keep: str | None = "first",
+        counts: str = "",
+        order: str = "",
     ) -> Self:
         """[Remove duplicate](https://ibis-project.org/reference/expression-tables#ibis.expr.types.relations.Table.distinct) rows from table.
 
@@ -228,8 +227,8 @@ class Dataset:
         self,
         info: Info,
         by: list[str] = [],
-        counts: str = '',
-        order: str = '',
+        counts: str = "",
+        order: str = "",
         aggregate: Aggregates = {},  # type: ignore
     ) -> Self:
         """[Group](https://ibis-project.org/reference/expression-tables#ibis.expr.types.relations.Table.group_by) table by columns."""
@@ -262,8 +261,8 @@ class Dataset:
         else:
             table = self.table
         if dense and limit is not None:
-            groups = table.aggregate(_=ibis._.count(), by=[name.lstrip('-') for name in by])
-            limit = groups.order_by(*map(order_key, by))[:limit]['_'].sum().to_pyarrow().as_py()
+            groups = table.aggregate(_=ibis._.count(), by=[name.lstrip("-") for name in by])
+            limit = groups.order_by(*map(order_key, by))[:limit]["_"].sum().to_pyarrow().as_py()
         return self.resolve(info, table.order_by(*map(order_key, by))[:limit])
 
     @doc_field(
@@ -276,9 +275,9 @@ class Dataset:
         self,
         info: Info,
         name: str,
-        offset: str = '',
+        offset: str = "",
         keep_empty: bool = False,
-        row_number: str = '',
+        row_number: str = "",
     ) -> Self:
         """[Unnest](https://ibis-project.org/reference/expression-tables#ibis.expr.types.relations.Table.unnest) an array column from a table."""
         table = self.table
@@ -300,9 +299,9 @@ class Dataset:
         right: str,
         keys: list[str],
         rkeys: list[str] = [],
-        how: str = 'inner',
-        lname: str = '',
-        rname: str = '{name}_right',
+        how: str = "inner",
+        lname: str = "",
+        rname: str = "{name}_right",
     ) -> Self:
         """[Join](https://ibis-project.org/reference/expression-tables#ibis.expr.types.relations.Table.join) two tables."""
         left = self.table
@@ -325,7 +324,7 @@ class Dataset:
         return type(self)(ibis.memtable(table))
 
     @doc_field(subset="columns names; defaults to all", how="remove if `any` or `all` are null")
-    def drop_null(self, info: Info, subset: list[str] | None = None, how: str = 'any') -> Self:
+    def drop_null(self, info: Info, subset: list[str] | None = None, how: str = "any") -> Self:
         """[Drop](https://ibis-project.org/reference/expression-tables#ibis.expr.types.relations.Table.drop_null) rows with null values."""
         return self.resolve(info, self.table.drop_null(subset, how=how))
 
@@ -338,7 +337,7 @@ class Dataset:
         scalar: Scalars = {},  # type: ignore
     ) -> Self:
         """[Fill null](https://ibis-project.org/reference/expression-tables.html#ibis.expr.types.relations.Table.fill_null) values."""
-        (value,) = itertools.chain(scalar, [] if value is UNSET else [value])  # type: ignore
+        (value,) = itertools.chain(scalar, [] if value is UNSET else [value])
         replacements = dict.fromkeys(ibis_schema(self.source) if name is None else name, value)
         return self.resolve(info, self.table.fill_null(replacements))
 
@@ -363,8 +362,8 @@ class Dataset:
         info: Info,
         by: list[str] = [],
         split: list[Projection] = [],
-        counts: str = '',
-        alias: str = '{}_index',
+        counts: str = "",
+        alias: str = "{}_index",
         aggregate: Aggregates = {},  # type: ignore
     ) -> Self:
         """Provisionally group table by adjacent values in columns."""