typemonkey 1.0.0__tar.gz

typemonkey-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 RexBytes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

typemonkey-1.0.0/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: typemonkey
+Version: 1.0.0
+Summary: Column type inference and type-aware cleaning: numbers, currency, percentages, booleans, nulls, dates.
+Author-email: RexBytes <pythonic@rexbytes.com>
+License: MIT License
+        
+        Copyright (c) 2026 RexBytes
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/RexBytes/typemonkey
+Project-URL: Issues, https://github.com/RexBytes/typemonkey/issues
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: datemonkey~=0.1.0
+Requires-Dist: cleanmonkey~=0.1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: hypothesis>=6.0; extra == "dev"
+Dynamic: license-file
+
+# typemonkey
+
+Column type inference and type-aware cleaning for messy tabular data.
+Infer whether a column is an integer, float, currency, percentage, boolean,
+date, or free-text string — then clean it to that type. Numbers buried in
+currency symbols, thousands separators, European decimal commas, accounting
+parentheses, and percent signs come out as plain Python numbers; a column's
+worth of `yes`/`Y`/`1`/`true` come out as `bool`; twenty-plus spellings of
+"null" collapse to `None`.
+
+Part of the monkey toolkit. Delegates date detection to
+[`datemonkey`](https://pypi.org/project/datemonkey/) and value normalisation
+to [`cleanmonkey`](https://pypi.org/project/cleanmonkey/) — it does not
+reinvent either.
+
+## Install
+
+```bash
+pip install typemonkey
+```
+
+## Quick start
+
+```python
+from typemonkey import infer_type, clean_numeric, clean_boolean, clean_column
+
+profile = infer_type(["$1,234.56", "$2,000.00", "$3.50"])
+profile.type          # TypeName.CURRENCY
+profile.confidence    # 1.0
+profile.locale        # "us"
+
+clean_numeric(["$1,234.56", "(50)", "12%", "N/A"]).values
+# [1234.56, -50, 0.12, None]      # parens = negative, 12% = 0.12, N/A = null
+
+clean_numeric(["1.234,56", "3,50"], locale="eu").values
+# [1234.56, 3.5]                  # European decimal comma
+
+clean_boolean(["yes", "NO", "1", "0", "maybe"]).values
+# [True, False, True, False, None]   # "maybe" recorded in .failures
+
+clean_column(["01234", "07090", "02139"]).values
+# ['01234', '07090', '02139']     # zero-padded IDs preserved as strings
+```
+
+Every entry point returns a typed dataclass (`ColumnProfile`, `CleanResult`),
+not a dict. `CleanResult.failures` lists `(index, original)` for non-null
+values that didn't parse, so "missing" is never confused with "empty".
+
+## What it recognises
+
+- **Numbers** — `int`, `float`, with thousands separators, apostrophe/space
+  grouping, leading `+`/`-`, accounting `(parentheses)` negatives.
+- **Currency** — `$ € £ ¥ ₹ ...` symbols and ISO codes (`USD`, `EUR`, ...).
+- **Percentages** — `"12%"`, `"8 %"` → `0.12`, `0.08` (or keep as `12`, `8`).
+- **Booleans** — `true/false`, `t/f`, `yes/no`, `y/n`, `on/off`, `1/0`.
+- **Dates** — via datemonkey (ISO, US/EU slash and dash, ambiguity reporting).
+- **Nulls** — 20+ spellings (`N/A`, `#N/A`, `null`, `none`, `-`, `unknown`, …).
+- **Preserve-as-string** — zero-padded IDs, Zip+4, phone numbers.
+- **Locale** — US `1,234.56` vs European `1.234,56`, auto-detected per column.
+
+## CLI
+
+```bash
+printf '$1,234.56\n$2,000.00\n$3.50\n' | typemonkey profile      # JSON report
+printf '12%%\n8 %%\nN/A\n'             | typemonkey clean         # cleaned values
+typemonkey clean --type integer column.txt
+```
+
+`typemonkey profile` prints a JSON `ColumnProfile`; `typemonkey clean` prints
+one cleaned value per line (blank for nulls) and exits non-zero if any non-null
+value failed to parse.
+
+## Using with AI assistants
+
+See [`SKILL.md`](SKILL.md) for an LLM-oriented quick reference (decision table,
+worked examples, anti-patterns).
+
+## Deliberate tradeoffs
+
+Some behaviour is intentional and might look like a bug — bare 5-digit numbers
+aren't treated as zips, all-`0`/`1` columns are integers not booleans, Excel
+serials report numeric. See [`LIMITATIONS.md`](LIMITATIONS.md) for the
+rationale and escape hatch on each.
+
+## License
+
+MIT

typemonkey-1.0.0/README.md

@@ -0,0 +1,87 @@
+# typemonkey
+
+Column type inference and type-aware cleaning for messy tabular data.
+Infer whether a column is an integer, float, currency, percentage, boolean,
+date, or free-text string — then clean it to that type. Numbers buried in
+currency symbols, thousands separators, European decimal commas, accounting
+parentheses, and percent signs come out as plain Python numbers; a column's
+worth of `yes`/`Y`/`1`/`true` come out as `bool`; twenty-plus spellings of
+"null" collapse to `None`.
+
+Part of the monkey toolkit. Delegates date detection to
+[`datemonkey`](https://pypi.org/project/datemonkey/) and value normalisation
+to [`cleanmonkey`](https://pypi.org/project/cleanmonkey/) — it does not
+reinvent either.
+
+## Install
+
+```bash
+pip install typemonkey
+```
+
+## Quick start
+
+```python
+from typemonkey import infer_type, clean_numeric, clean_boolean, clean_column
+
+profile = infer_type(["$1,234.56", "$2,000.00", "$3.50"])
+profile.type          # TypeName.CURRENCY
+profile.confidence    # 1.0
+profile.locale        # "us"
+
+clean_numeric(["$1,234.56", "(50)", "12%", "N/A"]).values
+# [1234.56, -50, 0.12, None]      # parens = negative, 12% = 0.12, N/A = null
+
+clean_numeric(["1.234,56", "3,50"], locale="eu").values
+# [1234.56, 3.5]                  # European decimal comma
+
+clean_boolean(["yes", "NO", "1", "0", "maybe"]).values
+# [True, False, True, False, None]   # "maybe" recorded in .failures
+
+clean_column(["01234", "07090", "02139"]).values
+# ['01234', '07090', '02139']     # zero-padded IDs preserved as strings
+```
+
+Every entry point returns a typed dataclass (`ColumnProfile`, `CleanResult`),
+not a dict. `CleanResult.failures` lists `(index, original)` for non-null
+values that didn't parse, so "missing" is never confused with "empty".
+
+## What it recognises
+
+- **Numbers** — `int`, `float`, with thousands separators, apostrophe/space
+  grouping, leading `+`/`-`, accounting `(parentheses)` negatives.
+- **Currency** — `$ € £ ¥ ₹ ...` symbols and ISO codes (`USD`, `EUR`, ...).
+- **Percentages** — `"12%"`, `"8 %"` → `0.12`, `0.08` (or keep as `12`, `8`).
+- **Booleans** — `true/false`, `t/f`, `yes/no`, `y/n`, `on/off`, `1/0`.
+- **Dates** — via datemonkey (ISO, US/EU slash and dash, ambiguity reporting).
+- **Nulls** — 20+ spellings (`N/A`, `#N/A`, `null`, `none`, `-`, `unknown`, …).
+- **Preserve-as-string** — zero-padded IDs, Zip+4, phone numbers.
+- **Locale** — US `1,234.56` vs European `1.234,56`, auto-detected per column.
+
+## CLI
+
+```bash
+printf '$1,234.56\n$2,000.00\n$3.50\n' | typemonkey profile      # JSON report
+printf '12%%\n8 %%\nN/A\n'             | typemonkey clean         # cleaned values
+typemonkey clean --type integer column.txt
+```
+
+`typemonkey profile` prints a JSON `ColumnProfile`; `typemonkey clean` prints
+one cleaned value per line (blank for nulls) and exits non-zero if any non-null
+value failed to parse.
+
+## Using with AI assistants
+
+See [`SKILL.md`](SKILL.md) for an LLM-oriented quick reference (decision table,
+worked examples, anti-patterns).
+
+## Deliberate tradeoffs
+
+Some behaviour is intentional and might look like a bug — bare 5-digit numbers
+aren't treated as zips, all-`0`/`1` columns are integers not booleans, Excel
+serials report numeric. See [`LIMITATIONS.md`](LIMITATIONS.md) for the
+rationale and escape hatch on each.
+
+## License
+
+MIT

typemonkey-1.0.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "typemonkey"
+version = "1.0.0"
+description = "Column type inference and type-aware cleaning: numbers, currency, percentages, booleans, nulls, dates."
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [{ name = "RexBytes", email = "pythonic@rexbytes.com" }]
+requires-python = ">=3.11"
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    # Pinned to the 0.1.x line: typemonkey reads detailed attributes off these
+    # pre-1.0 result objects (datemonkey's .format.pattern / .confidence /
+    # .results[].row_index, etc.), so a 0.2 could break us. Bump deliberately.
+    "datemonkey~=0.1.0",
+    "cleanmonkey~=0.1.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "pytest-cov", "hypothesis>=6.0"]
+
+[project.scripts]
+typemonkey = "typemonkey.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/RexBytes/typemonkey"
+Issues   = "https://github.com/RexBytes/typemonkey/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

typemonkey-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

typemonkey-1.0.0/src/typemonkey/__init__.py

@@ -0,0 +1,49 @@
+"""typemonkey — column type inference and type-aware cleaning.
+
+Public API (import ``from typemonkey import X``):
+
+* :func:`infer_type` — profile a column, returning a :class:`ColumnProfile`.
+* :func:`clean_column` — clean a column to an inferred or given type.
+* :func:`clean_numeric` / :func:`clean_boolean` — type-specific cleaners.
+* :func:`normalize_nulls` / :func:`is_null` — null handling.
+* :func:`detect_number_locale` — US vs European number format detection.
+* :func:`looks_like_preserve_string` — zip/phone/zero-padded-ID detection.
+* :class:`ColumnProfile`, :class:`CleanResult`, :class:`TypeName` — result types.
+* :data:`DEFAULT_NULLS`, :data:`TRUE_VALUES`, :data:`FALSE_VALUES` — vocabularies.
+
+See LIMITATIONS.md for deliberate design tradeoffs and SKILL.md for an
+LLM-oriented quick reference.
+"""
+
+from __future__ import annotations
+
+from .booleans import FALSE_VALUES, TRUE_VALUES, clean_boolean, parse_boolean
+from .clean import clean_column
+from .infer import infer_type
+from .locale import detect_number_locale
+from .models import CleanResult, ColumnProfile, TypeName
+from .nulls import DEFAULT_NULLS, is_null, normalize_nulls
+from .numbers import clean_numeric, parse_number
+from .preserve import looks_like_preserve_string
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "infer_type",
+    "clean_column",
+    "clean_numeric",
+    "clean_boolean",
+    "parse_number",
+    "parse_boolean",
+    "normalize_nulls",
+    "is_null",
+    "detect_number_locale",
+    "looks_like_preserve_string",
+    "ColumnProfile",
+    "CleanResult",
+    "TypeName",
+    "DEFAULT_NULLS",
+    "TRUE_VALUES",
+    "FALSE_VALUES",
+    "__version__",
+]

typemonkey-1.0.0/src/typemonkey/booleans.py

@@ -0,0 +1,124 @@
+"""Boolean vocabulary and normalisation.
+
+This module exists because "true" arrives as ``yes``, ``Y``, ``1``, ``on``,
+``T``, ``true``, ``TRUE`` and a dozen other spellings, and inference needs one
+authoritative mapping from token to ``bool``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .models import CleanResult, TypeName
+from .nulls import is_null
+
+# Tokens that mean True / False. Matching is case-insensitive and
+# whitespace-trimmed, so only one casing of each spelling is listed.
+TRUE_VALUES: frozenset[str] = frozenset(
+    {"true", "t", "yes", "y", "1", "on", "enabled", "active"}
+)
+FALSE_VALUES: frozenset[str] = frozenset(
+    {"false", "f", "no", "n", "0", "off", "disabled", "inactive"}
+)
+# The numeric pair is recognised as boolean but is *also* valid integer data.
+# Inference uses this set to avoid mislabelling a 0/1 integer column as boolean.
+NUMERIC_BOOLEANS: frozenset[str] = frozenset({"0", "1"})
+
+
+@dataclass
+class ParsedBoolean:
+    """A parsed boolean token.
+
+    Attributes:
+        value: The resulting ``bool``.
+        numeric: ``True`` when the source token was ``"0"`` or ``"1"`` — the
+            ambiguous case that is equally valid integer data.
+    """
+
+    value: bool
+    numeric: bool
+
+
+def parse_boolean(
+    token: object,
+    *,
+    true_values=None,
+    false_values=None,
+) -> ParsedBoolean:
+    """Parse one boolean token, raising :class:`ValueError` if unrecognised.
+
+    Args:
+        token: The value to parse. Non-strings are stringified; the result is
+            trimmed and lower-cased before lookup.
+        true_values: Override truthy vocabulary (case-insensitive). Defaults
+            to :data:`TRUE_VALUES`.
+        false_values: Override falsy vocabulary. Defaults to
+            :data:`FALSE_VALUES`.
+
+    Returns:
+        A :class:`ParsedBoolean`.
+
+    Raises:
+        ValueError: If the token is in neither vocabulary.
+    """
+    trues = TRUE_VALUES if true_values is None else frozenset(v.lower() for v in true_values)
+    falses = FALSE_VALUES if false_values is None else frozenset(v.lower() for v in false_values)
+    key = str(token).strip().lower()
+    if key in trues:
+        return ParsedBoolean(value=True, numeric=key in NUMERIC_BOOLEANS)
+    if key in falses:
+        return ParsedBoolean(value=False, numeric=key in NUMERIC_BOOLEANS)
+    raise ValueError(f"{token!r} is not a recognised boolean")
+
+
+def is_boolean(token: object, **kwargs) -> bool:
+    """Return ``True`` when :func:`parse_boolean` would succeed on ``token``."""
+    try:
+        parse_boolean(token, **kwargs)
+        return True
+    except ValueError:
+        return False
+
+
+def clean_boolean(
+    values,
+    *,
+    true_values=None,
+    false_values=None,
+    null_values=None,
+) -> CleanResult:
+    """Clean a column of messy boolean strings into Python ``bool`` values.
+
+    Args:
+        values: The column to clean.
+        true_values: Override truthy vocabulary (see :func:`parse_boolean`).
+        false_values: Override falsy vocabulary.
+        null_values: Null spellings (see :func:`typemonkey.nulls.is_null`);
+            recognised nulls become ``None`` and are not counted as failures.
+
+    Returns:
+        A :class:`CleanResult` whose ``values`` align 1:1 with ``values`` and
+        whose ``failures`` records ``(index, original)`` for non-null tokens
+        that matched neither vocabulary.
+    """
+    out: list[object] = []
+    failures: list[tuple[int, str]] = []
+    null_count = 0
+    for i, raw in enumerate(values):
+        if is_null(raw, null_values):
+            out.append(None)
+            null_count += 1
+            continue
+        try:
+            parsed = parse_boolean(raw, true_values=true_values, false_values=false_values)
+        except ValueError:
+            out.append(None)
+            failures.append((i, str(raw)))
+            continue
+        out.append(parsed.value)
+    return CleanResult(
+        values=out,
+        target_type=TypeName.BOOLEAN,
+        null_count=null_count,
+        failures=failures,
+    )

typemonkey-1.0.0/src/typemonkey/clean.py

@@ -0,0 +1,162 @@
+"""``clean_column`` — infer (or accept) a target type, then clean to it.
+
+This module exists as the one-call convenience entry point: hand it a column
+and it figures out the type and returns cleaned values, or pass ``target_type``
+to force the conversion. It dispatches to the type-specific cleaners in
+:mod:`typemonkey.numbers` and :mod:`typemonkey.booleans`, and to datemonkey for
+dates.
+"""
+
+from __future__ import annotations
+
+import cleanmonkey
+from datemonkey import parse_dates
+
+from .booleans import clean_boolean
+from .infer import infer_type
+from .locale import detect_number_locale
+from .models import CleanResult, TypeName
+from .nulls import is_null
+from .numbers import clean_numeric
+
+_NUMERIC = {TypeName.INTEGER, TypeName.FLOAT, TypeName.CURRENCY, TypeName.PERCENTAGE}
+
+
+def clean_column(
+    values,
+    *,
+    target_type: TypeName | str | None = None,
+    null_values=None,
+    locale: str | None = None,
+    locale_preference: str | None = None,
+    true_values=None,
+    false_values=None,
+    percent_as_fraction: bool = True,
+    integers: bool = True,
+) -> CleanResult:
+    """Clean a column to ``target_type``, inferring the type when not given.
+
+    ``values`` is materialised once up front, so a one-shot iterable
+    (generator) is safe: inference and cleaning see the same data, and counts
+    stay consistent.
+
+    Args:
+        values: The column to clean. Consumed exactly once.
+        target_type: A :class:`TypeName` (or its string value) to force. When
+            ``None`` the type is inferred via :func:`typemonkey.infer.infer_type`
+            and that result — including its detected ``locale`` — drives the
+            cleaning.
+        null_values: Null spellings (see :func:`typemonkey.nulls.is_null`).
+        locale: Number locale for numeric targets. When ``None`` it is taken
+            from inference (auto-detected from the data), or detected directly
+            for a forced numeric ``target_type``.
+        locale_preference: ``"us"``/``"eu"`` hint for date parsing.
+        true_values: Override truthy boolean vocabulary.
+        false_values: Override falsy boolean vocabulary.
+        percent_as_fraction: Scale percents by 1/100 (see
+            :func:`typemonkey.numbers.clean_numeric`).
+        integers: Return whole numbers as ``int`` (see
+            :func:`typemonkey.numbers.clean_numeric`).
+
+    Returns:
+        A :class:`CleanResult` whose ``values`` align 1:1 with ``values`` and
+        whose ``target_type`` echoes the inferred or forced type. For ``STRING``
+        targets every non-null value is cleanmonkey-normalised and never a
+        failure; for ``NULL`` every value is ``None`` and ``null_count`` equals
+        the input length.
+    """
+    vals = list(values)  # materialise once — safe for generators
+
+    inferred_locale: str | None = None
+    if target_type is None:
+        profile = infer_type(
+            vals,
+            null_values=null_values,
+            locale=locale,
+            locale_preference=locale_preference,
+            true_values=true_values,
+            false_values=false_values,
+        )
+        target = profile.type
+        inferred_locale = profile.locale
+    else:
+        target = TypeName(target_type)
+
+    if target in _NUMERIC:
+        # Honour an explicit locale, else the one inference detected, else
+        # detect it directly (forced numeric target with no inference step).
+        effective_locale = locale or inferred_locale or detect_number_locale(vals)
+        return clean_numeric(
+            vals,
+            locale=effective_locale,
+            null_values=null_values,
+            percent_as_fraction=percent_as_fraction,
+            integers=integers,
+            target_type=target,
+        )
+    if target is TypeName.BOOLEAN:
+        return clean_boolean(
+            vals,
+            true_values=true_values,
+            false_values=false_values,
+            null_values=null_values,
+        )
+    if target is TypeName.DATE:
+        return _clean_dates(vals, null_values, locale_preference)
+    if target is TypeName.NULL:
+        return CleanResult(
+            values=[None] * len(vals),
+            target_type=TypeName.NULL,
+            null_count=len(vals),
+        )
+    return _clean_strings(vals, null_values)
+
+
+def _clean_dates(values, null_values, locale_preference) -> CleanResult:
+    """Parse a date column via datemonkey, preserving null/failure distinction."""
+    vals = list(values)
+    null_mask = [is_null(v, null_values) for v in vals]
+    # datemonkey treats None as a null/failure; feed it None for our nulls so
+    # the row indices line up.
+    feed = [None if null_mask[i] else vals[i] for i in range(len(vals))]
+    batch = parse_dates(feed, locale_preference=locale_preference)
+    # datemonkey returns an *empty* ``results`` list when no value in the batch
+    # parses, and otherwise one result per row tagged with ``row_index``. Map by
+    # ``row_index`` and walk our own indices so output stays 1:1 with the input
+    # even when zero values parsed (every non-null then becomes a failure).
+    by_index = {r.row_index: r for r in batch.results}
+    out: list[object] = []
+    failures: list[tuple[int, str]] = []
+    for i in range(len(vals)):
+        if null_mask[i]:
+            out.append(None)
+            continue
+        result = by_index.get(i)
+        if result is not None and result.parsed is not None:
+            out.append(result.parsed)
+        else:
+            out.append(None)
+            failures.append((i, str(vals[i])))
+    return CleanResult(
+        values=out,
+        target_type=TypeName.DATE,
+        null_count=sum(null_mask),
+        failures=failures,
+    )
+
+
+def _clean_strings(values, null_values) -> CleanResult:
+    """Normalise a string column with cleanmonkey; nulls become ``None``."""
+    out: list[object] = []
+    null_count = 0
+    for v in values:
+        if is_null(v, null_values):
+            out.append(None)
+            null_count += 1
+        else:
+            out.append(cleanmonkey.clean(str(v)))
+    return CleanResult(
+        values=out,
+        target_type=TypeName.STRING,
+        null_count=null_count,
+    )