datemonkey 0.1.0__tar.gz → 0.2.0__tar.gz

{datemonkey-0.1.0/src/datemonkey.egg-info → datemonkey-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datemonkey
-Version: 0.1.0
+Version: 0.2.0
 Summary: Batch date parsing with ambiguity detection, confidence scores, and format lock-in.
 Author-email: RexBytes <pythonic@rexbytes.com>
 License-Expression: MIT
@@ -21,6 +21,12 @@ Classifier: Topic :: Text Processing
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: hypothesis; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
 Dynamic: license-file
 
 # datemonkey
@@ -193,6 +199,19 @@ Convert an Excel serial date number to a Python datetime.
 
 datemonkey is designed to work well as a tool for large language models. Date parsing is a common source of silent errors in LLM-driven data pipelines — ambiguous formats lead to wrong guesses, wasted tokens on retries, and broken downstream logic. datemonkey reduces that complexity: a single call returns a structured result with the detected format, confidence level, and any ambiguities — no multi-step prompting or validation loops required. Fewer tokens in, reliable answers out.
 
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for release history.
+
+## Development & review
+
+datemonkey is hardened with a competitive multi-model review methodology. The
+self-contained kit lives in [`review-kit/`](review-kit/):
+
+- [`review-kit/CONTRIBUTING.md`](review-kit/CONTRIBUTING.md) — testing philosophy and the review-panel process
+- [`review-kit/LIMITATIONS.md`](review-kit/LIMITATIONS.md) — **deliberate** design tradeoffs (DD/MM ambiguity, the Excel leap-year bug, the two-digit-year pivot, format lock-in). Read this before "fixing" behaviour that looks wrong.
+- [`review-kit/RELEASE_READINESS.md`](review-kit/RELEASE_READINESS.md) — the release rubric; run `python review-kit/scripts/readiness.py`.
+
 ## License
 
 MIT

{datemonkey-0.1.0 → datemonkey-0.2.0}/README.md

@@ -168,6 +168,19 @@ Convert an Excel serial date number to a Python datetime.
 
 datemonkey is designed to work well as a tool for large language models. Date parsing is a common source of silent errors in LLM-driven data pipelines — ambiguous formats lead to wrong guesses, wasted tokens on retries, and broken downstream logic. datemonkey reduces that complexity: a single call returns a structured result with the detected format, confidence level, and any ambiguities — no multi-step prompting or validation loops required. Fewer tokens in, reliable answers out.
 
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for release history.
+
+## Development & review
+
+datemonkey is hardened with a competitive multi-model review methodology. The
+self-contained kit lives in [`review-kit/`](review-kit/):
+
+- [`review-kit/CONTRIBUTING.md`](review-kit/CONTRIBUTING.md) — testing philosophy and the review-panel process
+- [`review-kit/LIMITATIONS.md`](review-kit/LIMITATIONS.md) — **deliberate** design tradeoffs (DD/MM ambiguity, the Excel leap-year bug, the two-digit-year pivot, format lock-in). Read this before "fixing" behaviour that looks wrong.
+- [`review-kit/RELEASE_READINESS.md`](review-kit/RELEASE_READINESS.md) — the release rubric; run `python review-kit/scripts/readiness.py`.
+
 ## License
 
 MIT

{datemonkey-0.1.0 → datemonkey-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "datemonkey"
-version = "0.1.0"
+version = "0.2.0"
 description = "Batch date parsing with ambiguity detection, confidence scores, and format lock-in."
 readme = "README.md"
 license = "MIT"
@@ -26,6 +26,9 @@ classifiers = [
     "Topic :: Text Processing",
 ]
 
+[project.optional-dependencies]
+dev = ["pytest", "pytest-cov", "hypothesis", "ruff", "mypy"]
+
 [project.scripts]
 datemonkey = "datemonkey.cli:main"
 
@@ -40,3 +43,11 @@ where = ["src"]
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 pythonpath = ["src"]
+
+[tool.ruff]
+src = ["src", "tests"]
+
+[tool.mypy]
+files = ["src"]
+python_version = "3.9"
+ignore_missing_imports = true

{datemonkey-0.1.0 → datemonkey-0.2.0}/src/datemonkey/__init__.py

@@ -31,7 +31,7 @@ from .models import (
 )
 from .parser import parse_dates
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 
 __all__ = [
     # Core API

{datemonkey-0.1.0 → datemonkey-0.2.0}/src/datemonkey/cli.py

@@ -10,35 +10,58 @@ from typing import Optional
 
 from .detector import detect_format
 from .formats import ALL_FORMATS
-from .models import Confidence
 from .parser import parse_dates
 
 
+def _extract_column(f, col: int, skip_header: bool) -> list[str]:
+    """Pull one CSV column from an open text stream."""
+    if col < 0:
+        print("Error: --column must be a non-negative integer", file=sys.stderr)
+        sys.exit(1)
+    reader = csv.reader(f)
+    values = []
+    skipped = 0
+    for i, row in enumerate(reader):
+        if skip_header and i == 0:
+            continue
+        if col < len(row):
+            values.append(row[col])
+        elif row:
+            # Non-empty row missing the requested column: don't drop it
+            # silently — report the data loss to stderr.
+            skipped += 1
+    if skipped:
+        print(
+            f"Warning: {skipped} row(s) had no column {col}; skipped.",
+            file=sys.stderr,
+        )
+    return values
+
+
+def _read_lines(lines, skip_header: bool) -> list[str]:
+    """Read non-empty stripped lines, optionally dropping a header row."""
+    stripped = [line.strip() for line in lines]
+    if skip_header and stripped:
+        stripped = stripped[1:]
+    return [ln for ln in stripped if ln]
+
+
 def _read_values(args: argparse.Namespace) -> list[str]:
-    """Read date values from arguments or stdin."""
+    """Read date values from arguments, a file, or stdin."""
     if args.values:
         return args.values
 
     if args.file:
         with open(args.file) as f:
             if args.column is not None:
-                if args.column < 0:
-                    print("Error: --column must be a non-negative integer", file=sys.stderr)
-                    sys.exit(1)
-                reader = csv.reader(f)
-                col = args.column
-                values = []
-                for i, row in enumerate(reader):
-                    if args.skip_header and i == 0:
-                        continue
-                    if col < len(row):
-                        values.append(row[col])
-                return values
-            else:
-                return [line.strip() for line in f if line.strip()]
+                return _extract_column(f, args.column, args.skip_header)
+            return _read_lines(f, args.skip_header)
 
     if not sys.stdin.isatty():
-        return [line.strip() for line in sys.stdin if line.strip()]
+        # --column and --skip-header apply to piped CSV too, not only to --file.
+        if args.column is not None:
+            return _extract_column(sys.stdin, args.column, args.skip_header)
+        return _read_lines(sys.stdin, args.skip_header)
 
     print("No input provided. Pass values as arguments, via --file, or pipe to stdin.", file=sys.stderr)
     sys.exit(1)
@@ -87,12 +110,12 @@ def cmd_detect(args: argparse.Namespace) -> None:
             print(f"\n  AMBIGUOUS: {', '.join(a.value for a in result.ambiguities)}")
 
         if result.candidates:
-            print(f"\n  Top candidates:")
+            print("\n  Top candidates:")
             for c in result.candidates[:5]:
                 print(f"    {c.format.label:40s} {c.match_count}/{c.sample_size} matches")
 
         if result.warnings:
-            print(f"\n  Warnings:")
+            print("\n  Warnings:")
             for w in result.warnings:
                 print(f"    - {w}")
 
@@ -169,7 +192,7 @@ def main(argv: Optional[list[str]] = None) -> None:
         prog="datemonkey",
         description="Batch date parsing with ambiguity detection.",
     )
-    ap.add_argument("--version", action="version", version="datemonkey 0.1.0")
+    ap.add_argument("--version", action="version", version="datemonkey 0.2.0")
 
     sub = ap.add_subparsers(dest="command", help="Available commands")
 

{datemonkey-0.1.0 → datemonkey-0.2.0}/src/datemonkey/detector.py

@@ -11,10 +11,10 @@ from typing import Any, Optional, Sequence
 
 from .formats import (
     ALL_FORMATS,
-    AMBIGUOUS_PAIRS,
     could_be_excel_serial,
     get_ambiguous_partner,
     is_date_like,
+    normalize_locale,
 )
 from .models import (
     AmbiguityType,
@@ -185,8 +185,10 @@ def detect_format(
             ],
         )
 
-    # Score all candidate formats
-    test_formats = formats or ALL_FORMATS
+    # Score all candidate formats. Use `is not None` (not truthiness) so an
+    # explicit empty list means "test no formats" rather than silently falling
+    # back to the full catalogue — the docstring promises None alone defaults.
+    test_formats = formats if formats is not None else ALL_FORMATS
     candidates = _score_candidates(date_like, test_formats)
 
     if not candidates:
@@ -212,46 +214,55 @@ def detect_format(
     # Check DD/MM vs MM/DD ambiguity
     ambig_partner = _check_day_month_ambiguity(date_like, best, candidates)
     if ambig_partner is not None:
-        # Try to resolve from data
+        # Try to resolve from data. _check_day_month_ambiguity only returns a
+        # partner with an *equal* match count, so _resolve_day_month can only
+        # confirm `best` (some value parses under best but not the partner) or
+        # report it as truly ambiguous — it can never name the partner as the
+        # winner here, so `best` never needs swapping.
         resolved = _resolve_day_month(date_like, best.format, ambig_partner.format)
-        if resolved is not None:
-            # Data resolves it — pick the right one
-            if resolved != best.format:
-                # Swap: the partner is actually the correct one
-                for c in candidates:
-                    if c.format == resolved:
-                        best = c
-                        break
-        else:
+        if resolved is None:
             # Truly ambiguous
             ambiguities.append(AmbiguityType.DAY_MONTH_SWAP)
             warnings.append(
                 f"Ambiguous: cannot distinguish {best.format.label} from "
                 f"{ambig_partner.format.label} using data alone."
             )
-            # Apply locale preference if provided
+            # Apply locale preference if provided. Choose between the two
+            # ambiguous candidates only (`best` and its partner `ambig_partner`)
+            # — never scan all candidates for any %m/%d format, or a custom
+            # `formats=` list could surface an unrelated MM/DD format (e.g.
+            # US_DASH for slash data) that cannot even parse the values.
             if locale_preference:
-                lp = locale_preference.lower()
-                if lp in ("us", "en_us", "en-us", "american"):
-                    # Prefer MM/DD
-                    for c in candidates:
-                        if c.format.pattern.startswith("%m"):
-                            best = c
-                            break
+                lp = normalize_locale(locale_preference)
+                if lp == "us":
+                    # Prefer MM/DD (the %m side of the ambiguous pair).
+                    best = (
+                        best
+                        if best.format.pattern.startswith("%m")
+                        else ambig_partner
+                    )
                     warnings.append(
                         f"Locale preference '{locale_preference}' applied: "
                         f"using {best.format.label}."
                     )
-                elif lp in ("eu", "european", "en_gb", "en-gb", "british", "de", "fr", "es", "it"):
-                    # Prefer DD/MM
-                    for c in candidates:
-                        if c.format.pattern.startswith("%d"):
-                            best = c
-                            break
+                elif lp == "eu":
+                    # Prefer DD/MM (the %d side of the ambiguous pair).
+                    best = (
+                        best
+                        if best.format.pattern.startswith("%d")
+                        else ambig_partner
+                    )
                     warnings.append(
                         f"Locale preference '{locale_preference}' applied: "
                         f"using {best.format.label}."
                     )
+                else:
+                    # Unrecognised hint: do not silently ignore it — say so, so
+                    # the ambiguity is not mistaken for "resolved by locale".
+                    warnings.append(
+                        f"Locale preference '{locale_preference}' not "
+                        f"recognized (use 'us' or 'eu'); ignoring."
+                    )
 
     # Check two-digit year
     if _has_two_digit_year(best.format):
@@ -261,14 +272,24 @@ def detect_format(
             "00-68 as 2000-2068 and 69-99 as 1969-1999."
         )
 
-    # Check mixed formats (multiple candidates with high match counts)
+    # Check mixed formats (multiple candidates with high match counts).
+    # Compare against the strongest candidate that is neither `best` itself nor
+    # its DD/MM-vs-MM/DD partner. Indexing candidates[1] blindly is wrong once a
+    # locale_preference has reassigned `best` to candidates[1]: the "second"
+    # would then be `best` again, producing a self-referential MIXED_FORMATS
+    # warning on the eu branch but not the us branch.
     if len(candidates) >= 2:
-        second = candidates[1]
-        # If second-best matches a significant portion and is a different "family"
-        if (
-            second.match_count >= len(date_like) * 0.2
-            and get_ambiguous_partner(best.format) != second.format
-        ):
+        partner = get_ambiguous_partner(best.format)
+        second = next(
+            (
+                c
+                for c in candidates
+                if c.format != best.format and c.format != partner
+            ),
+            None,
+        )
+        # If the next distinct family matches a significant portion, flag it.
+        if second is not None and second.match_count >= len(date_like) * 0.2:
             ambiguities.append(AmbiguityType.MIXED_FORMATS)
             warnings.append(
                 f"Possible mixed formats: {best.format.label} "
@@ -286,9 +307,25 @@ def detect_format(
     else:
         confidence = Confidence.LOW
 
-    # Assign confidence to candidates
+    # Assign confidence to candidates. `FormatCandidate.confidence` means
+    # "confidence if this format were chosen", so it must agree with the
+    # headline value the same format would produce as the pick — otherwise the
+    # same DateFormat reports two different numbers.
+    #   - the chosen format carries the headline confidence directly;
+    #   - best's unresolved-swap partner has the SAME counterfactual headline
+    #     (LOW), so mirror it rather than letting a full match fall to MEDIUM;
+    #   - everything else gets a per-format estimate (an ambiguous-pair format
+    #     is capped below HIGH only while the swap is actually unresolved).
+    swap_unresolved = AmbiguityType.DAY_MONTH_SWAP in ambiguities
+    partner_of_best = get_ambiguous_partner(best.format)
     for c in candidates:
-        if c.match_count == len(date_like) and get_ambiguous_partner(c.format) is None:
+        if c.format == best.format:
+            c.confidence = confidence
+        elif swap_unresolved and c.format == partner_of_best:
+            c.confidence = confidence
+        elif c.match_count == len(date_like) and not (
+            swap_unresolved and get_ambiguous_partner(c.format) is not None
+        ):
             c.confidence = Confidence.HIGH
         elif c.match_count >= len(date_like) * 0.8:
             c.confidence = Confidence.MEDIUM

{datemonkey-0.1.0 → datemonkey-0.2.0}/src/datemonkey/excel.py

@@ -12,6 +12,7 @@ by matching Excel's behavior for compatibility.
 from __future__ import annotations
 
 import datetime
+import math
 from typing import Optional, Union
 
 from .models import Confidence, DateFormat, DateResult
@@ -47,31 +48,56 @@ def excel_serial_to_datetime(
     except (ValueError, TypeError):
         return None
 
-    if num < _MIN_SERIAL or num > _MAX_SERIAL:
+    # NaN and infinity survive float() but cannot be converted to a day count:
+    # int(nan) raises ValueError and int(inf) raises OverflowError, and NaN
+    # comparisons are all False so the range check below would not stop them.
+    # They are "invalid" per the contract, so map to None rather than crash.
+    if not math.isfinite(num):
         return None
 
-    # Handle the Lotus 1-2-3 leap year bug:
-    # Excel thinks 1900-02-29 exists (serial 60).
-    # For serials > 60, subtract 1 to correct the off-by-one.
-    if int(num) == 60:
-        # Serial 60 is the non-existent Feb 29, 1900.
-        # Return March 1, 1900 to match common convention.
-        return datetime.datetime(1900, 3, 1)
-
-    days = int(num)
-    fraction = num - days
+    # Bound on the integer day part: a serial like 2958465.5 (noon on the last
+    # representable day, 9999-12-31) is in range even though 2958465.5 > the
+    # integer _MAX_SERIAL. Comparing the float against the int max wrongly
+    # rejected every fractional time on the final day.
+    if num < _MIN_SERIAL or int(num) > _MAX_SERIAL:
+        return None
 
-    if days > 60:
-        days -= 1
+    try:
+        # Handle the Lotus 1-2-3 leap year bug:
+        # Excel thinks 1900-02-29 exists (serial 60).
+        # For serials > 60, subtract 1 to correct the off-by-one.
+        if int(num) == 60:
+            # Serial 60 is the non-existent Feb 29, 1900. Map to March 1, 1900,
+            # preserving any fractional time-of-day component (the fraction is
+            # otherwise silently dropped at this one serial).
+            dt = datetime.datetime(1900, 3, 1)
+            dt += _time_of_day(num - 60)
+            return dt
+
+        days = int(num)
+        fraction = num - days
+
+        if days > 60:
+            days -= 1
+
+        dt = _EXCEL_EPOCH + datetime.timedelta(days=days)
+        dt += _time_of_day(fraction)
+        return dt
+    except (OverflowError, ValueError):
+        # Defensive: any residual range/overflow surprise -> invalid -> None.
+        return None
 
-    dt = _EXCEL_EPOCH + datetime.timedelta(days=days)
 
-    # Add time component from fractional part
-    if fraction > 0:
-        total_seconds = round(fraction * 86400)
-        dt += datetime.timedelta(seconds=total_seconds)
+def _time_of_day(fraction: float) -> datetime.timedelta:
+    """Convert a day fraction to a timedelta within the same calendar day.
 
-    return dt
+    A fraction at or above 86399.5/86400 (≈ the last half-second of a day)
+    would round up to a full 86400 seconds and silently roll the date into the
+    next day; clamp to 86399 so the time stays inside the intended day.
+    """
+    if fraction <= 0:
+        return datetime.timedelta(0)
+    return datetime.timedelta(seconds=min(round(fraction * 86400), 86399))
 
 
 def parse_excel_serial(

{datemonkey-0.1.0 → datemonkey-0.2.0}/src/datemonkey/formats.py

@@ -119,8 +119,36 @@ def could_be_excel_serial(value: str) -> bool:
         return False
     num = float(s)
     # Excel serial dates: 1 = 1900-01-01, reasonable range up to ~2958465 (9999-12-31)
-    # But practically, most dates are between 1 (1900) and ~55000 (2050+)
-    return 1 <= num <= 2958465
+    # But practically, most dates are between 1 (1900) and ~55000 (2050+).
+    # Bound on the integer day part so a valid fractional time on the last day
+    # (e.g. "2958465.5") is still recognised, matching excel_serial_to_datetime.
+    return 1 <= num and int(num) <= 2958465
+
+
+# ── Locale preference normalisation ──────────────────────────────────────
+
+US_LOCALE_ALIASES = frozenset({"us", "en_us", "en-us", "american"})
+EU_LOCALE_ALIASES = frozenset(
+    {"eu", "european", "en_gb", "en-gb", "british", "de", "fr", "es", "it"}
+)
+
+
+def normalize_locale(locale_preference: Optional[str]) -> Optional[str]:
+    """Normalise a locale_preference hint to ``"us"``, ``"eu"``, or ``None``.
+
+    Trims surrounding whitespace and lowercases before matching, so values like
+    ``" eu "`` or ``"EU"`` resolve. Returns ``None`` for both a missing
+    preference and an *unrecognised* one — callers that must tell those apart
+    should also test ``locale_preference`` itself.
+    """
+    if not locale_preference:
+        return None
+    lp = locale_preference.strip().lower()
+    if lp in US_LOCALE_ALIASES:
+        return "us"
+    if lp in EU_LOCALE_ALIASES:
+        return "eu"
+    return None
 
 
 def get_ambiguous_partner(fmt: DateFormat) -> Optional[DateFormat]:

{datemonkey-0.1.0 → datemonkey-0.2.0}/src/datemonkey/models.py

@@ -166,7 +166,11 @@ class BatchResult:
     @property
     def ok(self) -> bool:
         """True if all values were parsed successfully."""
-        return self.failed_count == 0 and self.total > 0
+        # Require every value to have parsed — not merely "nothing failed".
+        # Early-return paths (undetectable format, strict refusal, all-blank
+        # input) leave parsed_count == failed_count == 0 with total > 0; those
+        # must report ok == False, not True.
+        return self.total > 0 and self.parsed_count == self.total
 
     @property
     def success_ratio(self) -> float:

{datemonkey-0.1.0 → datemonkey-0.2.0}/src/datemonkey/parser.py

@@ -11,7 +11,7 @@ from typing import Any, Optional, Sequence, Union
 
 from .detector import detect_format
 from .excel import EXCEL_SERIAL_FORMAT, parse_excel_serial
-from .formats import could_be_excel_serial
+from .formats import could_be_excel_serial, normalize_locale
 from .models import (
     AmbiguityType,
     BatchResult,
@@ -68,6 +68,30 @@ def _parse_single(
         )
 
 
+def _all_failed(
+    values: Sequence[Any],
+    fmt: Optional[DateFormat],
+    reason: str,
+) -> list[DateResult]:
+    """Build one FAILED DateResult per value for an early-return path.
+
+    Keeps the batch invariant ``total == failed_count == len(results)`` and
+    lets callers inspect ``batch.failed`` even when parsing was refused or no
+    format could be determined (otherwise ``results`` would be empty while
+    ``total`` reported N values).
+    """
+    return [
+        DateResult(
+            original=v,
+            format_used=fmt,
+            confidence=Confidence.FAILED,
+            warnings=[reason],
+            row_index=i,
+        )
+        for i, v in enumerate(values)
+    ]
+
+
 def parse_dates(
     values: Sequence[Any],
     *,
@@ -86,8 +110,11 @@ def parse_dates(
             If None, auto-detect from the values.
         locale_preference: Hint for resolving DD/MM vs MM/DD ambiguity
             during auto-detection. "us" for MM/DD, "eu" for DD/MM.
-        strict: If True, treat any ambiguity as a failure (don't parse
-            ambiguous values, report them as errors).
+        strict: If True, refuse to parse when the batch has an unresolved
+            DD/MM vs MM/DD (day/month swap) ambiguity and no recognized
+            locale_preference was supplied to break it. Other ambiguity types
+            (two-digit year, mixed formats) are reported as warnings but do not
+            block parsing.
 
     Returns:
         BatchResult containing per-value results, detected format,
@@ -120,25 +147,40 @@ def parse_dates(
         resolved_format = detection_result.format
 
     if resolved_format is None:
+        reason = "Could not determine date format."
         return BatchResult(
+            results=_all_failed(values, None, reason),
             total=len(values),
-            warnings=["Could not determine date format."],
+            failed_count=len(values),
+            warnings=[reason],
             format_detection=detection_result,
         )
 
-    # In strict mode, refuse to parse if ambiguous
-    if strict and detection_result and detection_result.is_ambiguous:
-        if AmbiguityType.DAY_MONTH_SWAP in detection_result.ambiguities:
-            return BatchResult(
-                total=len(values),
-                detected_format=resolved_format,
-                warnings=[
-                    "Strict mode: refusing to parse due to DD/MM vs MM/DD "
-                    "ambiguity. Provide a format or locale_preference to resolve."
-                ]
-                + detection_result.warnings,
-                format_detection=detection_result,
-            )
+    # In strict mode, refuse to parse if ambiguous — UNLESS the caller supplied
+    # a *recognized* locale_preference, the documented escape hatch for the
+    # DD/MM vs MM/DD case. Gate on whether the preference actually resolves the
+    # ambiguity (normalize_locale), not merely on whether some string was
+    # passed: an unrecognized/whitespace/empty hint (e.g. "en", " eu ", "") is
+    # never applied by detection, so it must NOT silently disable the refusal.
+    if (
+        strict
+        and detection_result
+        and detection_result.is_ambiguous
+        and normalize_locale(locale_preference) is None
+        and AmbiguityType.DAY_MONTH_SWAP in detection_result.ambiguities
+    ):
+        reason = (
+            "Strict mode: refusing to parse due to DD/MM vs MM/DD "
+            "ambiguity. Provide a format or locale_preference to resolve."
+        )
+        return BatchResult(
+            results=_all_failed(values, resolved_format, reason),
+            detected_format=resolved_format,
+            total=len(values),
+            failed_count=len(values),
+            warnings=[reason] + detection_result.warnings,
+            format_detection=detection_result,
+        )
 
     # Parse each value with the locked-in format
     results: list[DateResult] = []

{datemonkey-0.1.0 → datemonkey-0.2.0/src/datemonkey.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datemonkey
-Version: 0.1.0
+Version: 0.2.0
 Summary: Batch date parsing with ambiguity detection, confidence scores, and format lock-in.
 Author-email: RexBytes <pythonic@rexbytes.com>
 License-Expression: MIT
@@ -21,6 +21,12 @@ Classifier: Topic :: Text Processing
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: hypothesis; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
 Dynamic: license-file
 
 # datemonkey
@@ -193,6 +199,19 @@ Convert an Excel serial date number to a Python datetime.
 
 datemonkey is designed to work well as a tool for large language models. Date parsing is a common source of silent errors in LLM-driven data pipelines — ambiguous formats lead to wrong guesses, wasted tokens on retries, and broken downstream logic. datemonkey reduces that complexity: a single call returns a structured result with the detected format, confidence level, and any ambiguities — no multi-step prompting or validation loops required. Fewer tokens in, reliable answers out.
 
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for release history.
+
+## Development & review
+
+datemonkey is hardened with a competitive multi-model review methodology. The
+self-contained kit lives in [`review-kit/`](review-kit/):
+
+- [`review-kit/CONTRIBUTING.md`](review-kit/CONTRIBUTING.md) — testing philosophy and the review-panel process
+- [`review-kit/LIMITATIONS.md`](review-kit/LIMITATIONS.md) — **deliberate** design tradeoffs (DD/MM ambiguity, the Excel leap-year bug, the two-digit-year pivot, format lock-in). Read this before "fixing" behaviour that looks wrong.
+- [`review-kit/RELEASE_READINESS.md`](review-kit/RELEASE_READINESS.md) — the release rubric; run `python review-kit/scripts/readiness.py`.
+
 ## License
 
 MIT