chore: remove CLAUDE.md and tests from HF Space

Not needed in deployment; .gitignore prevents accidental re-add.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.gitignore

@@ -0,0 +1,2 @@
+CLAUDE.md
+tests/

CLAUDE.md

@@ -1,51 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Setup & running
-
-```bash
-source venv/bin/activate
-python ui.py           # Gradio UI at http://localhost:7860
-```
-
-The Radxa inference box (`192.168.68.119:8088`) must be reachable on the LAN. Start llama-server on it with:
-```bash
-taskset -c 4-7 llama-server --threads 4 --jinja --ctx-size 4096 --host 0.0.0.0 --port 8088 \
-  -m <model.gguf> --mmproj <mmproj.gguf>
-```
-
-## Architecture
-
-Two files: `app.py` (logic) + `ui.py` (CSS, layout). Pipeline:
-
-1. `encode_image` — PIL resize to 960px longest side → base64 JPEG (A/B tested 2026-06-08: 640px loses numeric codes on small-print instruction sheet photos; 960px = 100% recall, +~60s vs 640; 1280px identical recall at +90s — not worth it. Shop screenshots are already ≤640px so unaffected.)
-2. `call_llama` — POST to `llama-server` OpenAI-compatible endpoint (`/v1/chat/completions`) with image as base64 data URI; CPU inference, ~90–180s depending on image type
-3. `extract_codes` — json_schema constraint → json.loads → numeric extraction; falls back to tolerant regex for non-json modes
-4. Gradio `gr.Blocks` UI — single-page, upload → analyze → display raw output + extracted codes
-
-Each request must be a fresh conversation (no message history) — otherwise llama-server reuses the previous image encoding.
-
-## Model
-
-InternVL3.5-2B Q6_K_L GGUF + mmproj f16 GGUF on Radxa Dragon Q6A (CPU-only, Ubuntu).
-
-## Pending (in priority order)
-
-1. ~~Humbrol → Tamiya conversion table~~ — done (CSV lookup + mojehobby.pl shop links)
-2. Structured model output (JSON-in-prompt or GBNF grammar instead of free-text regex)
-3. ~~Brand autodetection~~ — solved by brand dropdown (deterministic, no extra work needed)
-4. ~~HF Space deployment~~ — done (`build-small-hackathon/paint_match`, branch `hf-deploy`); Cloudflare Tunnel pending (do weekendu)
-5. Airfix Dogfighter aesthetic UI (deferred until pipeline is solid)
-6. ~~Paint inventory integration~~ — done (gspread + service account; `GOOGLE_SERVICE_ACCOUNT_JSON` + `GOOGLE_SHEET_ID` env vars; sheet "Hakaton", sheet1; owned badge "✓ ISSUED" replaces shop link)
-
-## Hackathon constraints
-
-"Off-the-grid": inference must stay on the Radxa — no hosted LLM APIs. Cloudflare Tunnel and HF Space are acceptable front-door plumbing. Deadline: 2026-06-15.
-
-## Known pitfalls
-
-- Port 8080 on the Radxa is taken; llama-server uses 8088.
-- First request after server start is warmup — disregard its timing.
-- macOS `base64` is BSD: no `-w0`. Use `base64 -i file` or `base64 < file`.
-- `hf` not `huggingface-cli` in this venv.

tests/test_app.py

@@ -1,249 +0,0 @@
-import sys, os
-sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
-
-from app import tamiya_shop_url, _load_humbrol_tamiya
-
-
-def test_url_xf_series():
-    assert tamiya_shop_url("XF17", "Sea Blue") == \
-        "https://www.mojehobby.pl/products/XF-17-Sea-Blue.html"
-
-
-def test_url_x_series():
-    assert tamiya_shop_url("X5", "Green") == \
-        "https://www.mojehobby.pl/products/X-5-Green.html"
-
-
-def test_url_multiword_name():
-    assert tamiya_shop_url("XF25", "Light Sea Grey") == \
-        "https://www.mojehobby.pl/products/XF-25-Light-Sea-Grey.html"
-
-
-def test_url_dotted_name():
-    assert tamiya_shop_url("XF12", "J.N. Grey") == \
-        "https://www.mojehobby.pl/products/XF-12-JN-Grey.html"
-
-
-def test_loader_returns_name():
-    table = _load_humbrol_tamiya()
-    code, name = table["104"]
-    assert code == "XF17"
-    assert name == "Sea Blue"
-
-
-def test_loader_empty_tamiya_returns_empty_strings():
-    table = _load_humbrol_tamiya()
-    code, name = table["9"]
-    assert code == ""
-    assert name == ""
-
-
-def test_loader_path_uses_data_dir():
-    """_load_humbrol_tamiya must read from data/ subdirectory."""
-    import inspect
-    source = inspect.getsource(_load_humbrol_tamiya)
-    assert '"data"' in source, "loader must reference data/ subdirectory"
-    table = _load_humbrol_tamiya()
-    assert len(table) > 100
-
-
-def test_shop_format_parses_plain_code_list():
-    """Regression: the model returns a plain '- code: name' list even under the
-    shop format. The unified regex must parse it (the old shop regex matched none)."""
-    from app import FORMATS, strip_parens, parse_entries
-    raw = ("The paint codes from the product list are:\n\n"
-           "- 11: Silver\n- 33: Matt Black\n"
-           "- 118+34: Matt Desert Sand (4 parts 118, 3 parts 34)")
-    entries = parse_entries(strip_parens(raw), FORMATS["airfix_shop"]["regex"])
-    assert [e["code"] for e in entries] == ["11", "33", "118+34"]
-
-
-def test_parser_handles_noisy_shop_output():
-    """Real shop-screenshot output: the model echoes the full product line and
-    appends a literal 'CODE: N - Name'. The tolerant parser must still extract
-    code+name and dedupe the repeated code on each line."""
-    from app import FORMATS, strip_parens, parse_entries, expand_codes
-    raw = (
-        "- Acrylic Paint 11 - Silver - Metallic - (14ml) - CODE: 11 - Silver\n"
-        "- Acrylic Paint 33 - Black - Matt - (14ml) - CODE: 33 - Black\n"
-        "- Acrylic Paint 168 - Hemp/Camouflage Beige - Matt - (14ml) - CODE: 168 - Hemp/Camouflage Beige"
-    )
-    expanded = expand_codes(parse_entries(strip_parens(raw), FORMATS["airfix_shop"]["regex"]))
-    by_code = {e["code"]: e["name"] for e in expanded}
-    assert by_code == {"11": "Silver", "33": "Black", "168": "Hemp/Camouflage Beige"}
-
-
-def test_json_parser_extracts_code_name():
-    """json_schema mode returns a JSON array; parse_json_entries pulls code+name."""
-    from app import parse_json_entries
-    raw = '[{"code": "11", "name": "Silver"}, {"code": "118+34", "name": "Desert Sand"}]'
-    entries = parse_json_entries(raw)
-    assert [(e["code"], e["name"]) for e in entries] == \
-        [("11", "Silver"), ("118+34", "Desert Sand")]
-
-
-def test_json_parser_drops_malformed_codes():
-    """Non-numeric / junk codes are filtered; a non-array yields nothing."""
-    from app import parse_json_entries
-    raw = '[{"code": "33", "name": "Black"}, {"code": "n/a"}, {"name": "no code"}]'
-    assert [e["code"] for e in parse_json_entries(raw)] == ["33"]
-    assert parse_json_entries('not json at all') == []
-    assert parse_json_entries('{"code": "11"}') == []  # object, not array
-
-
-def test_json_parser_extracts_code_from_polluted_field():
-    """json_schema enforces shape but not semantics: the 2B model dumps the whole
-    echoed product line into `code`. The parser must pull the numeric code out."""
-    from app import parse_json_entries
-    raw = ('[{"code": "Acrylic Paint 11 - Silver - Metallic", "name": "Silver - Metallic"},'
-           ' {"code": "Acrylic Paint 118+34 - Desert Sand", "name": "Desert Sand"}]')
-    assert [e["code"] for e in parse_json_entries(raw)] == ["11", "118+34"]
-
-
-def test_json_parser_feeds_expand_codes():
-    """The JSON path plugs into the shared downstream: composite split + dedupe."""
-    from app import parse_json_entries, expand_codes
-    raw = '[{"code": "118+34", "name": "Mix"}, {"code": "11", "name": "Silver"}]'
-    expanded = expand_codes(parse_json_entries(raw))
-    assert [e["code"] for e in expanded] == ["118", "34", "11"]
-
-
-def test_is_paint_name_filters_decals_and_junk():
-    """Decal/stencil refs, bare numbers and years are not paints; colour names and
-    a missing name (code still matters) are kept."""
-    from app import is_paint_name
-    assert is_paint_name("Silver - Metallic") is True
-    assert is_paint_name("Gun Metal") is True
-    assert is_paint_name(None) is True
-    assert is_paint_name("") is True
-    assert is_paint_name("Decal No. 87 May 1991") is False
-    assert is_paint_name("Stencil 12") is False
-    assert is_paint_name("11") is False          # name is just a number
-    assert is_paint_name("May 1991") is False     # year
-
-
-def test_extract_entries_drops_decal_entries():
-    """End-to-end on a JSON payload mimicking paper.JPG: decal/junk rows fall out,
-    real paint rows survive."""
-    import app
-    raw = ('[{"code": "87", "name": "Decal No. 87 May 1991"},'
-           ' {"code": "70", "name": "11"},'
-           ' {"code": "53", "name": "Gun Metal"},'
-           ' {"code": "11", "name": "Silver"}]')
-    orig = app.OUTPUT_MODE
-    app.OUTPUT_MODE = "json"
-    try:
-        entries = app.extract_entries(raw, app.CODE_REGEX)
-    finally:
-        app.OUTPUT_MODE = orig
-    assert [e["code"] for e in entries] == ["53", "11"]
-
-
-def test_json_parser_salvages_truncated_array():
-    """max_tokens can cut the JSON mid-entry; the parser must still recover the
-    complete objects before the break instead of losing everything."""
-    from app import parse_json_entries
-    truncated = ('[\n  {"code": "11", "name": "Silver"},\n'
-                 '  {"code": "33", "name": "Black"},\n'
-                 '  {"code": "Acrylic Paint')  # cut off mid-entry, no closing ]
-    assert [e["code"] for e in parse_json_entries(truncated)] == ["11", "33"]
-
-
-def test_meng_format_dropped():
-    """Meng is out of scope for the hackathon (codes don't map to Tamiya)."""
-    from app import FORMATS
-    assert "meng_color_reference" not in FORMATS
-
-
-def test_analyze_final_yield_is_two_value_tuple():
-    """analyze() is a generator (status updates, then a final (raw_str, html_str))."""
-    from unittest.mock import patch
-    from PIL import Image
-    import numpy as np
-    from app import analyze
-
-    img = Image.fromarray(np.zeros((10, 10, 3), dtype=np.uint8))
-    with patch("app.call_llama", return_value="- 33: Flat Black\n- 98: Sky Grey"):
-        updates = list(analyze(img, "airfix_instruction"))
-
-    final = updates[-1]
-    assert isinstance(final, tuple)
-    assert len(final) == 2
-    raw, html = final
-    assert isinstance(raw, str)
-    assert isinstance(html, str)
-
-
-def test_encode_image_applies_exif_orientation():
-    """Phone photos carry an EXIF orientation flag; encode_image must straighten
-    them. server.py opens raw files (PIL.Image.open) which bypass Gradio's own
-    exif_transpose, so the correction has to live in encode_image itself."""
-    import base64, io
-    from PIL import Image
-    from app import encode_image
-
-    # Portrait 100x200 stored sideways with orientation=6 (rotate to view as landscape).
-    img = Image.new("RGB", (100, 200), "white")
-    exif = img.getexif()
-    exif[274] = 6  # tag 274 = Orientation
-    buf = io.BytesIO()
-    img.save(buf, format="JPEG", exif=exif)
-    buf.seek(0)
-    reopened = Image.open(buf)  # mirrors PIL.Image.open(path) in server.py
-
-    decoded = Image.open(io.BytesIO(base64.b64decode(encode_image(reopened))))
-    # After exif_transpose the displayed image is landscape: width > height.
-    assert decoded.width > decoded.height
-
-
-def test_llama_server_defaults_to_lan(monkeypatch):
-    import importlib, app
-    monkeypatch.delenv("LLAMA_SERVER", raising=False)
-    importlib.reload(app)
-    assert app.LLAMA_SERVER == "http://192.168.68.119:8088"
-
-
-def test_llama_server_reads_env(monkeypatch):
-    import importlib, app
-    monkeypatch.setenv("LLAMA_SERVER", "https://tunnel.example.com")
-    try:
-        importlib.reload(app)
-        assert app.LLAMA_SERVER == "https://tunnel.example.com"
-    finally:
-        monkeypatch.delenv("LLAMA_SERVER", raising=False)
-        importlib.reload(app)
-
-
-def test_manifest_shows_badge_for_owned_paint(monkeypatch):
-    """When a Tamiya code is in OWNED, the manifest li must carry class='owned'."""
-    import inventory, app
-    monkeypatch.setattr(inventory, "OWNED", frozenset({"XF17"}))  # no dash, matches lookup format
-
-    from unittest.mock import patch as mpatch
-    from PIL import Image
-    img = Image.new("RGB", (10, 10))
-
-    # JSON_SCHEMA produces a bare array. Humbrol 104 → XF17 Sea Blue.
-    fake_raw = '[{"code": "104", "name": "Sea Blue"}]'
-    with mpatch.object(app, "call_llama", return_value=fake_raw):
-        raw, html = app._run_analysis(img, "airfix_shop")
-
-    assert 'class="owned"' in html, f"Expected owned badge, got: {html}"
-    assert "mojehobby" not in html, f"Shop link should not appear for owned paint"
-
-
-def test_manifest_shows_shop_link_for_unowned_paint(monkeypatch):
-    """When a Tamiya code is NOT in OWNED, the manifest li must contain a shop link."""
-    import inventory, app
-    monkeypatch.setattr(inventory, "OWNED", frozenset())
-
-    from unittest.mock import patch as mpatch
-    from PIL import Image
-    img = Image.new("RGB", (10, 10))
-
-    fake_raw = '[{"code": "104", "name": "Sea Blue"}]'
-    with mpatch.object(app, "call_llama", return_value=fake_raw):
-        raw, html = app._run_analysis(img, "airfix_shop")
-
-    assert "mojehobby" in html, f"Expected shop link, got: {html}"
-    assert 'class="owned"' not in html

tests/test_inventory.py

@@ -1,46 +0,0 @@
-import sys, os
-sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
-
-import importlib
-from unittest.mock import MagicMock, patch
-
-
-def make_sheet_rows(*codes):
-    return [[c] for c in codes]
-
-
-def test_owned_is_frozenset():
-    import inventory
-    assert isinstance(inventory.OWNED, frozenset)
-
-
-def test_owned_empty_when_env_missing(monkeypatch):
-    monkeypatch.delenv("GOOGLE_SERVICE_ACCOUNT_JSON", raising=False)
-    monkeypatch.delenv("GOOGLE_SHEET_ID", raising=False)
-    import inventory
-    importlib.reload(inventory)
-    assert inventory.OWNED == frozenset()
-
-
-def test_owned_normalises_to_uppercase(monkeypatch):
-    monkeypatch.setenv("GOOGLE_SERVICE_ACCOUNT_JSON", '{"type":"service_account"}')
-    monkeypatch.setenv("GOOGLE_SHEET_ID", "fake-id")
-    fake_ws = MagicMock()
-    fake_ws.get_all_values.return_value = make_sheet_rows("Kod", "x-25", "XF-24", " XF-2 ")
-    fake_gc = MagicMock()
-    fake_gc.open_by_key.return_value.sheet1 = fake_ws
-    with patch("gspread.service_account_from_dict", return_value=fake_gc):
-        import inventory
-        importlib.reload(inventory)
-    assert "X25" in inventory.OWNED
-    assert "XF24" in inventory.OWNED
-    assert "XF2" in inventory.OWNED
-
-
-def test_owned_empty_on_auth_error(monkeypatch):
-    monkeypatch.setenv("GOOGLE_SERVICE_ACCOUNT_JSON", '{"type":"service_account"}')
-    monkeypatch.setenv("GOOGLE_SHEET_ID", "fake-id")
-    with patch("gspread.service_account_from_dict", side_effect=Exception("auth failed")):
-        import inventory
-        importlib.reload(inventory)
-    assert inventory.OWNED == frozenset()

tests/test_server.py

@@ -1,32 +0,0 @@
-import sys, os
-sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
-
-import PIL.Image
-import server
-
-
-def test_analyze_opens_filedata_dict_and_returns_manifest(monkeypatch, tmp_path):
-    # gr.Server delivers the image as a FileData dict {"path": ...}, not a PIL image.
-    # This covers server.analyze's dict-unwrap branch (its only novel logic).
-    # Force the regex parser so the line-format mock parses regardless of the
-    # default OUTPUT_MODE — this test is about the dict unwrap, not the constraint.
-    monkeypatch.setattr("app.OUTPUT_MODE", "free")
-    monkeypatch.setattr(
-        "app.call_llama",
-        lambda img_b64, prompt: "- 33: Black",
-    )
-    img_path = tmp_path / "swatch.png"
-    PIL.Image.new("RGB", (32, 32), "white").save(img_path)
-
-    updates = list(server.analyze({"path": str(img_path)}, "airfix_shop"))
-
-    assert len(updates) >= 1
-    raw, manifest = updates[-1]
-    assert "33" in raw
-    assert "Humbrol 33" in manifest
-    assert manifest.startswith("<ul>")
-
-
-def test_analyze_handles_no_image():
-    updates = list(server.analyze(None, "airfix_shop"))
-    assert updates[-1] == ("No image provided.", "")