patchground 0.1.0__py3-none-any.whl

patchground/catalog/cache-expiry/solution/reference.patch

@@ -0,0 +1,41 @@
+diff --git a/src/profilecache/cache.py b/src/profilecache/cache.py
+index 497b49d..90f2a16 100644
+--- a/src/profilecache/cache.py
++++ b/src/profilecache/cache.py
+@@ -13,11 +13,12 @@ Clock = Callable[[], float]
+ @dataclass
+ class _Entry:
+     value: Any
+-    ttl: float
+     deadline: float
+
+
+ def _validate_ttl(ttl: float) -> float:
++    if not ttl > 0:
++        raise ValueError(f"ttl must be positive, got {ttl!r}")
+     return ttl
+
+
+@@ -36,7 +37,7 @@ class TTLCache:
+     def set(self, key: Hashable, value: Any, ttl: float | None = None) -> None:
+         """Store ``value`` under ``key`` for ``ttl`` seconds (default: the cache default)."""
+         ttl = _validate_ttl(self._default_ttl if ttl is None else ttl)
+-        self._entries[key] = _Entry(value, ttl, self._clock() + ttl)
++        self._entries[key] = _Entry(value, self._clock() + ttl)
+
+     def get(self, key: Hashable, default: Any = None) -> Any:
+         """Return the live value for ``key``, or ``default`` if absent or expired."""
+@@ -47,7 +48,6 @@ class TTLCache:
+         if self._expired(entry, now):
+             del self._entries[key]
+             return default
+-        entry.deadline = now + entry.ttl
+         return entry.value
+
+     def __contains__(self, key: Hashable) -> bool:
+@@ -64,4 +64,4 @@ class TTLCache:
+
+     @staticmethod
+     def _expired(entry: _Entry, now: float) -> bool:
+-        return now > entry.deadline
++        return now >= entry.deadline

patchground/catalog/cache-expiry/workspace/pyproject.toml

@@ -0,0 +1,8 @@
+[project]
+name = "profilecache"
+version = "0.2.0"
+requires-python = ">=3.12"
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]

patchground/catalog/cache-expiry/workspace/src/profilecache/__init__.py

@@ -0,0 +1,6 @@
+"""In-memory caching for user profiles."""
+
+from profilecache.cache import TTLCache
+from profilecache.client import ProfileClient
+
+__all__ = ["ProfileClient", "TTLCache"]

patchground/catalog/cache-expiry/workspace/src/profilecache/cache.py

@@ -0,0 +1,67 @@
+"""A small in-memory cache whose entries expire after a time to live (TTL)."""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable, Hashable
+from dataclasses import dataclass
+from typing import Any
+
+Clock = Callable[[], float]
+
+
+@dataclass
+class _Entry:
+    value: Any
+    ttl: float
+    deadline: float
+
+
+def _validate_ttl(ttl: float) -> float:
+    return ttl
+
+
+class TTLCache:
+    """Maps keys to values for a limited time.
+
+    Time comes from an injectable ``clock`` returning seconds, so callers and
+    tests control it. Expired entries are dropped lazily when they are looked at.
+    """
+
+    def __init__(self, default_ttl: float = 60.0, clock: Clock = time.monotonic) -> None:
+        self._default_ttl = _validate_ttl(default_ttl)
+        self._clock = clock
+        self._entries: dict[Hashable, _Entry] = {}
+
+    def set(self, key: Hashable, value: Any, ttl: float | None = None) -> None:
+        """Store ``value`` under ``key`` for ``ttl`` seconds (default: the cache default)."""
+        ttl = _validate_ttl(self._default_ttl if ttl is None else ttl)
+        self._entries[key] = _Entry(value, ttl, self._clock() + ttl)
+
+    def get(self, key: Hashable, default: Any = None) -> Any:
+        """Return the live value for ``key``, or ``default`` if absent or expired."""
+        entry = self._entries.get(key)
+        if entry is None:
+            return default
+        now = self._clock()
+        if self._expired(entry, now):
+            del self._entries[key]
+            return default
+        entry.deadline = now + entry.ttl
+        return entry.value
+
+    def __contains__(self, key: Hashable) -> bool:
+        entry = self._entries.get(key)
+        return entry is not None and not self._expired(entry, self._clock())
+
+    def purge_expired(self) -> int:
+        """Drop every expired entry and return how many were removed."""
+        now = self._clock()
+        stale = [key for key, entry in self._entries.items() if self._expired(entry, now)]
+        for key in stale:
+            del self._entries[key]
+        return len(stale)
+
+    @staticmethod
+    def _expired(entry: _Entry, now: float) -> bool:
+        return now > entry.deadline

patchground/catalog/cache-expiry/workspace/src/profilecache/client.py

@@ -0,0 +1,38 @@
+"""Profile client that avoids refetching recently loaded profiles."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from profilecache.cache import TTLCache
+
+Profile = dict[str, Any]
+
+_MISSING = object()
+
+
+class ProfileClient:
+    """Loads profiles through ``fetch`` and keeps them in a cache for ``ttl`` seconds."""
+
+    def __init__(
+        self,
+        fetch: Callable[[str], Profile],
+        cache: TTLCache | None = None,
+        ttl: float = 30.0,
+    ) -> None:
+        self._fetch = fetch
+        self._cache = cache if cache is not None else TTLCache()
+        self._ttl = ttl
+
+    def get(self, user_id: str) -> Profile:
+        cached = self._cache.get(user_id, _MISSING)
+        if cached is not _MISSING:
+            return cached
+        profile = self._fetch(user_id)
+        self._cache.set(user_id, profile, ttl=self._ttl)
+        return profile
+
+    def update(self, user_id: str, profile: Profile) -> None:
+        """Replace the cached profile after the user edited it."""
+        self._cache.set(user_id, profile, ttl=self._ttl)

patchground/catalog/csv-import-row-errors/TICKET.md

@@ -0,0 +1,97 @@
+# Let the stock importer report bad rows instead of stopping at the first one
+
+**Reported by:** warehouse operations
+**Component:** `stockimport`
+
+## Background
+
+`import_inventory(text)` reads the nightly stock feed (`sku,quantity,unit_price`) and returns a list
+of `Item`. It stops with `ImportFailed` at the first problem, so a feed with many bad rows takes many
+re-uploads to fix. The feed data is synthetic in this exercise.
+
+## Request
+
+Add a non-strict mode that returns every valid item together with one error per rejected row. The
+default behavior must not change.
+
+### Public API
+
+```python
+import_inventory(text: str, *, strict: bool = True) -> list[Item] | ImportResult
+```
+
+- `strict=True` (the default) returns `list[Item]` exactly as today.
+- `strict=False` returns `ImportResult(items: list[Item], errors: list[RowError])`.
+- `strict` is keyword-only. `Item`, `RowError`, `ImportResult` and `ImportFailed` already exist in
+  `stockimport/models.py` and are exported from `stockimport`; keep their fields and names.
+- `Item(sku: str, quantity: int, unit_price_cents: int)`.
+- `RowError(line: int, column: str | None, code: str, message: str)`. `message` is free human text
+  and is not part of the contract.
+- `ImportFailed` subclasses `ValueError`, carries the `RowError` as `.error`, and its text is
+  `"line <line>: <message>"`.
+
+### Input format and line numbers
+
+The input is a string. The first physical line is the header; the rest are records. A quoted field
+may contain line breaks, so a record can span several physical lines. Line numbers are 1-based
+physical lines of the text (header = line 1). A record's line is the physical line **where it
+starts**, and the next record's line counts every physical line before it.
+
+### Rules
+
+1. **Header.** The first record must be exactly `sku`, `quantity`, `unit_price` (case-sensitive, in
+   that order, nothing else). Otherwise, including empty text or a blank first line, the import
+   raises `ImportFailed` with `RowError(line=1, column=None, code="bad_header", ...)`, in both modes.
+2. **Malformed CSV.** Only two syntax problems are recognized after the header: text other than a
+   comma or line end right after a closing quote, and a quoted field never closed before the end of
+   the text. Either raises `ImportFailed` with `code="malformed_csv"`, `column=None` and `line` the
+   starting line of the record that contains the problem, in both modes. Non-strict mode returns no
+   partial result in this case. Strict mode still raises the first row error that appears earlier in
+   the text, if there is one.
+3. **Empty lines.** A physical line with no characters at all (outside a quoted field) is skipped
+   and is not an error. It still counts toward line numbers. A line holding only spaces or `""` is a
+   record and is judged by rule 5.
+4. **One error per row.** A rejected row produces exactly one `RowError`, for the first check below
+   that fails. Fields are never trimmed.
+5. **Checks, in this order**
+   1. `wrong_field_count` (column `None`): the record does not have exactly 3 fields.
+   2. `invalid_sku` (column `"sku"`): not one or more of `A-Z`, `0-9` and `-`.
+   3. `duplicate_sku` (column `"sku"`): an earlier row in the same text was accepted with this sku.
+   4. `invalid_quantity` (column `"quantity"`): not one or more ASCII digits `0-9`. Leading zeros are
+      fine (`"007"` is 7). No sign, no spaces, no decimals, no exponent.
+   5. `invalid_price` (column `"unit_price"`): not ASCII digits optionally followed by `.` and one
+      or two ASCII digits (`"12"`, `"12.5"`, `"12.50"`, `"0.29"` are valid; `".5"`, `"5."`, `"12.345"`,
+      `"-1"`, `"1e3"`, `"1,000.00"` are not).
+6. **Cents.** `unit_price_cents` is the exact decimal amount times 100, as an `int`, computed
+   without floating point: `"12"` → 1200, `"12.5"` → 1250, `"0.29"` → 29, `"19.99"` → 1999.
+7. **Duplicates.** The first accepted row for a sku wins and its `Item` is never changed. A row
+   rejected for any reason does not reserve its sku, so a later valid row with the same sku is
+   accepted. A `duplicate_sku` row is itself rejected.
+8. **Order.** `items` are in file order. `errors` are in file order (ascending `line`).
+9. **Strict mode** raises `ImportFailed` for the first error in file order that the non-strict mode
+   would report (rules 1–5 and 7 apply identically); it never reports a later error instead.
+10. **Nothing accepted.** A text with a valid header and no valid rows gives `items == []` in
+    non-strict mode.
+
+## Example
+
+```text
+sku,quantity,unit_price
+A-1,5,19.99
+A-2,x,1.00
+B-1,2,0.29
+
+A-1,9,1.00
+```
+
+`import_inventory(text, strict=False)` returns items `A-1` (5 × 1999) and `B-1` (2 × 29), and errors
+`(line=3, column="quantity", code="invalid_quantity")` and `(line=6, column="sku", code="duplicate_sku")`.
+`import_inventory(text)` raises `ImportFailed` for line 3.
+
+## Notes
+
+- Keep the single-purpose importer in `importer.py`; do not add dependencies.
+- Run `pgnd check` from the session workspace to check your changes in Docker.
+- Add tests for the behavior you implement and keep strict mode unchanged.
+- You may use your own editor and AI tools. The goal is to build and explain a precise change, not
+  only to make the listed cases pass.

patchground/catalog/csv-import-row-errors/challenge.yaml

@@ -0,0 +1,33 @@
+spec_version: "0.1"
+id: csv-import-row-errors
+version: 1.0.1
+title: Report bad rows from the stock importer instead of stopping at the first
+type: feature
+summary: >-
+  A strict CSV stock importer aborts at the first bad row. Add a non-strict mode that returns the
+  valid items and one precise error per rejected row, keeping strict behavior unchanged.
+languages: [python]
+tags: [csv, validation, parsing, error-handling]
+difficulty: intermediate
+timebox_minutes: 45
+ai_policy: allowed
+environment:
+  dockerfile: environment/Dockerfile
+  services: []
+  test_command: pytest -q -p no:cacheprovider --junitxml=$PG_RESULTS/junit.xml
+checks:
+  visible: checks/visible
+  hidden: checks/hidden
+solution: solution/reference.patch
+expected_paths: [src/stockimport/, tests/]
+hints:
+  - Decide where a failure for one row should stop and where it should only be recorded. Which failures can never be limited to one row?
+  - Look at when a sku is recorded as seen, and at what must be true of a row before it may reserve that sku.
+  - Keep one place that judges a row. Strict and non-strict mode should differ only in what happens to the error it produces.
+debrief:
+  questions: debrief/questions.md
+  focus: [requirements_analysis, test_quality, scope_judgment]
+author: {name: Patchground contributors}
+content_license: CC-BY-4.0
+provenance: generated
+generated_by: {model: "Claude Code via Orca worker (model unverified)", prompt_version: launch-csv-import-v1}

patchground/catalog/csv-import-row-errors/checks/hidden/tests/test_import_hidden.py

@@ -0,0 +1,359 @@
+"""Hidden checks. Each group names the TICKET rule it covers."""
+
+import pytest
+
+from stockimport import ImportFailed, ImportResult, Item, RowError, import_inventory
+
+HEADER = "sku,quantity,unit_price"
+
+
+def doc(*lines, end="\n"):
+    return "\n".join((HEADER, *lines)) + end
+
+
+def lenient(text):
+    return import_inventory(text, strict=False)
+
+
+def shape(errors):
+    return [(e.line, e.column, e.code) for e in errors]
+
+
+def strict_error(text):
+    with pytest.raises(ImportFailed) as caught:
+        import_inventory(text)
+    assert isinstance(caught.value.error, RowError)
+    return caught.value.error
+
+
+# --- Public API -------------------------------------------------------------------------------
+
+
+def test_api_non_strict_returns_import_result_with_lists():
+    result = lenient(doc("A-1,1,1.00"))
+    assert isinstance(result, ImportResult)
+    assert isinstance(result.items, list) and isinstance(result.errors, list)
+    assert result.items == [Item("A-1", 1, 100)]
+    assert result.errors == []
+
+
+def test_api_default_and_explicit_strict_return_a_plain_list():
+    text = doc("A-1,1,1.00", "B-2,3,2.50")
+    expected = [Item("A-1", 1, 100), Item("B-2", 3, 250)]
+    assert import_inventory(text) == expected
+    assert import_inventory(text, strict=True) == expected
+
+
+def test_api_strict_is_keyword_only():
+    with pytest.raises(TypeError):
+        import_inventory(doc("A-1,1,1.00"), False)
+
+
+def test_api_import_failed_text_and_type():
+    with pytest.raises(ValueError, match=r"^line 2: ") as caught:
+        import_inventory(doc("A-1,x,1.00"))
+    assert isinstance(caught.value, ImportFailed)
+    assert caught.value.error.line == 2
+
+
+# --- Rule 1: header -----------------------------------------------------------------------------
+
+BAD_HEADERS = [
+    pytest.param("", id="empty-text"),
+    pytest.param("\n", id="blank-first-line"),
+    pytest.param("\nsku,quantity,unit_price\nA-1,1,1.00\n", id="blank-then-header"),
+    pytest.param("sku,quantity\nA-1,1\n", id="missing-column"),
+    pytest.param("sku,quantity,unit_price,extra\nA-1,1,1.00,x\n", id="extra-column"),
+    pytest.param("sku,qty,unit_price\nA-1,1,1.00\n", id="renamed-column"),
+    pytest.param("quantity,sku,unit_price\n1,A-1,1.00\n", id="reordered"),
+    pytest.param("SKU,quantity,unit_price\nA-1,1,1.00\n", id="case-sensitive"),
+    pytest.param(" sku,quantity,unit_price\nA-1,1,1.00\n", id="not-trimmed"),
+]
+
+
+@pytest.mark.parametrize("text", BAD_HEADERS)
+@pytest.mark.parametrize("strict", [True, False])
+def test_rule1_bad_header_fails_in_both_modes(text, strict):
+    with pytest.raises(ImportFailed) as caught:
+        import_inventory(text, strict=strict)
+    error = caught.value.error
+    assert (error.line, error.column, error.code) == (1, None, "bad_header")
+
+
+def test_rule1_header_only_and_crlf_header_are_valid():
+    assert lenient(HEADER + "\n") == ImportResult([], [])
+    assert lenient(HEADER) == ImportResult([], [])
+    result = lenient(HEADER + "\r\nA-1,2,3.00\r\n")
+    assert result.items == [Item("A-1", 2, 300)] and result.errors == []
+
+
+# --- Rule 2: malformed CSV ----------------------------------------------------------------------
+
+
+def test_rule2_unterminated_quote_reports_the_record_start_line():
+    text = doc("A-1,1,1.00", 'A-2,"5,1.00', "A-3,1,1.00")
+    for strict in (True, False):
+        with pytest.raises(ImportFailed) as caught:
+            import_inventory(text, strict=strict)
+        error = caught.value.error
+        assert (error.line, error.column, error.code) == (3, None, "malformed_csv")
+
+
+def test_rule2_text_after_closing_quote_after_a_multiline_record():
+    text = doc('"A\nB",1,1.00', '"A-1"x,1,1.00')
+    # header = 1, multi-line record = lines 2-3, the broken record starts on line 4
+    with pytest.raises(ImportFailed) as caught:
+        lenient(text)
+    error = caught.value.error
+    assert (error.line, error.column, error.code) == (4, None, "malformed_csv")
+
+
+def test_rule2_non_strict_returns_no_partial_result():
+    text = doc("A-1,1,1.00", "B-2,x,1.00", '"C-3"junk,1,1.00')
+    with pytest.raises(ImportFailed) as caught:
+        lenient(text)
+    assert caught.value.error.code == "malformed_csv"
+
+
+def test_rule2_strict_reports_an_earlier_row_error_before_the_syntax_error():
+    text = doc("A-1,1,1.00", "B-2,x,1.00", '"C-3"junk,1,1.00')
+    error = strict_error(text)
+    assert (error.line, error.code) == (3, "invalid_quantity")
+
+
+# --- Rule 3: empty lines ------------------------------------------------------------------------
+
+
+def test_rule3_empty_lines_are_skipped_but_counted():
+    text = doc("A-1,1,1.00", "", "", "B-2,x,1.00", "", "C-3,1,1.00", "", end="\n\n")
+    result = lenient(text)
+    assert [i.sku for i in result.items] == ["A-1", "C-3"]
+    assert shape(result.errors) == [(5, "quantity", "invalid_quantity")]
+
+
+def test_rule3_crlf_empty_lines_are_skipped_and_counted():
+    text = HEADER + "\r\n\r\nA-1,x,1.00\r\n\r\nB-2,1,1.00\r\n"
+    result = lenient(text)
+    assert [i.sku for i in result.items] == ["B-2"]
+    assert shape(result.errors) == [(3, "quantity", "invalid_quantity")]
+
+
+@pytest.mark.parametrize("line", [" ", '""', "\t"], ids=repr)
+def test_rule3_lines_that_are_not_empty_are_records(line):
+    result = lenient(doc("A-1,1,1.00", line))
+    assert shape(result.errors) == [(3, None, "wrong_field_count")]
+
+
+# --- Rules 4 and 5: one error per row, check order ----------------------------------------------
+
+
+def test_rule5_wrong_field_count_wins_over_everything():
+    result = lenient(doc("a b,1", "A-1,1,1.00,extra", "A-2"))
+    assert shape(result.errors) == [
+        (2, None, "wrong_field_count"),
+        (3, None, "wrong_field_count"),
+        (4, None, "wrong_field_count"),
+    ]
+    assert result.items == []
+
+
+ORDER_CASES = [
+    pytest.param(["bad sku,x,y"], "invalid_sku", "sku", id="sku-before-quantity-and-price"),
+    pytest.param(["A-1,1,1.00", "A-1,x,y"], "duplicate_sku", "sku", id="duplicate-before-quantity"),
+    pytest.param(["A-1,1,1.00", "A-1,1,y"], "duplicate_sku", "sku", id="duplicate-before-price"),
+    pytest.param(["A-1,x,y"], "invalid_quantity", "quantity", id="quantity-before-price"),
+    pytest.param(["A-1,1,y"], "invalid_price", "unit_price", id="price-last"),
+]
+
+
+@pytest.mark.parametrize(("rows", "code", "column"), ORDER_CASES)
+def test_rule5_each_row_gets_only_its_first_failing_check(rows, code, column):
+    result = lenient(doc(*rows))
+    assert len(result.errors) == 1
+    assert (result.errors[0].code, result.errors[0].column) == (code, column)
+    assert result.errors[0].line == len(rows) + 1
+
+
+@pytest.mark.parametrize("sku", ["", "a-1", "A 1", " A-1", "A-1 ", "A_1", "É-1", "A\n1"], ids=repr)
+def test_rule5_invalid_sku(sku):
+    text = HEADER + "\n" + '"' + sku + '"' + ",1,1.00\n"
+    result = lenient(text)
+    assert result.items == []
+    assert shape(result.errors) == [(2, "sku", "invalid_sku")]
+
+
+@pytest.mark.parametrize("sku", ["A", "0", "-", "AB-12-C", "007"], ids=repr)
+def test_rule5_valid_sku(sku):
+    assert lenient(doc(f"{sku},1,1.00")).items == [Item(sku, 1, 100)]
+
+
+@pytest.mark.parametrize("quantity", ["", "-1", "+2", "1.5", "1e2", " 3", "3 ", "٣", "１２", "0x10"], ids=repr)
+def test_rule5_invalid_quantity(quantity):
+    text = HEADER + "\n" + 'A-1,"' + quantity + '",1.00\n'
+    assert shape(lenient(text).errors) == [(2, "quantity", "invalid_quantity")]
+
+
+@pytest.mark.parametrize(("quantity", "value"), [("0", 0), ("7", 7), ("007", 7), ("1000000", 1000000)], ids=repr)
+def test_rule5_valid_quantity(quantity, value):
+    assert lenient(doc(f"A-1,{quantity},1.00")).items == [Item("A-1", value, 100)]
+
+
+BAD_PRICES = ["", ".5", "5.", "12.345", "-1", "+1", "1e3", "1,000.00", " 1", "1 ", "1.0.0", "NaN", "inf", "١٢", "1.٥", "$1"]
+
+
+@pytest.mark.parametrize("price", BAD_PRICES, ids=repr)
+def test_rule5_invalid_price(price):
+    text = HEADER + "\n" + 'A-1,1,"' + price + '"\n'
+    result = lenient(text)
+    assert result.items == []
+    assert shape(result.errors) == [(2, "unit_price", "invalid_price")]
+
+
+# --- Rule 6: exact cents ------------------------------------------------------------------------
+
+CENTS = [
+    ("0", 0),
+    ("0.00", 0),
+    ("12", 1200),
+    ("12.5", 1250),
+    ("12.50", 1250),
+    ("12.05", 1205),
+    ("0.1", 10),
+    ("0.01", 1),
+    ("0.29", 29),
+    ("1.15", 115),
+    ("19.99", 1999),
+    ("4.35", 435),
+    ("1234567.89", 123456789),
+    ("90071992547409.93", 9007199254740993),
+]
+
+
+@pytest.mark.parametrize(("price", "cents"), CENTS, ids=repr)
+def test_rule6_prices_become_exact_integer_cents(price, cents):
+    (item,) = lenient(doc(f"A-1,1,{price}")).items
+    assert item.unit_price_cents == cents
+    assert type(item.unit_price_cents) is int
+
+
+@pytest.mark.parametrize(("price", "cents"), CENTS, ids=repr)
+def test_rule6_strict_and_non_strict_agree_on_cents(price, cents):
+    assert import_inventory(doc(f"A-1,1,{price}")) == [Item("A-1", 1, cents)]
+
+
+# --- Rule 7: duplicates -------------------------------------------------------------------------
+
+
+def test_rule7_first_accepted_row_wins():
+    result = lenient(doc("A-1,5,1.00", "A-1,9,9.00", "A-1,7,7.00"))
+    assert result.items == [Item("A-1", 5, 100)]
+    assert shape(result.errors) == [(3, "sku", "duplicate_sku"), (4, "sku", "duplicate_sku")]
+
+
+@pytest.mark.parametrize(
+    "bad_row",
+    [
+        pytest.param("A-1,x,1.00", id="bad-quantity"),
+        pytest.param("A-1,1,1.005", id="bad-price"),
+        pytest.param("A-1,1", id="wrong-field-count"),
+        pytest.param("A-1,-1,x", id="both-bad"),
+    ],
+)
+def test_rule7_a_rejected_row_does_not_reserve_its_sku(bad_row):
+    result = lenient(doc(bad_row, "A-1,5,2.50"))
+    assert result.items == [Item("A-1", 5, 250)]
+    assert len(result.errors) == 1 and result.errors[0].line == 2
+
+
+def test_rule7_a_multiline_rejected_row_does_not_reserve_its_sku():
+    result = lenient(doc('A-1,"1\n2",1.00', "A-1,3,1.00"))
+    assert result.items == [Item("A-1", 3, 100)]
+    assert shape(result.errors) == [(2, "quantity", "invalid_quantity")]
+
+
+def test_rule7_duplicates_ignore_blank_lines_between_rows():
+    result = lenient(doc("A-1,1,1.00", "", "A-1,2,2.00"))
+    assert result.items == [Item("A-1", 1, 100)]
+    assert shape(result.errors) == [(4, "sku", "duplicate_sku")]
+
+
+# --- Lines of multi-line records (rules in "Input format and line numbers") -----------------------
+
+
+def test_lines_multiline_record_reports_its_start_and_shifts_later_lines():
+    text = doc('"A\nB",1,1.00', "C-1,x,1.00", 'D-1,"1\n2\n3",1.00', "E-1,x,1.00")
+    result = lenient(text)
+    assert shape(result.errors) == [
+        (2, "sku", "invalid_sku"),
+        (4, "quantity", "invalid_quantity"),
+        (5, "quantity", "invalid_quantity"),
+        (8, "quantity", "invalid_quantity"),
+    ]
+    assert result.items == []
+
+
+def test_lines_multiline_record_with_crlf():
+    text = HEADER + '\r\n"A\r\nB",1,1.00\r\nC-1,x,1.00\r\n'
+    assert shape(lenient(text).errors) == [(2, "sku", "invalid_sku"), (4, "quantity", "invalid_quantity")]
+
+
+# --- Rule 8: order ------------------------------------------------------------------------------
+
+
+def test_rule8_items_and_errors_are_in_file_order():
+    text = doc("Z-9,1,1.00", "bad,1,1.00", "A-1,1,1.00", "A-1,x,1", "M-5,2,3.5", "M-5,1,1", "B-2,y,1.00")
+    result = lenient(text)
+    assert [i.sku for i in result.items] == ["Z-9", "A-1", "M-5"]
+    lines = [e.line for e in result.errors]
+    assert lines == sorted(lines) == [3, 5, 7, 8]
+    assert [e.code for e in result.errors] == ["invalid_sku", "duplicate_sku", "duplicate_sku", "invalid_quantity"]
+
+
+def test_rule8_ticket_example():
+    text = "sku,quantity,unit_price\nA-1,5,19.99\nA-2,x,1.00\nB-1,2,0.29\n\nA-1,9,1.00\n"
+    result = lenient(text)
+    assert result.items == [Item("A-1", 5, 1999), Item("B-1", 2, 29)]
+    assert shape(result.errors) == [(3, "quantity", "invalid_quantity"), (6, "sku", "duplicate_sku")]
+    assert strict_error(text).line == 3
+
+
+# --- Rule 9: strict mode ------------------------------------------------------------------------
+
+
+def test_rule9_strict_raises_the_first_error_not_the_last():
+    error = strict_error(doc("A-1,1,1.00", "B-2,x,1.00", "C-3,1,y", "D-4"))
+    assert (error.line, error.column, error.code) == (3, "quantity", "invalid_quantity")
+
+
+@pytest.mark.parametrize(
+    "rows",
+    [
+        pytest.param(["A-1,1,1.00", "A-1,2,2.00"], id="duplicate"),
+        pytest.param(["", "", 'A-1,"1\n2",1.00', "bad"], id="multiline-after-blank-lines"),
+        pytest.param(["A-1", "B-2,x,y"], id="field-count-first"),
+        pytest.param(["A-1,1,1.005"], id="price"),
+    ],
+)
+def test_rule9_strict_error_equals_first_non_strict_error(rows):
+    text = doc(*rows)
+    assert strict_error(text) == lenient(text).errors[0]
+
+
+def test_rule9_strict_stops_at_the_first_rejected_row_even_if_a_later_row_is_valid():
+    error = strict_error(doc("A-1,x,1.00", "A-1,1,1.00", "B-2,1,y"))
+    assert (error.line, error.code) == (2, "invalid_quantity")
+
+
+# --- Rule 10: nothing accepted ------------------------------------------------------------------
+
+
+def test_rule10_all_rows_rejected_gives_empty_items_and_all_errors():
+    result = lenient(doc("a,1,1.00", "B-1,x,1.00", "C-1,1,x", "D-1"))
+    assert result.items == []
+    assert [e.line for e in result.errors] == [2, 3, 4, 5]
+
+
+def test_rule10_non_strict_does_not_raise_for_row_errors():
+    result = lenient(doc("???,???,???"))
+    assert isinstance(result, ImportResult)
+    assert len(result.errors) == 1