tabalyst 0.4.0__tar.gz → 0.4.2__tar.gz

{tabalyst-0.4.0/src/tabalyst.egg-info → tabalyst-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tabalyst
-Version: 0.4.0
+Version: 0.4.2
 Summary: Open-source toolkit for understanding and working with unfamiliar data.
 Author: Gregory Borelli
 License-Expression: MIT
@@ -181,6 +181,7 @@ tabalyst report data.csv --delimiter ";"
 tabalyst report data.csv --encoding cp1252
 tabalyst report data.csv --config tabalyst.json
 tabalyst report data.csv --verbose
+tabalyst report data.csv --workers 4
 tabalyst report --help
 tabalyst --version
 ```
@@ -233,7 +234,9 @@ detector: numbers with decimal commas, dates, booleans, enumerations, email
 addresses, URLs, phone numbers, postal codes, currency amounts, percentages,
 quantities, UUIDs and IP addresses. Values of sensitive fields, such as email
 addresses, are masked by default. Results are written atomically: an
-interrupted scan never leaves a partial file.
+interrupted scan never leaves a partial file. Files of 16 MiB or more are
+analyzed by several worker processes, with the same result; `--workers`
+chooses their number, `--workers 1` keeps one process.
 
 Build the report from a scan document without reading the source again:
 

{tabalyst-0.4.0 → tabalyst-0.4.2}/README.md

@@ -147,6 +147,7 @@ tabalyst report data.csv --delimiter ";"
 tabalyst report data.csv --encoding cp1252
 tabalyst report data.csv --config tabalyst.json
 tabalyst report data.csv --verbose
+tabalyst report data.csv --workers 4
 tabalyst report --help
 tabalyst --version
 ```
@@ -199,7 +200,9 @@ detector: numbers with decimal commas, dates, booleans, enumerations, email
 addresses, URLs, phone numbers, postal codes, currency amounts, percentages,
 quantities, UUIDs and IP addresses. Values of sensitive fields, such as email
 addresses, are masked by default. Results are written atomically: an
-interrupted scan never leaves a partial file.
+interrupted scan never leaves a partial file. Files of 16 MiB or more are
+analyzed by several worker processes, with the same result; `--workers`
+chooses their number, `--workers 1` keeps one process.
 
 Build the report from a scan document without reading the source again:
 

{tabalyst-0.4.0 → tabalyst-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tabalyst"
-version = "0.4.0"
+version = "0.4.2"
 description = "Open-source toolkit for understanding and working with unfamiliar data."
 readme = "README.md"
 requires-python = ">=3.11"

{tabalyst-0.4.0 → tabalyst-0.4.2}/src/tabalyst/cli/report.py

@@ -143,6 +143,17 @@ def report_command(
             help="Disable interactive file and phase progress.",
         ),
     ] = False,
+    workers: Annotated[
+        int | None,
+        typer.Option(
+            "--workers",
+            min=1,
+            help=(
+                "Processes that analyze values: 1 for one process. By default, "
+                "files of 16 MiB or more use one per spare processor."
+            ),
+        ),
+    ] = None,
 ) -> None:
     """Analyze and profile datasets with Tabalyst Report."""
     if quiet and verbose:
@@ -162,6 +173,7 @@ def report_command(
             force=force,
             on_progress=progress,
             from_scan=from_scan,
+            workers=workers,
         )
     except TabalystError as exc:
         typer.echo(f"Error: {exc}", err=True)

{tabalyst-0.4.0 → tabalyst-0.4.2}/src/tabalyst/cli/scan.py

@@ -149,6 +149,17 @@ def scan_command(
         bool,
         typer.Option("--no-progress", help="Disable interactive progress."),
     ] = False,
+    workers: Annotated[
+        int | None,
+        typer.Option(
+            "--workers",
+            min=1,
+            help=(
+                "Processes that analyze values: 1 for one process. By default, "
+                "files of 16 MiB or more use one per spare processor."
+            ),
+        ),
+    ] = None,
 ) -> None:
     """Scan CSV and JSON files into a complete JSON description of their data."""
     if quiet and verbose:
@@ -168,6 +179,7 @@ def scan_command(
             collections=collection,
             force=force,
             on_progress=progress,
+            workers=workers,
         )
     except TabalystError as exc:
         typer.echo(f"Error: {exc}", err=True)

{tabalyst-0.4.0 → tabalyst-0.4.2}/src/tabalyst/models.py

@@ -378,7 +378,7 @@ class DatasetProfile(ResultModel):
 
 class ReportProfile(ResultModel):
     format_version: Literal["0.1.0a"] = "0.1.0a"
-    format_revision: Literal[6] = 6
+    format_revision: Literal[8] = 8
     generated_at: datetime
     processing_seconds: FiniteFloat
     source: SourceInfo

{tabalyst-0.4.0 → tabalyst-0.4.2}/src/tabalyst/report_service.py

@@ -175,18 +175,25 @@ def generate_reports(
     force: bool = False,
     on_progress: ProgressCallback | None = None,
     from_scan: bool = False,
+    workers: int | None = None,
 ) -> BatchReportResult:
     """Plan and execute one or more reports without depending on the CLI.
 
     With ``from_scan``, the inputs are scan documents written by
     ``tabalyst scan``: each report is built from its document without reading
     the source again, after the staleness checks of ``tabalyst.scan_reuse``.
+    Otherwise ``workers`` is passed to ``tabalyst.scan()``.
     """
     if from_scan and (separator is not None or encoding is not None):
         raise ConfigurationError(
             "--delimiter and --encoding cannot be used with --scan: the scan "
             "document records how its source was read."
         )
+    if from_scan and workers is not None:
+        raise ConfigurationError(
+            "--workers cannot be used with --scan: the report reads the scan "
+            "document, not its source."
+        )
     plan = build_report_plan(
         input_specs,
         output=output,
@@ -245,6 +252,7 @@ def generate_reports(
                     config_paths,
                     force=force,
                     on_progress=forward,
+                    workers=workers,
                 )
         except TabalystError as exc:
             failures.append(ReportFailure(job=job, error=exc))

{tabalyst-0.4.0 → tabalyst-0.4.2}/src/tabalyst/reporting.py

@@ -1,10 +1,12 @@
 """Render self-contained analysis results as an interactive HTML report."""
 
+import re
 from collections import defaultdict
 from importlib.resources import files
 from pathlib import Path
 
 from jinja2 import Environment, StrictUndefined
+from markupsafe import Markup, escape
 
 from tabalyst._version import get_version
 from tabalyst.models import ReportProfile
@@ -55,6 +57,17 @@ def format_size(size_bytes: int) -> str:
     return f"{size_bytes / 1024:.1f} KB"
 
 
+# Separators after which a long name may break: snake case, paths and dates.
+_BREAKS = re.compile(r"(?<=[_./-])")
+
+
+def breakable(name: str) -> Markup:
+    """``name`` escaped, with a line break opportunity after each separator,
+    so that a table squeezed for room narrows its column instead of
+    scrolling."""
+    return Markup("<wbr>").join(escape(part) for part in _BREAKS.split(name))
+
+
 def load_profile(path: str | Path) -> ReportProfile:
     """Validate and load the experimental JSON profile format."""
     return ReportProfile.model_validate_json(Path(path).read_text(encoding="utf-8"))
@@ -68,6 +81,7 @@ def render_report(profile: ReportProfile) -> str:
     environment.filters["number"] = format_number
     environment.filters["seconds"] = format_seconds
     environment.filters["size"] = format_size
+    environment.filters["breakable"] = breakable
     template = environment.from_string(
         resources.joinpath("templates/report.html").read_text(encoding="utf-8")
     )

{tabalyst-0.4.0 → tabalyst-0.4.2}/src/tabalyst/scan_service.py

@@ -106,6 +106,7 @@ def generate_scans(
     collections: Sequence[str] | None = None,
     force: bool = False,
     on_progress: ProgressCallback | None = None,
+    workers: int | None = None,
 ) -> BatchScanResult:
     """Scan one or more CSV or JSON files and write one scan document each.
 
@@ -113,7 +114,8 @@ def generate_scans(
     the ``scan`` section of each ``config_path`` file in order, then
     ``delimiter``, ``encoding`` and ``collections``. The whole batch is
     rejected before any scan when an output is unsafe; afterwards, a failed
-    source does not stop the others.
+    source does not stop the others. ``workers`` is passed to
+    ``tabalyst.scan()``.
     """
     config_paths = _config_paths(config_path)
     config = resolve_scan_config(
@@ -151,7 +153,9 @@ def generate_scans(
                 )
 
         try:
-            result = scan(job.source, config=config, on_progress=forward)
+            result = scan(
+                job.source, config=config, on_progress=forward, workers=workers
+            )
             emit_progress(
                 on_progress, job.source, ProgressPhase.WRITING, index=index, total=total
             )

{tabalyst-0.4.0 → tabalyst-0.4.2}/src/tabalyst/scanner/api.py

@@ -8,7 +8,7 @@ from pathlib import Path
 from time import perf_counter
 
 from tabalyst._version import __version__
-from tabalyst.errors import InputError
+from tabalyst.errors import ConfigurationError, InputError
 from tabalyst.progress import ProgressCallback, ProgressPhase, emit_progress
 from tabalyst.scanner.config import ScanConfig, config_sha256
 from tabalyst.scanner.detectors.registry import (
@@ -25,11 +25,17 @@ from tabalyst.scanner.models import (
     Scope,
     SourceInfo,
 )
-from tabalyst.scanner.observations import Record, StreamItem
+from tabalyst.scanner.observations import (
+    DatasetOpened,
+    Record,
+    RecordBatch,
+    StreamItem,
+)
 from tabalyst.scanner.paths import format_absolute, parse_path
 from tabalyst.scanner.readers.base import Reader
 from tabalyst.scanner.readers.csv_reader import CsvReader
 from tabalyst.scanner.readers.json_reader import JsonReader
+from tabalyst.scanner.workers import WorkerPool, worker_count
 
 NORMALIZATION_VERSION = 1
 # Reading progress is reported at most once per percent of the source, and
@@ -86,9 +92,17 @@ def _collection_scope(source_format: str, config: ScanConfig) -> CollectionScope
 def _observed(
     items: Iterable[StreamItem], on_record: Callable[[Record], None]
 ) -> Iterator[StreamItem]:
+    """Items as read, after passing each analyzed record to ``on_record``;
+    records of a batch are passed one by one, as ``Record`` items."""
+    declared = {}
     for item in items:
         if type(item) is Record:
             on_record(item)
+        elif type(item) is RecordBatch:
+            for record in item.records(declared[item.dataset]):
+                on_record(record)
+        elif type(item) is DatasetOpened:
+            declared[item.dataset] = [field.path for field in item.fields]
         yield item
 
 
@@ -99,6 +113,7 @@ def scan(
     registry: DetectorRegistry | None = None,
     on_progress: ProgressCallback | None = None,
     on_record: Callable[[Record], None] | None = None,
+    workers: int | None = None,
 ) -> ScanResult:
     """Read one source completely and return its finalized scan result.
 
@@ -107,7 +122,14 @@ def scan(
     order, before the engine: consumers that need record-level facts, such
     as the report's preview and duplicate rows, get them in the same pass. It
     must not modify the record.
+
+    ``workers`` is the number of processes that analyze values: ``1`` scans
+    in this process; by default, large sources use one worker per spare
+    processor (``workers.worker_count``). The result does not depend on it.
+    A custom ``registry`` always scans in this process.
     """
+    if workers is not None and workers < 1:
+        raise ConfigurationError("workers must be at least 1")
     path = Path(source)
     # A private copy: the finalized result must not share state with the caller.
     config = ScanConfig() if config is None else config.model_copy(deep=True)
@@ -130,8 +152,17 @@ def scan(
         default_registry() if registry is None else registry, config
     )
     engine = ScanEngine(config, detectors)
-    engine.consume(reader if on_record is None else _observed(reader, on_record))
-    datasets = engine.finalize()
+    count = 1 if registry is not None else worker_count(workers, stat.st_size)
+    if count > 1:
+        pool = WorkerPool(config.model_dump_json(by_alias=True), count)
+        if pool.start():
+            engine.values.pool = pool
+    try:
+        engine.consume(reader if on_record is None else _observed(reader, on_record))
+        datasets = engine.finalize()
+    finally:
+        if engine.values.pool is not None:
+            engine.values.pool.close()
     summary = reader.summary()
 
     excluded = engine.records_excluded

{tabalyst-0.4.0 → tabalyst-0.4.2}/src/tabalyst/scanner/config.py

@@ -52,6 +52,9 @@ MAX_PREVIEW_RECORDS = 1_000
 MAX_PATTERNS = 200
 MAX_PATTERN_LENGTH = 1_000
 MAX_PATTERN_INPUT_LENGTH = 10_000
+# A streamed field keeps its warm-up values: the warm-up is bounded.
+MAX_WARMUP_VALUES = 1_000_000
+MAX_PROBE_INTERVAL = 1_000_000
 
 MissingCategory = Literal["absent", "null", "empty", "blank", "marker"]
 ScalarType = Literal["string", "integer", "number", "boolean"]
@@ -176,6 +179,12 @@ class TypeSettings(_Settings):
 
 class DetectionSettings(_Settings):
     minimum_share: float = Field(default=0.95, gt=0, le=1)
+    # Adaptive detection (design 13): 0 keeps detection exhaustive.
+    warmup_values: int = Field(default=10_000, ge=0, le=MAX_WARMUP_VALUES)
+    probe_interval: int = Field(default=100, ge=0, le=MAX_PROBE_INTERVAL)
+    # Detectors that reacted to at most this share of the warm-up values are
+    # skipped too; 0 skips only those that reacted to none.
+    rare_share: float = Field(default=0.001, ge=0, le=1)
 
 
 NumberConvention = Literal["dot", "comma"]

{tabalyst-0.4.0 → tabalyst-0.4.2}/src/tabalyst/scanner/detectors/base.py

@@ -10,9 +10,9 @@ accumulator adds its own ``details``.
 from __future__ import annotations
 
 import re
-from collections.abc import Mapping
+from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, ClassVar, Literal
+from typing import TYPE_CHECKING, ClassVar, Literal, NamedTuple
 
 if TYPE_CHECKING:
     from tabalyst.scanner.exposure import ExposureGate
@@ -20,8 +20,7 @@ if TYPE_CHECKING:
 State = Literal["matched", "ambiguous", "invalid"]
 
 
-@dataclass(frozen=True, slots=True)
-class Classification:
+class Classification(NamedTuple):
     """Result of a detector for one value; ``None`` stands for not matched.
 
     - ``matched`` values may carry a ``format`` and a parsed ``value`` for
@@ -34,6 +33,9 @@ class Classification:
     - ``convention`` names the reading of an unambiguous value when several
       readings exist (date order, decimal convention); it feeds the ambiguity
       evidence of the field (design 12.6).
+
+    An immutable named tuple: detectors build one per matched value, and a
+    tuple is built about twice as fast as a frozen dataclass.
     """
 
     state: State
@@ -69,9 +71,15 @@ class DetectorAccumulator:
     ``add`` receives every tested value with its classification (``None`` when
     not matched) and its count. In both execution modes it sees the same
     distinct values, first seen first, with the same total counts.
+
+    A class whose ``add`` does nothing for unmatched values (``None``) sets
+    ``ignores_unmatched`` in its own body: the engine then skips those calls.
+    The flag applies only to the class that defines ``add``, so a subclass
+    that overrides ``add`` receives every value unless it sets it again.
     """
 
     __slots__ = ()
+    ignores_unmatched: ClassVar[bool] = True
 
     def add(
         self, value: str, classification: Classification | None, count: int
@@ -90,6 +98,14 @@ class DetectorAccumulator:
         """Field-level detectors decide at the end whether their values match."""
         return True
 
+    def rejects_field(self) -> bool:
+        """Whether a field-level detector already knows that the field cannot
+        match, whatever values follow, and that ``add`` no longer changes
+        ``details``. The engine then counts later values as not matched
+        without classifying them, which is exact only for detectors whose
+        ``classify`` never returns ``ambiguous`` or ``invalid``."""
+        return False
+
 
 class Detector:
     """Base class of detectors; subclasses set the class attributes and
@@ -104,6 +120,11 @@ class Detector:
     - ``max_input_length``: longer values are ``not_tested``.
     - ``scope``: ``field`` detectors, such as enumeration candidates, decide
       at the end whether every value of the field matches or none does.
+
+    The engine classifies distinct values in batches through
+    ``classify_many``, which maps ``classify`` by default. A detector may
+    override it to reject most values without a call per value, provided it
+    returns exactly what ``classify`` returns for each value.
     """
 
     id: ClassVar[str]
@@ -121,6 +142,10 @@ class Detector:
     def classify(self, value: str) -> Classification | None:
         raise NotImplementedError
 
+    def classify_many(self, values: Sequence[str]) -> list[Classification | None]:
+        """``classify`` of each value, in order."""
+        return list(map(self.classify, values))
+
     def accumulator(self) -> DetectorAccumulator:
         return DetectorAccumulator()
 
@@ -135,6 +160,7 @@ class AmbiguityAccumulator(DetectorAccumulator):
     """
 
     __slots__ = ("candidates", "count", "evidence", "resolution")
+    ignores_unmatched = True
 
     def __init__(self, readings: list[str], resolution: dict[str, str] | None) -> None:
         self.count = 0

{tabalyst-0.4.0 → tabalyst-0.4.2}/src/tabalyst/scanner/detectors/boolean.py

@@ -7,7 +7,7 @@ booleans stay in the ``booleans`` block.
 
 from __future__ import annotations
 
-from collections.abc import Mapping
+from collections.abc import Mapping, Sequence
 
 from tabalyst.scanner.detectors.base import (
     Classification,
@@ -45,12 +45,21 @@ class BooleanDetector(Detector):
             return None
         return self._words.get(value.casefold())
 
+    def classify_many(self, values: Sequence[str]) -> list[Classification | None]:
+        words = self._words
+        longest = self._longest
+        return [
+            words.get(value.casefold()) if len(value) <= longest else None
+            for value in values
+        ]
+
     def accumulator(self) -> BooleanAccumulator:
         return BooleanAccumulator()
 
 
 class BooleanAccumulator(DetectorAccumulator):
     __slots__ = ("false", "true")
+    ignores_unmatched = True
 
     def __init__(self) -> None:
         self.true = 0

{tabalyst-0.4.0 → tabalyst-0.4.2}/src/tabalyst/scanner/detectors/currency.py

@@ -8,7 +8,7 @@ of money. The number part follows the number detector (``amount.py``).
 from __future__ import annotations
 
 import re
-from collections.abc import Mapping
+from collections.abc import Mapping, Sequence
 
 from tabalyst.scanner.detectors.amount import (
     NUMBER_PART,
@@ -107,12 +107,22 @@ class CurrencyDetector(Detector):
         sign, _, body, prefix, suffix = parts
         return self.reader.read(sign, body, prefix, suffix)
 
+    def classify_many(self, values: Sequence[str]) -> list[Classification | None]:
+        classify = self.classify
+        return [
+            classify(value)
+            if value[:1] in _FIRST or value[-1:] in _LAST
+            else None
+            for value in values
+        ]
+
     def accumulator(self) -> CurrencyAccumulator:
         return CurrencyAccumulator(self.reader)
 
 
 class CurrencyAccumulator(AmountAccumulator):
     __slots__ = ("currencies",)
+    ignores_unmatched = True
 
     def __init__(self, reader: AmountReader) -> None:
         super().__init__(reader)

{tabalyst-0.4.0 → tabalyst-0.4.2}/src/tabalyst/scanner/detectors/email.py

@@ -8,7 +8,7 @@ masked by default (design 12.8).
 from __future__ import annotations
 
 import re
-from collections.abc import Mapping
+from collections.abc import Mapping, Sequence
 
 from tabalyst.scanner.detectors.base import (
     Classification,
@@ -66,12 +66,17 @@ class EmailDetector(Detector):
             return _BAD_DOMAIN
         return Classification("matched", value=domain.lower())
 
+    def classify_many(self, values: Sequence[str]) -> list[Classification | None]:
+        classify = self.classify
+        return [classify(value) if "@" in value else None for value in values]
+
     def accumulator(self) -> EmailAccumulator:
         return EmailAccumulator(NameCounts(self.max_tracked, self.max_listed))
 
 
 class EmailAccumulator(DetectorAccumulator):
     __slots__ = ("domains",)
+    ignores_unmatched = True
 
     def __init__(self, domains: NameCounts) -> None:
         self.domains = domains

{tabalyst-0.4.0 → tabalyst-0.4.2}/src/tabalyst/scanner/detectors/enumeration.py

@@ -5,12 +5,14 @@ A field-level detector: its values match together when the field has at least
 ``minimum_values`` eligible values and at most ``maximum_distinct`` distinct
 analytical values (ignoring case when ``case_sensitive`` is false); otherwise
 none matches. It keeps at most ``maximum_distinct + 1`` values, so its state is
-bounded and its result does not depend on frequency tables.
+bounded and its result does not depend on frequency tables. Once it holds
+``maximum_distinct + 1`` values, the field is rejected and later values are
+only counted (``rejects_field``).
 """
 
 from __future__ import annotations
 
-from collections.abc import Mapping
+from collections.abc import Mapping, Sequence
 
 from tabalyst.scanner.detectors.base import (
     Classification,
@@ -36,6 +38,9 @@ class EnumerationDetector(Detector):
     def classify(self, value: str) -> Classification:
         return _MEMBER
 
+    def classify_many(self, values: Sequence[str]) -> list[Classification]:
+        return [_MEMBER] * len(values)
+
     def accumulator(self) -> EnumerationAccumulator:
         return EnumerationAccumulator(
             self.minimum_values, self.maximum_distinct, self.case_sensitive
@@ -62,6 +67,11 @@ class EnumerationAccumulator(DetectorAccumulator):
     def field_matches(self) -> bool:
         return self.values >= self.minimum and len(self.keys) <= self.maximum
 
+    def rejects_field(self) -> bool:
+        # Keys stop growing past the maximum: the field can no longer match,
+        # and ``details`` no longer changes.
+        return len(self.keys) > self.maximum
+
     def details(self, gate: ExposureGate) -> dict[str, object]:
         distinct = len(self.keys)
         if distinct <= self.maximum:

{tabalyst-0.4.0 → tabalyst-0.4.2}/src/tabalyst/scanner/detectors/ip.py

@@ -9,7 +9,7 @@ so the detector is sensitive: its fields are masked by default (design 12.8).
 from __future__ import annotations
 
 import re
-from collections.abc import Mapping
+from collections.abc import Mapping, Sequence
 
 from tabalyst.scanner.detectors.base import (
     Classification,
@@ -108,12 +108,24 @@ class IpAddressDetector(Detector):
             return _ipv6(value) if self._ipv6 else None
         return _ipv4(value) if self._ipv4 else None
 
+    def classify_many(self, values: Sequence[str]) -> list[Classification | None]:
+        classify = self.classify
+        return [
+            classify(value)
+            if MIN_LENGTH <= len(value) <= MAX_LENGTH
+            and value[0] in _EDGE
+            and value[-1] in _EDGE
+            else None
+            for value in values
+        ]
+
     def accumulator(self) -> IpAddressAccumulator:
         return IpAddressAccumulator(self.versions)
 
 
 class IpAddressAccumulator(DetectorAccumulator):
     __slots__ = ("versions",)
+    ignores_unmatched = True
 
     def __init__(self, versions: tuple[str, ...]) -> None:
         self.versions = dict.fromkeys(sorted(versions), 0)

{tabalyst-0.4.0 → tabalyst-0.4.2}/src/tabalyst/scanner/detectors/number.py

@@ -18,7 +18,7 @@ spreadsheet number formats: ``0``, ``0.0``, ``0E0``, ``#,##0.0``, ``0,0``.
 from __future__ import annotations
 
 import re
-from collections.abc import Mapping
+from collections.abc import Mapping, Sequence
 from decimal import Decimal
 
 from tabalyst.scanner.detectors.base import (
@@ -37,6 +37,8 @@ _CONVENTIONS = {"dot": (".", "," + _SPACES), "comma": (",", "." + _SPACES)}
 
 # Characters of every accepted value: an exact, cheap rejection.
 _CHARACTERS = re.compile("[-+.]?[0-9.][0-9.,eE+   -]*")
+# The first character of every value that ``_CHARACTERS`` accepts.
+_FIRST = frozenset("+-.0123456789")
 
 INTEGER_FORMATS = frozenset(
     {"0"} | {f"#{separator}##0" for separator in ",." + _SPACES}
@@ -150,6 +152,26 @@ class NumberDetector(Detector):
             )
         return Classification("ambiguous", candidates=candidates)
 
+    def classify_many(self, values: Sequence[str]) -> list[Classification | None]:
+        """``classify`` of each value: values that cannot start a number are
+        rejected, and strict integers of ASCII digits read, without a call."""
+        classify = self.classify
+        first = _FIRST
+        results: list[Classification | None] = []
+        append = results.append
+        for value in values:
+            if value[:1] not in first:
+                append(None)
+            elif (
+                value.isdigit()
+                and value.isascii()
+                and (value[0] != "0" or len(value) == 1)
+            ):
+                append(Classification("matched", "0", (), None, _integer(value)))
+            else:
+                append(classify(value))
+        return results
+
     def accumulator(self) -> AmbiguityAccumulator:
         resolution = (
             None

{tabalyst-0.4.0 → tabalyst-0.4.2}/src/tabalyst/scanner/detectors/pattern.py

@@ -9,7 +9,7 @@ value. Patterns are trusted configuration: Python ``re`` has no timeout.
 from __future__ import annotations
 
 import re
-from collections.abc import Mapping
+from collections.abc import Mapping, Sequence
 
 from tabalyst.scanner.config import PatternSettings
 from tabalyst.scanner.detectors.base import Classification, Detector
@@ -31,6 +31,12 @@ class PatternDetector(Detector):
     def classify(self, value: str) -> Classification | None:
         return _MATCHED if self._fullmatch(value) is not None else None
 
+    def classify_many(self, values: Sequence[str]) -> list[Classification | None]:
+        fullmatch = self._fullmatch
+        return [
+            _MATCHED if fullmatch(value) is not None else None for value in values
+        ]
+
 
 def pattern_detector(settings: PatternSettings) -> type[PatternDetector]:
     """A detector class for one validated ``patterns`` entry."""