fix(ingest): skip candidates that may be duplicates or carry guessed values

A dry run at bc86016 on TechAPI develop's data wrote 15 GPUs, at least 9 of
them already curated under another name, and 52 CPUs with wrong values. Ingest
now skips rather than guesses, and the summary says why for every skip.

Dedup reads every manufacturer folder of the category under run()'s data_root
instead of get_data_root() and the candidate's own folder. GPUs also match
across spelling (Ti500 / Ti 500), bus, memory size, revision, Mobile/laptop,
"Generation" and "(Workstation) Edition" names and the retired Quadro brand
(new gpu_identity.py), and a name that extends a curated board with the same
clock and TDP counts as that board. An existing path is never written over.

CPU tables: hybrid parts take P + E + LP-E cores and threads, checked against
the Total column; a mismatch is a problem, not a value. Arc Graphics columns
are no longer read as CPU cores, and TDP/Power columns as clocks. A section
heading becomes the architecture only when it names one codename or Zen
generation; "Mobile", "Desktop" and generation headings leave it empty.

Release dates: parse_date_period gives the end of the stated period. A part
the source dates after the run date ("Q4 2026", "Q1 2027") is skipped, and so
is any candidate with problems, even with --include-drafts.

Author: Seungpyo1007

app/ingest/gpu_identity.py

@@ -0,0 +1,81 @@
+"""Conservative GPU identity checks for additions-only ingest.
+
+One board is often listed under several names: ``GeForce3 Ti500`` and
+``GeForce3 Ti 500``, ``RTX 6000 Ada Generation`` and ``RTX 6000 Ada``, a laptop
+part with and without ``Mobile``, one card per memory size. A candidate that
+matches a curated board under any of those spellings is skipped, never added
+as a second record: a missed addition is cheap, a duplicate is not.
+"""
+
+from __future__ import annotations
+
+import re
+
+# Words that name a variant of a board rather than a different board.
+_QUALIFIERS = frozenset({
+    "agp", "pci", "pcie",  # bus
+    "generation", "edition",  # "Ada Generation", "Workstation Edition"
+    "mobile", "laptop", "notebook",  # laptop parts; Max-Q is its own power tier
+    "engineering", "sample",
+})
+_MEMORY_RE = re.compile(r"\d+(?:gb|mb)")
+# Turing and later workstation boards dropped the Quadro brand ("Quadro T500" is "T500").
+_QUADRO_RENAMED_RE = re.compile(r"(?:t|a|rtx)\d*")
+
+
+def _tokens(slug: str) -> list[str]:
+    tokens = [token for token in slug.lower().split("-") if token]
+    joined: list[str] = []
+    for token in tokens:
+        # Rejoin pairs the slugifier splits: "max-q", "e-s" (engineering sample),
+        # "pci-e", "rev-2", "3-gb".
+        if joined and (joined[-1], token) == ("e", "s"):
+            joined[-1] = "engineering"
+            continue
+        if joined and (
+            (joined[-1], token) in {("max", "q"), ("pci", "e")}
+            or (joined[-1] == "rev" and token.isdigit())
+            or (joined[-1].isdigit() and token in {"gb", "mb"})
+        ):
+            joined[-1] += token
+            continue
+        joined.append(token)
+    return joined
+
+
+def gpu_key(slug: str) -> str:
+    """Spelling-insensitive identity: ``geforce3-ti500`` == ``geforce3-ti-500``."""
+    return "".join(_tokens(slug))
+
+
+def gpu_family_key(slug: str) -> str:
+    """Identity with variant words dropped: bus, memory size, revision, laptop
+    markers, "Generation"/"(Workstation) Edition" and the retired Quadro brand."""
+    tokens = _tokens(slug)
+    if len(tokens) > 1 and tokens[0] == "quadro" and _QUADRO_RENAMED_RE.fullmatch(tokens[1]):
+        tokens = tokens[1:]
+    kept = [
+        token
+        for i, token in enumerate(tokens)
+        if token not in _QUALIFIERS
+        and not _MEMORY_RE.fullmatch(token)
+        and not re.fullmatch(r"rev\d*", token)
+        # "RTX PRO 6000 Blackwell Workstation (Edition)" is the plain board.
+        and not (token == "workstation" and tokens[i + 1 : i + 2] in ([], ["edition"]))
+    ]
+    return "".join(kept)
+
+
+def spec_twins(candidate: dict[str, object], existing: dict[str, object]) -> bool:
+    """Two names where one extends the other (``HD 2350`` / ``HD 2350 PRO``) and
+    the boards share core clock and TDP: likely the same board, so not a new one."""
+    left = gpu_key(str(candidate.get("slug", "")))
+    right = gpu_key(str(existing.get("slug", "")))
+    short, long = sorted((left, right), key=len)
+    if len(short) < 4 or short == long or not long.startswith(short):
+        return False
+    if not long[len(short)].isalpha():
+        return False  # "hd235" vs "hd2350" is a different number, not a suffix
+    clocks = candidate.get("base_clock_mhz"), existing.get("base_clock_mhz")
+    tdps = candidate.get("tdp_w"), existing.get("tdp_w")
+    return None not in clocks and None not in tdps and clocks[0] == clocks[1] and tdps[0] == tdps[1]

app/ingest/normalize.py

@@ -138,34 +138,58 @@ def parse_cores_threads(text: str) -> tuple[int | None, int | None]:
 
 def parse_date(text: str) -> date | None:
     """Best-effort calendar date. ``"Q3 2023"`` → ``2023-07-01``; year-only → Jan 1."""
+    period = parse_date_period(text)
+    return period[0] if period else None
+
+
+def parse_date_period(text: str) -> tuple[date, date] | None:
+    """``(first, last)`` day of the period a date cell names.
+
+    A full date is a one-day period. ``"Q4 2026"`` is Oct 1 – Dec 31, ``"Dec 2024"``
+    the whole month and a bare year the whole year, so a caller can tell whether
+    the period had ended (the part had shipped) by a given day.
+    """
     if not text:
         return None
     stripped = text.strip()
 
     if (match := _ISO_DATE_RE.match(stripped)):
         year, month, day = (int(g) for g in match.groups())
-        return _safe_date(year, month, day)
+        return _day(_safe_date(year, month, day))
     if (match := _NUMERIC_DATE_RE.match(stripped)):
         year, month, day = (int(g) for g in match.groups())
-        return _safe_date(year, month, day)
+        return _day(_safe_date(year, month, day))
     if (match := _LONG_DATE_RE.search(stripped)):
         month_name, day_str, year_str = match.group(1), match.group(2), match.group(3)
-        return _safe_date(int(year_str), _MONTHS[month_name.lower()[:3]], int(day_str))
+        return _day(_safe_date(int(year_str), _MONTHS[month_name.lower()[:3]], int(day_str)))
     if (match := _SHORT_DATE_RE.search(stripped)):
         day_str, month_name, year_str = match.group(1), match.group(2), match.group(3)
-        return _safe_date(int(year_str), _MONTHS[month_name.lower()[:3]], int(day_str))
+        return _day(_safe_date(int(year_str), _MONTHS[month_name.lower()[:3]], int(day_str)))
     if (match := _QUARTER_RE.search(stripped)):
         quarter = int(match.group(1))
         year_raw = match.group(2)
         year = 2000 + int(year_raw) if len(year_raw) == 2 else int(year_raw)
-        return _safe_date(year, (quarter - 1) * 3 + 1, 1)
+        return _months(year, (quarter - 1) * 3 + 1, 3)
     if (match := _MONTH_YEAR_RE.search(stripped)):
-        return _safe_date(int(match.group(2)), _MONTHS[match.group(1).lower()[:3]], 1)
+        return _months(int(match.group(2)), _MONTHS[match.group(1).lower()[:3]], 1)
     if (match := _YEAR_ONLY_RE.search(stripped)):
-        return _safe_date(int(match.group(1)), 1, 1)
+        return _months(int(match.group(1)), 1, 12)
     return None
 
 
+def _day(day: date | None) -> tuple[date, date] | None:
+    return (day, day) if day else None
+
+
+def _months(year: int, first_month: int, count: int) -> tuple[date, date] | None:
+    first = _safe_date(year, first_month, 1)
+    if first is None:
+        return None
+    last_month = first_month + count - 1
+    after = date(year + 1, 1, 1) if last_month == 12 else date(year, last_month + 1, 1)
+    return first, date.fromordinal(after.toordinal() - 1)
+
+
 def _safe_date(year: int, month: int, day: int) -> date | None:
     try:
         return date(year, month, day)