Upload folder using huggingface_hub (part 61)

google_drive_export/dataset_annotated/labels/ffaa8463e3e8d6be.txt

@@ -0,0 +1,4 @@
+0 0.514721 0.497057 0.880708 0.976686
+0 0.423462 0.528546 0.748916 0.847120
+0 0.466082 0.417253 0.343521 0.313060
+0 0.467098 0.348551 0.345282 0.453801

google_drive_export/dataset_annotated/labels/ffd9ca6aff7641b9.txt

@@ -0,0 +1,2 @@
+0 0.868601 0.535727 0.058631 0.056538
+0 0.312879 0.238340 0.054033 0.049270

google_drive_export/dataset_annotated/labels/ffeac303cb5ada59.txt

@@ -0,0 +1 @@
+0 0.488530 0.502639 0.955919 0.993613

google_drive_export/docs/PROJECT_CONTEXT_AND_ACTION_PLAN.md

@@ -0,0 +1,127 @@
+# E-Waste PCB Component Purity & Cannibalization Index: Project Context, System Architecture & Master Action Plan
+
+## 1. Project Overview & Business Context
+
+The **Component Purity & Cannibalization Index** is an edge-AI system built for Kabadiwala Connect (e-waste recycling platform). It detects real-time, on-device PCB cannibalization (the illicit stripping of valuable components like CPU sockets, gold edge connector fingers, IC microchips, and SMD tantalum capacitors) to:
+1. Calculate a dynamic **Board Integrity Score (BIS)**.
+2. Emit **8-language vernacular voice warnings** to scrap collectors for fair purchasing price adjustments.
+3. Propagate component integrity data across the **Collector → Dealer → Recycler** supply chain to catch mid-chain cannibalization fraud.
+
+---
+
+## 2. Current Project State & Progress Summary
+
+| Category | Current Status | Details & Artifacts |
+| :--- | :--- | :--- |
+| **Dataset Size** | **3,923 Normalized JPEGs** | Located in `data/images/` and `data/annotated_auto/images/` (6,864 total tracked). Average resolution: $1315 \times 1029\text{ px}$. |
+| **Auto-Annotation** | **3,784 Draft Bounding Boxes** | Auto-labeled via YOLO-World zero-shot model (`pipeline/auto_annotate.py`, `conf=0.02`). |
+| **Dataset Spec** | **YOLO Format Ready** | Specification saved to [`data/annotated_auto/data.yaml`](file:///home/taruns/Downloads/scraper/data/annotated_auto/data.yaml). Summary in [`data/annotated_auto/auto_annotation_summary.json`](file:///home/taruns/Downloads/scraper/data/annotated_auto/auto_annotation_summary.json). |
+| **Updated Taxonomy** | **7 Fine-Grained Classes** | Defined in [`config/taxonomy.yaml`](file:///home/taruns/Downloads/scraper/config/taxonomy.yaml) (separates fraud desoldered pads from factory empty pads). |
+| **Scraper Status** | **Harvest Completed (+681 Net New)** | Incremental harvest executed across 298 queries (`config/queries.yaml`). |
+| **Pipeline Tests** | **11 / 11 Passed** | Test suite (`tests/test_pipeline.py`) fully compliant. |
+
+---
+
+## 3. Architecture & Dual-Track Execution Strategy
+
+Development is decoupled into two parallel tracks linked by a frozen contract ([`model_contract.md`](file:///home/taruns/Downloads/scraper/implementation_plan_component_purity_index.md#L61)):
+
+```
+       ┌────────────────────────────────────────────────────────┐
+       │             model_contract.md (Frozen Schema)          │
+       └──────────────────────────┬─────────────────────────────┘
+                                  │
+         ┌────────────────────────┴────────────────────────┐
+         │                                                 │
+┌────────▼───────────────────────┐       ┌─────────────────▼─────────────────────┐
+│ Track A: Model & Dataset       │       │ Track B: Application & Integration    │
+├────────────────────────────────┤       ├───────────────────────────────────────┤
+│ • 7-Class Refined Taxonomy     │       │ • `MockModelClient` for Dev/Testing   │
+│ • Multi-Scale YOLOv8 Training  │       │ • Integrity Engine (`purity_assay.py`) │
+│ • Focal Loss for Desoldered    │       │ • Offline Pre-Recorded Audio Warnings │
+│ • TFLite INT8 Quantization     │       │ • Collector Lite & Recycler Portal    │
+│ • Real-World Test Evaluation   │       │ • BIS-Delta Fraud Discrepancy UI      │
+└────────────────┬───────────────┘       └─────────────────┬─────────────────────┘
+                 │                                         │
+                 └─────────────────┬───────────────────────┘
+                                   ▼
+          Swap Mock for Quantized Model (`TFLiteModelClient`)
+                         (1-Line Config Change)
+```
+
+---
+
+## 4. System Requirements & Architectural Adjustments
+
+Based on technical analysis and field realities, the following system-level changes are enforced:
+
+### A. Edge Hardware & Memory Optimization (Low-End Android 2GB–3GB RAM)
+* **Sequential Model Execution**: Running the 21-class category model and YOLOv8 micro-model simultaneously triggers browser tab memory crashes. 
+* **Fix**: Enforce explicit tensor disposal (`model.dispose()`) after Stage 1 classification before loading Stage 2 micro-component detection.
+
+### B. Taxonomy Refinement (Eliminating False Fraud Signals)
+* **Fix**: Split generic desoldered footprints into:
+  1. `forcibly_desoldered_pad`: Exposed pads with jagged solder peaks, torn traces, or blowtorch/burnt flux residue (**fraud signal**).
+  2. `factory_unpopulated_pad`: Clean silkscreen outline with smooth solder dots left unpopulated from factory (**NOT fraud**).
+  3. `occluded_region`: Footprints covered by heatsinks, metal shields, or thick dust.
+
+### C. Dynamic Scrap Grade Pricing Floor
+* **Fix**: Replace rigid 35% hardcoded floor with category scrap grade floors:
+  $$\text{Adjusted Price} = \text{Base Price} \times \left( \text{Floor}_{\text{category}} + (1 - \text{Floor}_{\text{category}}) \times \frac{\text{BIS}}{100} \right)$$
+  * Server/GPU PCBs: $\text{Floor} = 0.15$
+  * Desktop PCBs: $\text{Floor} = 0.30$
+  * Low-grade Power PCBs: $\text{Floor} = 0.60$
+
+### D. Multi-Angle 2-Sided Inspection Protocol
+* **Fix**: Standardize a 2-photo workflow (Front Top-Down + Reverse Bottom-Down / Edge) in Collector Lite to inspect both sides of the PCB.
+
+### E. Supply Chain Fraud Tolerance Bands
+* **Fix**: Update Recycler Portal intake discrepancy bands to:
+  * $< 12\%$ BIS Drop $\rightarrow$ Normal capture variance (Pass).
+  * $12\text{--}25\%$ BIS Drop $\rightarrow$ Advisory Warning / Discrepancy Flag.
+  * $> 25\%$ BIS Drop $\rightarrow$ Critical Fraud Alert & CPCB Form 6 PDF Audit Log Entry.
+
+### F. Offline Vernacular Audio Reliability
+* **Fix**: Standardize pre-recorded `.opus` audio playback via Service Worker `CacheStorage` as a fallback when Web Speech API regional voice packs are missing offline.
+
+---
+
+## 5. Master Plan of Action (Step-by-Step Roadmap)
+
+### Phase 1: Baseline Model Training (Track A)
+- [x] Auto-annotate dataset with 3,130 draft boxes (`pipeline/auto_annotate.py`).
+- [ ] Fine-tune baseline **YOLOv8n / YOLOv8s** on `data/annotated_auto/data.yaml` (`imgsz=960` or `1280`).
+- [ ] Evaluate per-class mAP@50 and fraud recall on `forcibly_desoldered_pad`.
+- [ ] Quantize model to TFLite INT8 ($<15\text{ MB}$, target $<1\text{s}$ latency).
+
+### Phase 2: Incremental Harvest & Synthetic Data (Optional Extension)
+- [ ] Execute optional incremental scraper batch (~500–1,000 images) using updated [`config/queries.yaml`](file:///home/taruns/Downloads/scraper/config/queries.yaml).
+- [ ] Apply CutMix / Copy-Paste synthetic desoldered pad data synthesis during training.
+
+### Phase 3: Purity Engine Module Build (Track B)
+- [ ] Build `purity_engine/model_client.py` (`MockModelClient` & `TFLiteModelClient`).
+- [ ] Build `purity_engine/purity_assay.py` (Form-factor baseline matching + dynamic scrap pricing formula).
+- [ ] Build `purity_engine/vernacular_voice.py` (Web Speech API + `.opus` fallback).
+
+### Phase 4: App Integration & End-to-End Verification
+- [ ] Extend Collector Lite (`mobile/kabadiwala-lite.html`) with 2-photo workflow & inline BIS display.
+- [ ] Extend Recycler Portal (`recycler-dashboard-frontend/`) with BIS-delta view ($12\% / 25\%$ flags).
+- [ ] Run automated test suite (`tests/test_purity_assay.py`, `tests/test_bis_delta_api.py`).
+
+---
+
+## 6. Key Configuration & Pipeline Commands Quick Reference
+
+* **Run Automated Tests**:
+  ```bash
+  .venv/bin/python -m pytest
+  ```
+* **Run Auto-Annotation Script**:
+  ```bash
+  .venv/bin/python pipeline/auto_annotate.py
+  ```
+* **Run Incremental Web Scraper**:
+  ```bash
+  .venv/bin/python scraper.py harvest
+  ```
+* **Dataset Location**: `data/annotated_auto/`

google_drive_export/docs/implementation_plan.md

@@ -0,0 +1,72 @@
+# Implementation Plan: E-Waste Dataset Scraper & Pipeline (v2 Architecture)
+
+Build a modular, production-grade Python web scraper and image preprocessing pipeline following `scraper_plan_v2.md` to harvest, clean, deduplicate, and prepare high-resolution e-waste PCB dataset images for fine-tuning YOLOv8 micro-component detectors.
+
+## User Review Required
+
+> [!IMPORTANT]
+> **Scraping Target & Volume:** The pilot harvest target will be set to **500 images per query batch** across Bing and Flickr to keep the pilot run under 10–15 minutes while establishing real attrition rates.
+> **Dependency Note:** `icrawler`, `pillow`, `imagehash`, and `open_clip_torch` (or lightweight CLIP filtering) will be installed in the environment.
+
+## Open Questions
+
+> [!NOTE]
+> **CLIP Relevance Filter Mode:** Should the initial script execute CLIP zero-shot relevance filtering locally via PyTorch, or fall back to rule-based aspect-ratio/color-histogram heuristic filtering if PyTorch GPU memory is constrained during background runs? (Default: Rule-based + optional CLIP module).
+
+---
+
+## Proposed Changes
+
+### Scraping & Pipeline Package (`ewaste_dataset_pipeline/`)
+
+Creation of a self-contained, modular Python CLI pipeline under `ewaste_dataset_pipeline/`.
+
+#### [NEW] [`config/taxonomy.yaml`](file:///home/taruns/sih2026_kabadiwala/ewaste_dataset_pipeline/config/taxonomy.yaml)
+- Defines the 5 target YOLO detection classes: `cpu_socket`, `gold_finger`, `ic_chip`, `tantalum_capacitor`, `desoldered_zone`.
+- Defines image-level tags: `board_type`, `condition`, `source_type`.
+
+#### [NEW] [`config/queries.yaml`](file:///home/taruns/sih2026_kabadiwala/ewaste_dataset_pipeline/config/queries.yaml)
+- Search query expansion matrix across search terms, condition variants, board types, and multilingual terms.
+
+#### [NEW] [`pipeline/manifest.py`](file:///home/taruns/sih2026_kabadiwala/ewaste_dataset_pipeline/pipeline/manifest.py)
+- SQLite database abstraction layer (`manifest.db`) tracking URL provenance, download status, MD5 checksums, resolution, pHash values, cluster IDs, and split assignments.
+
+#### [NEW] [`pipeline/crawler.py`](file:///home/taruns/sih2026_kabadiwala/ewaste_dataset_pipeline/pipeline/crawler.py)
+- URL harvester using `icrawler` (Bing, Flickr, Baidu) with exponential backoff retries, custom headers, and rate limiting. Saves raw bytes to `data/originals/`.
+
+#### [NEW] [`pipeline/validator.py`](file:///home/taruns/sih2026_kabadiwala/ewaste_dataset_pipeline/pipeline/validator.py)
+- Validation engine checking file integrity (`verify()` + `load()`), short/long resolution cutoffs ($\ge 480\text{ px}$ short side), and aspect ratio bounds (flag $> 3:1$, drop $> 6:1$).
+
+#### [NEW] [`pipeline/processor.py`](file:///home/taruns/sih2026_kabadiwala/ewaste_dataset_pipeline/pipeline/processor.py)
+- Image normalizer handling EXIF auto-rotation (`exif_transpose`), RGBA alpha white-background compositing, CMYK to RGB conversion, and JPEG 95 quality encoding.
+
+#### [NEW] [`pipeline/dedup.py`](file:///home/taruns/sih2026_kabadiwala/ewaste_dataset_pipeline/pipeline/dedup.py)
+- Multi-tier deduplication engine (SHA-256 exact byte hash + perceptual `pHash`/`dHash` with horizontal flip awareness).
+
+#### [NEW] [`scraper.py`](file:///home/taruns/sih2026_kabadiwala/ewaste_dataset_pipeline/scraper.py)
+- Unified CLI entry point supporting subcommands: `harvest`, `validate`, `process`, `dedup`, `report`.
+
+#### [NEW] [`requirements.txt`](file:///home/taruns/sih2026_kabadiwala/ewaste_dataset_pipeline/requirements.txt)
+- Dependency specifications (`icrawler`, `Pillow`, `imagehash`, `pyyaml`, `tqdm`).
+
+---
+
+## Verification Plan
+
+### Automated Verification
+1. **Unit & Module Tests:**
+   - Test image validation on corrupted, truncated, transparent PNG, CMYK, and EXIF-rotated sample images.
+   - Verify pHash deduplication on identical vs resized/flipped images.
+2. **CLI Execution Runs:**
+   - Execute pilot harvest run:
+     ```bash
+     cd ewaste_dataset_pipeline
+     python3 scraper.py harvest --max-num 50
+     python3 scraper.py validate
+     python3 scraper.py process
+     python3 scraper.py dedup
+     python3 scraper.py report
+     ```
+
+### Manual Verification
+- Inspect generated `reports/summary.json` to verify image yield, discard counts by reason, and clean `dataset_raw/` outputs.

google_drive_export/docs/implementation_plan_component_purity_index.md

@@ -0,0 +1,148 @@
+# Implementation Plan: Edge "Component Purity & Cannibalization Index" (Updated)
+
+This feature delivers real-time, on-device detection of PCB cannibalization (stripping/depopulation of valuable components like CPU sockets, gold edge fingers, and tantalum capacitors) to calculate a **Board Integrity Score (BIS)**, generate vernacular voice warnings for scrap pricing adjustments, and propagate integrity data through the Dealer → Recycler chain to catch mid-chain stripping fraud.
+
+Model training data collection is still in progress, so this plan is split into two tracks joined by a single frozen interface (`model_contract.md`): **Track A** builds and trains the detection model; **Track B** builds the full app pipeline against a mock model conforming to that same contract, so integration is not blocked on model readiness. Swapping the mock for the trained model later is a one-line config change, not a rewrite.
+
+---
+
+## User Review Required
+
+> [!IMPORTANT]
+> - **Labeling taxonomy refinement**: Split desoldered footprints into `forcibly_desoldered_pad` (jagged, torn traces, burnt flux) and `factory_unpopulated_pad` (pristine silkscreen, smooth solder dots) to eliminate false cannibalization alerts on unpopulated board regions. Added `occluded_region` to prevent penalizing components covered by heatsinks/dust.
+> - **Form-factor baselines**: Replaced static class-wide component counts with form-factor sub-profiles (`desktop_atx`, `desktop_micro_atx`, `server_1u`, `gpu_pcb`, `ram_dimm`) in `board_profiles.json` to prevent small intact boards from receiving low BIS scores.
+> - **Dynamic price floor**: Replaced the rigid 35% hardcoded price floor with category-based scrap grade floors ($\text{Floor}_{\text{category}}$ = 15% for high-grade server/GPU boards up to 60% for low-grade power boards).
+> - **Sequential edge execution**: Adopted sequential model loading (`dispose()` calls between 21-class category classifier and YOLOv8 micro-model) to prevent memory crashes on 2GB–3GB RAM Android phones.
+> - **BIS-delta tolerance bands**: Updated recycler intake fraud threshold to $>12\%$ for advisory flags and $>25\%$ for critical alerts (up from 5%) to accommodate field-vs-warehouse camera & lighting variances.
+> - **Offline voice fallback**: Standardized pre-recorded `.opus` audio snippets via Service Worker `CacheStorage` as a fallback when Web Speech API offline regional voice packs are missing.
+> - **Data sourcing strategy**: Confirmed that existing open datasets can bootstrap the generic (`*_intact`) component classes, removing most of the annotation burden for those; the fraud-specific classes (`forcibly_desoldered_pad`, `occluded_region`) still require primarily field-staged photography, supplemented — not replaced — by mined web sources. See Phase 1, Component 2a. **Requires a decision on whether forum/marketplace-sourced supplemental images are approved for use** (see licensing note in Component 2a) before any scraping work begins.
+
+---
+
+## Track A: Micro-Component Detection Model
+
+### Phase 1: Data Collection & Labeling (Updated Guidelines)
+
+#### Component 1: Refined Labeling Taxonomy (`taxonomy/component_classes.yaml`)
+- [NEW] Defines fine-grained class states to eliminate false positives:
+  - `bga_cpu_socket_intact`, `bga_cpu_socket_missing`
+  - `gold_edge_finger_intact`, `gold_edge_finger_stripped`
+  - `tantalum_cap_intact`, `tantalum_cap_missing`
+  - `ram_dimm_slot_intact`, `ram_dimm_slot_stripped`
+  - `forcibly_desoldered_pad` (jagged solder, torn traces, blowtorch/burnt flux residue — primary fraud signal)
+  - `factory_unpopulated_pad` (clean silkscreen outline, smooth solder dots — unpopulated from factory, NOT fraud)
+  - `occluded_region` (heatsinks, metal shields, heavy dirt/dust covering component pads)
+
+#### Component 2: Data Collection & Sourcing Protocol (`data_collection/`)
+- [NEW] `capture_protocol.md` — multi-angle capture protocol (Front side top-down, Reverse side top-down, and macro gold edge connector shot) to handle 2-sided PCB inspection.
+- [NEW] `board_sourcing_log.csv` — logs board type, source, form factor (`desktop_atx`, `micro_atx`, `server_4u`, etc.), and intentional stripping state (pristine, blowtorched, organically degraded, factory unpopulated).
+- Sourcing requirements: Must harvest dirty, corroded, dusty, and factory-unpopulated boards alongside pristine and stripped examples to match field scrap yard conditions.
+
+#### Component 2a: Data Sourcing Strategy — Open Datasets, Mined Web Sources, and Field Photography (`data_collection/sourcing_strategy.md`)
+
+Research into publicly available data confirms a **three-tier sourcing strategy**, since scraping alone cannot cover the fraud-specific classes:
+
+**Tier 1 — Open datasets, for bootstrapping `*_intact` classes (use directly, no scraping needed):**
+- A Dataset Ninja "PCB Component Detection" set — 1,410 images, 11,119 bounding-box-labeled objects across 9 classes (capacitor, transformer, MOSFET, resistor, etc.), released CC0 and explicitly tagged for the waste-recycling use case.
+- HuggingFace `PCB_COMPONENTS_LABELLED` — 17-class YOLO-format set (IC, capacitor, connector, crystal oscillator, diode, ferrite bead, fuse, inductor, LED, resistor, switch, transistor, pins, pads, test points).
+- HuggingFace `pcb-object-detection-dataset` — 21-class YOLO set including heatsinks and connectors.
+- Roboflow Universe community PCB datasets (component-level bounding boxes, CC BY 4.0).
+- **Use**: pretrain the detection backbone and pad out the `*_intact` and generic-component classes; re-map class names to `taxonomy/component_classes.yaml`. This does not reduce the need for field data on fraud-specific classes below, but meaningfully cuts the annotation volume needed for the "board still has its parts" side of the taxonomy.
+
+**Tier 2 — Mined web sources, as a supplemental seed set for `forcibly_desoldered_pad` only (not a primary source):**
+- Gold-recovery/e-waste hobbyist forums (e.g. Gold Refining Forum, finishing.com) contain user-posted photos of boards before, during, and after chip/pin removal, and active community discussion distinguishing "unpopulated" from "depopulated" boards — the closest organic analog to the `forcibly_desoldered_pad` class available online.
+- Hobbyist "gold recovery" / heat-gun chip-pulling YouTube videos are a higher-yield variant of the same source: frame-extraction from a single video can produce many more usable images than a forum thread.
+- **Known limitations, by design not treated as a primary source**:
+  - Low volume per source and inconsistent photo quality/angle — doesn't match the phone-camera, scrap-yard conditions defined in `capture_protocol.md`.
+  - No existing bounding boxes — still requires full manual annotation, same as field photos.
+  - Licensing: forum and video content is user-generated and not freely licensed for reuse; scraping is low-risk for an internal/hackathon prototype but is **not cleared for production training data** without explicit permission or a licensed dataset. Flagged in User Review Required above — treat as blocked until a decision is made.
+- **Use**: a small supplemental set to diversify what "stripped" looks like beyond staged photos, mined and annotated in parallel with, not instead of, Tier 3.
+
+**Tier 3 — Deliberately staged field photography, mandatory and primary for fraud classes (this is the existing Component 2 protocol above):**
+- Only source that guarantees: domain match to real collector phone conditions, controlled multi-angle capture, and clean separation between `forcibly_desoldered_pad`, `factory_unpopulated_pad`, and `occluded_region` at capture time (know the ground truth because you staged it, rather than inferring it after the fact from a forum photo).
+- Remains the dataset of record for Phase 4 evaluation thresholds; Tier 1/2 data is for pretraining and augmentation only, not held-out test data.
+
+#### Component 3: Annotation & QA
+- [NEW] Bounding-box annotation via CVAT or Label Studio, exported in COCO/YOLO format.
+- [NEW] `qa_annotation_review.py` — inter-annotator agreement check (min. 2 annotators per image, flag disagreement >10% of boxes for adjudication).
+- Target: minimum 300 images per class, with at least 30% deliberately-stripped/burnt negative examples, before first training run.
+
+### Phase 2: Form-Factor Baseline Definitions
+
+#### Component 4: Dynamic Board Profiles (`baselines/board_profiles.json`)
+- [NEW] Defines expected component counts/area ratios per board class **and form factor**:
+  - `desktop_atx`, `desktop_micro_atx`, `desktop_itx`
+  - `server_1u_2u`, `server_blade_4u`
+  - `gpu_pcb_high_end`, `gpu_pcb_budget`
+  - `ram_dimm_desktop`, `ram_so_dimm_laptop`
+- Sourced from recycling domain experts — consumed downstream by `purity_assay.py`.
+
+### Phase 3: Model Training
+
+#### Component 5: Training Pipeline (`training/train.py`)
+- [NEW] YOLOv8n/s fine-tuning with multi-scale training (`imgsz=960` or `1280`) and custom anchor ratios for elongated `gold_finger` boxes ($>4:1$).
+- Heavy augmentations for field realities: specular glare on gold fingers, lighting variance, dirt noise, and angle tilt.
+- [NEW] `train_config.yaml` — Focal loss & elevated class weights for `forcibly_desoldered_pad` vs `factory_unpopulated_pad`.
+
+#### Component 6: Auxiliary Desoldered Pad Classifier Head
+- [NEW] Secondary classification head specifically trained to distinguish desoldered blowtorch pads from factory empty pads.
+
+#### Component 7: Export & Quantization (`export/export_tflite.py`)
+- [NEW] Export to TFLite INT8 quantized, target size <15MB, target inference <1s on low-end Android hardware.
+- [NEW] `model_contract.md` — freezes input/output tensor schema.
+
+### Phase 4: Evaluation
+
+#### Component 8: Model Evaluation (`eval/evaluate.py`)
+- [NEW] Per-class mAP, plus dedicated fraud recall on `forcibly_desoldered_pad` and false-positive rate on `factory_unpopulated_pad`.
+- Thresholds: $\ge 90\%$ recall on intact classes, $\ge 85\%$ recall on desoldered pad classes, and $\le 5\%$ false positive rate on factory unpopulated pads.
+
+---
+
+## Track B: Integration into Kabadiwala Connect
+
+### Component 9: Purity Engine & Memory-Conscious Orchestrator (`purity_engine/`)
+
+- [NEW] `purity_engine/model_client.py` — wrapper supporting `MockModelClient` and `TFLiteModelClient` with explicit tensor memory management (`model.dispose()` between Stage 1 and Stage 2).
+- [NEW] `purity_engine/purity_assay.py` — implements `calculate_board_integrity_score(detected_components, form_factor)`:
+  - Dynamic price formula:
+    $$\text{Adjusted Price} = \text{Base Price} \times \left( \text{Floor}_{\text{category}} + (1 - \text{Floor}_{\text{category}}) \times \frac{\text{BIS}}{100} \right)$$
+  - Scrap Grade Floors: Server/GPU = 15%, Desktop = 30%, Low-grade Power = 60%.
+- [NEW] `purity_engine/pcb_analyzer.py` — single entry point for Collector Lite & Recycler Portal.
+
+### Component 10: Vernacular Voice Alerts with Audio Fallback (`purity_engine/vernacular_voice.py`)
+
+- [NEW] Extends Collector Lite's 8-language Web Speech API audio system with Service Worker pre-recorded `.opus` audio fallbacks for offline devices lacking regional voice packs.
+- Message templates parameterized by BIS band (Pristine $\ge 85\%$, Partial $50\text{--}84\%$, Severe $<50\%$).
+
+### Component 11: Collector Lite Multi-Angle UI Integration (`mobile/kabadiwala-lite.html`)
+
+- Extend Step 1 of Collector Lite: Stage 1 21-class classifier detects `PCB` $\rightarrow$ prompts guided Front/Back photo capture $\rightarrow$ triggers `pcb_analyzer`.
+- Displays BIS score, missing-component breakdown, and transparent price adjustment in Step 3.
+- Persists assay JSON into IndexedDB with the scrap slip.
+
+### Component 12: QR Handover Payload Enrichment (`mobile/dealer.html`, backend)
+
+- QR payload includes collector BIS score, form factor, and assay report hash.
+
+### Component 13: Recycler Portal BIS-Delta View (`recycler-dashboard-frontend/`)
+
+- Re-scan intake lot via `pcb_analyzer`.
+- Tolerance Bands:
+  - $< 12\%$ BIS Drop $\rightarrow$ Normal capture variance (Pass).
+  - $12\text{--}25\%$ BIS Drop $\rightarrow$ Discrepancy Flagged.
+  - $> 25\%$ BIS Drop $\rightarrow$ Critical Fraud Alert & CPCB Form 6 PDF Audit Log Entry.
+
+### Component 14: Backend API Changes (`backend/`)
+
+- [NEW] `POST /api/lots/{lot_id}/assay` & `GET /api/lots/{lot_id}/bis-delta`.
+
+---
+
+## Sequencing Summary
+
+| | Track A (Model & Dataset) | Track B (App Integration) |
+|---|---|---|
+| Now | Tier 1: bootstrap from open datasets. Tier 3: harvest dirty/stripped/unpopulated boards; annotate fine-grained taxonomy. Tier 2 (mined web sources) blocked pending licensing decision | Build multi-angle UI & pricing engine against `MockModelClient` |
+| Parallel | Multi-scale YOLOv8 training with focal loss & TFLite INT8 quantization | Collector Lite, audio fallbacks, Recycler Portal BIS-delta tolerance UI |
+| Hand-off | Ship model clearing Phase 4 thresholds | Swap `TFLiteModelClient` in with zero code changes |

google_drive_export/docs/scraper_plan_v2.md

@@ -0,0 +1,485 @@
+# E-Waste Image Dataset Pipeline: Revised Plan (v2)
+
+## 0. What changed from v1
+
+v1 framed the work as a scraping problem. v2 treats it as a **dataset-quality problem** in which scraping is one input. The main changes:
+
+| Area | v1 | v2 |
+| :--- | :--- | :--- |
+| Class definitions | Scrape folders and annotation classes disagreed | One taxonomy defined first; queries derived from it |
+| Deduplication | MD5 only (byte-identical) | Exact hash + perceptual hash (flip-aware) + embedding clusters, global across classes |
+| Aspect-ratio filter | Discarded > 3:1 (removes RAM/edge-finger images) | Flag > 3:1, discard only > 6:1 |
+| Min resolution | 250 px | Short side ≥ 480 px, long side ≥ 800 px |
+| Relevance | None | CLIP zero-shot filter + manual review queue |
+| Domain gap | Web images only | Real-world capture set, held-out real-world test split |
+| Splits | Random train/val | Cluster-aware train/val + separate real-world test |
+| Small objects | Not addressed | Resolution policy, `imgsz=1280`, tiling/two-stage inference |
+| Image handling | `verify()` only, JPEG q90 | `verify()` + `load()`, EXIF fix, alpha compositing, q95, originals preserved |
+| Resilience | Claimed backoff/fallback that `icrawler` lacks | Custom downloader with retries, backoff, per-domain rate limits |
+| Provenance | Sequential filenames | Hash filenames + SQLite manifest, resumable stages |
+| Targets & metrics | None | Per-class image/instance targets, evaluation plan |
+| BIS | Undefined | Proposed definition (needs sign-off) |
+
+---
+
+## 1. Objective & Scope
+
+Build a repeatable pipeline that produces a clean, deduplicated, well-documented image dataset for a YOLO detector that finds components on PCBs and supports an on-device **Board Integrity Score (BIS)** in a mobile app.
+
+**In scope:** collection, validation, normalization, deduplication, relevance filtering, manifesting, splitting, annotation guidelines, training/evaluation plan, export.
+**Out of scope for this document:** app UI, backend, pricing/valuation logic beyond BIS inputs.
+
+### Success criteria
+
+- ≥ 1,500 labeled images per class and ≥ 10,000 labeled instances per class in the training set (common YOLO guideline; revisit after the first training run).
+- Zero train/val/test leakage (no near-duplicate or same-board pairs across splits).
+- ≥ 40% of the final set is "in-the-wild" imagery (dirty, cluttered, phone-shot), not clean listing photos.
+- Held-out real-world test set of ≥ 300 images that is never used for tuning.
+- Every image traceable to its source URL, query, and processing history via the manifest.
+
+---
+
+## 2. Phase 0: Decisions to lock before writing code
+
+### 2.1 Detection taxonomy (fixes the v1 class mismatch)
+
+Define **object classes** (what YOLO detects) separately from **image-level tags** (metadata used for search and stratification).
+
+**Detection classes (v1 of the label set):**
+
+| Class | Definition | Notes |
+| :--- | :--- | :--- |
+| `cpu_socket` | LGA, PGA, or ZIF processor socket footprint (populated or empty) | Sockets only; see BGA note below |
+| `gold_finger` | Gold-plated edge-connector contacts (PCIe, RAM, edge cards) | Long, thin objects; boxes must not be forced square |
+| `ic_chip` | Packaged ICs, including BGA-package chips soldered to the board | Optional sub-attribute `bga` in annotation tool |
+| `tantalum_capacitor` | SMD tantalum capacitors (typically yellow/orange/black molded bodies with polarity bar) | Small object; needs labeling rules |
+| `desoldered_zone` | Region with exposed pads/solder residue where a component was removed | Ambiguous; needs a precise definition and example gallery |
+
+> **BGA correction:** BGA (ball grid array) is a chip *package* soldered onto the board. LGA/PGA are *sockets*. v1's `bga_cpu_socket` conflated them. In v2, BGA chips fall under `ic_chip`, and socket queries target LGA/PGA only.
+
+**Image-level tags (manifest metadata, not YOLO classes):**
+
+- `board_type`: desktop, laptop, phone, server, GPU, other
+- `condition`: intact, stripped, burnt/damaged
+- `source_type`: listing (white background), in_the_wild, recycling_yard, render/diagram (to be discarded)
+
+Folders are **not labels**. Search-query hints are noisy and are stored only as `class_hint` metadata.
+
+### 2.2 Target counts and attrition budget
+
+Boards contain several classes per image, so ~3,000-4,000 unique labeled images may cover all classes, but the rare/small classes drive the budget.
+
+| Class | Target images | Target instances | Difficulty |
+| :--- | :--- | :--- | :--- |
+| `ic_chip` | 1,500 | 15,000+ | Easy (abundant) |
+| `cpu_socket` | 1,500 | 3,000+ | Medium |
+| `gold_finger` | 1,500 | 5,000+ | Medium |
+| `tantalum_capacitor` | 1,500 | 10,000+ | Hard (small, visually varied) |
+| `desoldered_zone` | 1,500 | 5,000+ | Hard (ambiguous) |
+
+Expect **50-70% attrition** across validation, dedup, and relevance filtering, so plan to harvest roughly **3x the target** (about 10,000-12,000 raw downloads). Set the exact harvest budget after a 500-image pilot measures the real attrition rate.
+
+### 2.3 Board Integrity Score (BIS): proposed definition
+
+BIS must be defined now because it determines which labels are needed.
+
+Proposal (needs domain-owner sign-off):
+
+```
+V_present = Σ over detected high-value classes c of  w_c × count_c
+            (cpu_socket, gold_finger, ic_chip, tantalum_capacitor)
+V_missing = w_d × (number or area-normalized sum of desoldered_zone detections)
+
+BIS = 100 × V_present / (V_present + V_missing)
+```
+
+Open questions: value weights `w_c` (need recycler input), whether to use counts or area, per-board-type normalization, and how detector confidence thresholds affect BIS stability. Log these as decisions in `docs/decisions.md`.
+
+---
+
+## 3. System Architecture
+
+```mermaid
+flowchart TD
+    A["Config: taxonomy + query matrix"] --> B["URL harvest via icrawler: Bing / Baidu / Flickr"]
+    B --> C["Resilient downloader: retry, backoff, rate limit"]
+    RW["Real-world photo capture"] --> E
+    C --> D[("Originals store: untouched bytes, sha256 names")]
+    D --> E{"Validation"}
+    E -- "fail: corrupt, under 20 KB, below min resolution, over 6:1" --> X["Discard and log reason"]
+    E -- "pass (flag if over 3:1)" --> F["Normalize: EXIF fix, RGB, JPEG q95"]
+    F --> G{"Dedup: exact + perceptual, global"}
+    G -- "duplicate" --> X
+    G -- "unique" --> H{"CLIP relevance filter"}
+    H -- "irrelevant" --> X
+    H -- "borderline" --> R["Manual review queue"]
+    H -- "relevant" --> M["Manifest: SQLite"]
+    R --> M
+    M --> S["Cluster-aware split: train / val / test"]
+    S --> L["Annotation: CVAT or Roboflow"]
+    L --> T["YOLO training and evaluation"]
+```
+
+Design principles:
+
+1. **Stages are idempotent and resumable.** Each image has a `status` in the manifest; reruns skip completed work.
+2. **Originals are never modified.** Normalized copies are derived artifacts and can be regenerated with different settings.
+3. **Every discard is logged with a reason** so thresholds can be tuned from data instead of guesses.
+
+---
+
+## 4. Directory & Dataset Schema
+
+```
+ewaste_dataset_pipeline/
+├── scraper.py                  # CLI entry point (subcommands: harvest, validate, process, dedup, filter, split, report)
+├── config/
+│   ├── config.yaml             # thresholds, engines, rate limits, seeds
+│   ├── taxonomy.yaml           # classes, definitions, image-level tags
+│   └── queries.yaml            # query matrix (see §5.1)
+├── pipeline/
+│   ├── crawler.py              # URL harvest + custom downloader
+│   ├── validator.py
+│   ├── processor.py            # normalization
+│   ├── dedup.py                # exact + perceptual + embedding clusters
+│   ├── relevance.py            # CLIP zero-shot filter
+│   ├── manifest.py             # SQLite state store + JSONL/CSV export
+│   ├── split.py                # cluster-aware splitting
+│   └── report.py               # summary statistics
+├── tests/
+│   ├── fixtures/               # truncated JPEG, RGBA PNG, EXIF-rotated, CMYK, animated GIF, 5:1 RAM image
+│   └── test_*.py
+├── data/
+│   ├── originals/              # untouched downloaded bytes: <sha256[:16]>.<orig_ext>
+│   ├── images/                 # normalized JPEGs: <sha256[:16]>.jpg (flat store)
+│   ├── review/                 # borderline / flagged images for manual review
+│   ├── realworld/              # own captures, organized by session_id
+│   ├── manifest.db             # SQLite source of truth
+│   └── manifest.jsonl          # export for tooling
+├── splits/
+│   └── splits.json             # frozen image_id -> split mapping (versioned)
+├── reports/
+│   └── summary.json
+├── dataset_annotated/          # YOLO export after labeling
+│   ├── data.yaml
+│   ├── train/
+│   ├── val/
+│   └── test/                   # real-world sessions only
+├── docs/
+│   ├── decisions.md
+│   └── labeling_guide.md
+└── requirements.txt
+```
+
+The flat `images/` store replaces per-class folders because one image can match several queries. Per-hint browsing views can be generated from the manifest on demand.
+
+---
+
+## 5. Core Modules
+
+### 5.1 Query & Category Registry (`queries.yaml`)
+
+Queries are **derived from the taxonomy**, then expanded along diversity axes. Two or three queries per class, as in v1, will not produce enough variety.
+
+**Expansion matrix:** `class term × board_type × condition × view/lighting × language`
+
+| Axis | Example values |
+| :--- | :--- |
+| Board type | desktop motherboard, laptop mainboard, smartphone PCB, server board, GPU PCB |
+| Condition | intact, stripped, burnt, corroded, dusty |
+| View / setting | top view, close-up macro, angled, recycling bin, workbench, e-waste pile, hand-held |
+| Language | English, plus Chinese, Spanish, German, Hindi, Vietnamese (recycling hubs and local marketplaces) |
+
+Example seed terms per class:
+
+- `cpu_socket`: "LGA 1151 socket close up", "LGA 1700 socket bent pins", "PGA socket AM4 motherboard", "empty CPU socket motherboard scrap"
+- `gold_finger`: "PCIe x16 gold fingers PCB", "RAM module gold contacts scrap", "edge connector gold plated board"
+- `ic_chip`: "BGA chip on motherboard close up", "SMD IC laptop motherboard", "chipset heatsink removed motherboard"
+- `tantalum_capacitor`: "SMD tantalum capacitor yellow PCB", "tantalum capacitor polarity stripe board", "tantalum capacitors recycling"
+- `desoldered_zone`: "desoldered components exposed pads PCB", "cannibalized motherboard ewaste scrap", "hot air removed chips board", "burnt circuit board blowtorch"
+
+Notes:
+
+- Search engines cap results per query (often a few hundred at best), so **volume comes from query variety**, not from raising `max_num`.
+- Record `query`, `engine`, and `class_hint` per URL in the manifest.
+
+### 5.2 Harvesting & Download Engine (`crawler.py`)
+
+- **Engines:** `icrawler` Bing, Baidu, and Flickr crawlers. The Google crawler is unreliable and optional. **DuckDuckGo is not natively supported by `icrawler`** and is removed from v1 scope; add it later only through a separate adapter.
+- **Two-step design:**
+  1. Use `icrawler` to harvest URLs and metadata into the manifest with status `pending`.
+  2. A custom downloader (subclass of `icrawler`'s `ImageDownloader`, or a `requests` session pool) performs the fetch.
+- **Resilience (implemented explicitly, since `icrawler` does not provide it):**
+  - Exponential backoff with jitter (e.g., `tenacity`), max 4 retries
+  - Per-domain rate limiting and concurrency caps
+  - Connect/read timeouts (e.g., 5s / 20s), maximum download size (e.g., 25 MB)
+  - Content-Type and magic-byte sniffing before saving
+  - Rotating realistic User-Agent strings
+  - Respect HTTP 429 / `Retry-After`
+- **Concurrency:** 4-8 downloader threads per query, global cap across queries.
+- **Resumability:** URL-normalized dedup at the manifest level so reruns never re-fetch a URL already tried (successful or permanently failed).
+- **Storage:** save untouched bytes to `data/originals/` under `<sha256[:16]>.<ext>`.
+
+### 5.3 Validation Engine (`validator.py`)
+
+Checks run in a fixed order so cheap checks fail first:
+
+| # | Check | Rule | Action |
+| :--- | :--- | :--- | :--- |
+| 1 | File size | < 20 KB | Discard (`too_small_file`) |
+| 2 | Integrity | `Image.open()` → `verify()` → **reopen** → `load()` (catches truncation that `verify()` misses) | Discard (`corrupt`) |
+| 3 | Animated | Multi-frame GIF/WEBP | Use first frame; flag `animated` |
+| 4 | Resolution | Short side < 480 px **or** long side < 800 px | Discard (`low_resolution`) |
+| 5 | Aspect ratio | > 3:1 or < 1:3 | **Flag** `extreme_aspect`, send to review |
+| 6 | Aspect ratio (hard) | > 6:1 or < 1:6 | Discard (`extreme_aspect_hard`) |
+
+Why the aspect-ratio change: RAM modules and edge-finger crops are naturally ~4.5-5:1. A 3:1 hard cutoff would remove exactly the images the `gold_finger` class needs.
+
+Why the resolution change: tantalum capacitors and desoldered zones occupy very few pixels; a 250 px image contains almost no usable detail for them.
+
+### 5.4 Normalization Engine (`processor.py`)
+
+Applied to a **copy** of each validated image:
+
+1. **`ImageOps.exif_transpose()`** first, so phone photos are not rotated incorrectly.
+2. **Mode conversion to RGB:**
+   - RGBA / LA / P-with-transparency: composite onto a **white** background (a naive `convert("RGB")` turns transparency black).
+   - CMYK: convert via embedded ICC profile when present (`ImageCms`), otherwise standard conversion.
+   - Grayscale: replicate to 3 channels.
+3. **Size cap:** if the long side > 2560 px, downscale with LANCZOS (never upscale). This bounds storage while preserving detail for small objects.
+4. **Encode:** JPEG **quality 95**, 4:4:4 chroma subsampling (`subsampling=0`), `optimize=True`. This limits the extra lossy generation and keeps fine solder/pad detail that q90 with default 4:2:0 would blur.
+5. **Metadata:** strip EXIF (privacy and size); store dimensions and original format in the manifest.
+6. Output name: `data/images/<sha256[:16]>.jpg`, where the hash is of the original file bytes.
+
+### 5.5 Deduplication Engine (`dedup.py`)
+
+MD5 catches only byte-identical files. A resized or recompressed copy of the same photo gets a different hash, and near-duplicates that straddle train/val inflate metrics. v2 uses three layers, applied **globally across all classes and all queries**:
+
+| Layer | Method | Catches |
+| :--- | :--- | :--- |
+| 1. Exact | SHA-256 of original bytes (pre-decode) and of decoded pixel array | Byte-identical and re-saved-identical images |
+| 2. Near-duplicate | Perceptual hash (`imagehash` pHash, 64-bit, plus dHash) with Hamming distance ≤ 6; also hash the **horizontally flipped** image and compare | Resizes, recompression, minor crops/edits, mirror copies |
+| 3. Semantic clusters | CLIP image embeddings; cosine similarity ≥ 0.95 → same cluster (agglomerative or connected components) | Same board photographed from slightly different angles, same listing series |
+
+Implementation notes:
+
+- For ≤ 100k images, pairwise Hamming comparison with vectorized NumPy popcount is fast enough; use a BK-tree or LSH banding beyond that.
+- Within a duplicate group, **keep the highest-resolution member** and record all members' URLs under it in the manifest.
+- Every image gets a `cluster_id`. Layers 1-2 remove images; layer 3 does **not** remove images, it only labels clusters for leakage-safe splitting (§6).
+
+### 5.6 Relevance Filter (`relevance.py`)
+
+Search results contain many stock illustrations, renders, diagrams, product boxes, logos, and off-topic hardware.
+
+- **Model:** `open_clip` (e.g., ViT-B/32) zero-shot scoring.
+- **Positive prompts:** "a photo of a printed circuit board", "a photo of a computer motherboard", "a photo of electronic waste".
+- **Negative prompts:** "a 3D render", "a diagram or schematic", "a product box", "a logo", "a screenshot", "a computer case", "a person", "an image with a watermark".
+- **Buckets:** `relevant` (auto-keep), `borderline` (manual review), `irrelevant` (discard). Tune the two thresholds on a **hand-labeled sample of ~200 images**, then report precision/recall of the filter.
+- **`source_type` tagging:** use zero-shot prompts to estimate `listing` vs `in_the_wild` so the domain mix can be monitored.
+- **Watermarks/stock:** flagged, not auto-discarded (zero-shot watermark detection is unreliable). Flagged images go to review.
+
+### 5.7 Manual Review
+
+- Review **all** `borderline` and `extreme_aspect` items, plus a **10% random sample** of auto-kept images to estimate residual noise.
+- Use a contact-sheet tool (FiftyOne or a simple generated HTML grid) that supports keep/discard/re-tag.
+- Record reviewer decisions in the manifest (`review_status`, `reviewer`, `reviewed_at`).
+
+### 5.8 Manifest & Provenance (`manifest.py`)
+
+SQLite is the source of truth, exported to JSONL/CSV for tooling. One row per image (plus a table of source URLs per image).
+
+| Field | Description |
+| :--- | :--- |
+| `image_id` | sha256[:16] of original bytes |
+| `source_urls[]` | all URLs that produced this image |
+| `engine`, `queries[]`, `class_hints[]` | how it was found |
+| `scraped_at` | timestamp |
+| `orig_format`, `width`, `height`, `filesize`, `aspect_ratio` | measured properties |
+| `flags[]` | `extreme_aspect`, `animated`, `watermark_suspect`, etc. |
+| `phash`, `dhash` | perceptual hashes |
+| `cluster_id` | duplicate/semantic cluster |
+| `clip_score`, `relevance_bucket` | filter outputs |
+| `board_type`, `condition`, `source_type` | image-level tags |
+| `status` | `pending → downloaded → validated → normalized → deduped → filtered → kept` or `discarded` |
+| `discard_reason` | why it was removed |
+| `review_status` | reviewer outcome |
+| `split` | `train` / `val` / `test` (set by §6) |
+| `session_id`, `board_id` | for real-world captures |
+
+---
+
+## 6. Real-World Data & Splitting
+
+### 6.1 Real-world capture set (closes the domain gap)
+
+Web results skew toward clean listing photos. The deployed app will see dirty, cluttered, phone-shot boards under poor lighting.
+
+- Capture **≥ 300 test images plus ≥ 300 additional training images** from recycling partners or a bench setup.
+- Vary: phone models, lighting (daylight, warm, harsh flash, dim), backgrounds, distances (macro to whole-board), angles, board types, and conditions.
+- Record `session_id` (one per visit/location/day) and `board_id` (one per physical board). Photograph each board from multiple angles.
+- Capture at native phone resolution; keep originals.
+
+### 6.2 Split policy (leakage-safe)
+
+| Split | Composition | Rule |
+| :--- | :--- | :--- |
+| `train` | Web + real-world training sessions | ~80% of the non-test pool |
+| `val` | Web + real-world training sessions | ~20% of the non-test pool; used for model selection |
+| `test` | **Real-world sessions only, held out** | Never used for tuning or threshold selection; sessions not present in train/val |
+
+- Split by **group**, not by image: use `cluster_id` for web images and `board_id`/`session_id` for real-world images (`GroupShuffleSplit` or similar), so near-duplicates and same-board photos never straddle splits.
+- Stratify on `class_hints` and `source_type` where feasible so val reflects the domain mix.
+- Freeze the result in `splits/splits.json` with the random seed; regenerate only by explicit version bump.
+
+---
+
+## 7. Annotation
+
+- Write `docs/labeling_guide.md` **before** labeling: definitions and 10+ positive/negative example crops per class, plus edge cases (partially occluded, damaged, blurry).
+- **Label at full resolution** (never label downscaled copies).
+- **Minimum object size policy:** objects smaller than ~16 px at the intended training resolution are either marked `ignore` or excluded consistently; document the choice.
+- Boxes: tight; `gold_finger` boxes follow the actual (elongated) strip; no padding to squares.
+- **Quality control:** double-annotate a 10% sample, compute IoU/agreement per class, and resolve disagreements to refine the guide. `desoldered_zone` is the class most likely to need a redefinition.
+- Tools: CVAT or Roboflow. Export in YOLO format with the frozen splits.
+
+---
+
+## 8. Training & Evaluation Plan
+
+### 8.1 Small-object strategy
+
+- Train with **`imgsz=1280`** (or 960 as a compromise) rather than the 640 default.
+- For on-device use, avoid running the full nano model at 1280 on a phone. Two options to evaluate:
+  1. **Tiled inference** (SAHI-style): overlapping 640 px tiles with merged detections.
+  2. **Two-stage:** a light board detector at 640 → crop board → component detector on the crop.
+- Consider mosaic/scale augmentation tuned for small objects; verify augmentations do not destroy `gold_finger` aspect ratios.
+
+### 8.2 Metrics
+
+- mAP@50 and mAP@50-95 **per class**, not just overall.
+- **Recall by object-size bucket** (small / medium / large by pixel area), to expose the small-object problem.
+- Report results on `val` and, separately, on the real-world `test` split. **The test-set number is the headline number.**
+- BIS validation: compare BIS from ground-truth labels vs BIS from detections on the test set, and report the error.
+
+### 8.3 Export checks
+
+- Export to ONNX / TFLite and **re-evaluate on the test set after export and after quantization**; set an acceptable mAP-drop budget (e.g., ≤ 2 points) before shipping to `mobile/`.
+
+---
+
+## 9. Technical Stack
+
+| Tool / Library | Role |
+| :--- | :--- |
+| Python 3.10+ | Runtime |
+| `icrawler` | URL harvesting (Bing, Baidu, Flickr; Google optional) |
+| `requests`, `tenacity` | Custom downloader with retry/backoff |
+| `Pillow` | Validation, EXIF handling, normalization, ICC conversion |
+| `numpy` | Vectorized hash comparison |
+| `imagehash` | Perceptual hashing (pHash/dHash) |
+| `hashlib` | Exact SHA-256 hashing |
+| `open_clip_torch` + `torch` | Relevance filter and embeddings for clustering |
+| `scikit-learn` | Group-aware splitting, clustering |
+| `PyYAML` | Configuration |
+| `tqdm` | Progress monitoring |
+| `fiftyone` (optional) | Review UI, embedding visualization |
+| `ultralytics`, `sahi` | Training and tiled inference |
+| `pytest` | Tests |
+
+Pin exact versions in `requirements.txt` and record them in every report.
+
+---
+
+## 10. Execution Plan
+
+### Step 1: Install
+
+```bash
+pip install -r requirements.txt
+```
+
+### Step 2: Run stages (each is resumable)
+
+```bash
+python3 scraper.py harvest   --config config/config.yaml   # collect URLs into manifest
+python3 scraper.py download                                 # fetch originals with retries
+python3 scraper.py validate                                 # integrity, size, aspect
+python3 scraper.py process                                  # EXIF fix, RGB, JPEG q95
+python3 scraper.py dedup                                    # exact + perceptual + clusters
+python3 scraper.py filter                                   # CLIP relevance + review queue
+python3 scraper.py split                                    # cluster-aware splits
+python3 scraper.py report                                   # summary statistics
+```
+
+### Step 3: Verification report (`reports/summary.json` and printed table)
+
+Per `class_hint` and overall:
+
+- Raw URLs harvested, downloads succeeded/failed
+- Discards **by reason** (corrupt, too small, low resolution, hard aspect, exact dup, near dup, irrelevant)
+- Flagged and reviewed counts
+- Final kept count vs target (§2.2)
+- Resolution distribution and `source_type` mix (in-the-wild share vs the 40% goal)
+- Number of duplicate clusters and largest cluster size
+- Split sizes and a leakage check (no `cluster_id`/`board_id` shared across splits)
+
+---
+
+## 11. Testing
+
+Unit tests using fixtures in `tests/fixtures/`:
+
+| Test | Expectation |
+| :--- | :--- |
+| Truncated JPEG | Rejected by the `verify()` + `load()` sequence |
+| RGBA PNG with transparency | Composited on white, not black |
+| EXIF-rotated phone photo | Output is upright |
+| CMYK JPEG | Correct RGB conversion |
+| Animated GIF | First frame used, `animated` flag set |
+| 5:1 RAM image | Flagged, **not** discarded |
+| 8:1 banner | Discarded with `extreme_aspect_hard` |
+| Resized / recompressed / flipped copy of a fixture | Detected as near-duplicate |
+| Rerun after interruption | No re-download, no duplicate rows |
+| Leakage check | No shared `cluster_id` across splits |
+
+---
+
+## 12. Milestones & Acceptance Criteria
+
+| Phase | Deliverable | Acceptance criterion |
+| :--- | :--- | :--- |
+| 0. Decisions | `taxonomy.yaml`, target counts, BIS definition in `docs/decisions.md` | Signed off by project owner |
+| 1. Pipeline build | All modules + tests passing | Fixtures behave as specified in §11 |
+| 2. Pilot | ~500-image end-to-end run | Attrition rate measured; CLIP thresholds tuned on 200 hand-labeled images |
+| 3. Full collection | Harvest budget executed; real-world capture ≥ 600 images | Kept counts meet §2.2 or gaps identified and queries extended |
+| 4. QA | Manual review complete; frozen `splits.json` | Leakage check clean; ≥ 40% in-the-wild |
+| 5. Annotation | Labeled dataset + `labeling_guide.md` | Inter-annotator agreement acceptable per class |
+| 6. Training & eval | Baseline model, per-class and size-bucket metrics | Test-set results reported; failure analysis written |
+| 7. Export | ONNX/TFLite + post-quantization test results | mAP drop within budget; BIS error reported |
+
+---
+
+## 13. Risks & Mitigations
+
+| Risk | Mitigation |
+| :--- | :--- |
+| Search engines return too few unique images per query | Wide query matrix (§5.1), multiple engines, multilingual queries, real-world capture |
+| Heavy overrepresentation of clean listing photos | `source_type` monitoring; explicit in-the-wild target; real-world capture |
+| Tiny objects (tantalum caps) undetectable | Higher min resolution, `imgsz=1280`, tiling/two-stage, small-object metrics |
+| `desoldered_zone` label ambiguity | Precise definition, example gallery, double annotation, willingness to redefine or move to segmentation |
+| Near-duplicate leakage inflates metrics | Cluster-aware splits, leakage check in CI, held-out real-world test set |
+| CLIP filter discards valid images | Threshold tuned on hand-labeled sample; borderline goes to review, not discard |
+| Class imbalance (ICs abundant, tantalum rare) | Per-class targets, targeted queries and captures for rare classes, per-class metrics |
+| Quantization degrades small-object accuracy | Post-export evaluation with a mAP-drop budget; consider mixed precision |
+| Pipeline state lost mid-run | SQLite manifest, idempotent stages, originals preserved |
+| BIS unstable or not meaningful | Define and validate BIS against ground-truth labels early (§2.3, §8.2) |
+
+---
+
+## 14. Immediate Next Actions
+
+1. Review and finalize the taxonomy and class definitions (§2.1).
+2. Get domain input on BIS weights and whether BIS uses counts or area (§2.3).
+3. Stand up the repository skeleton from §4, with config, manifest schema, and test fixtures.
+4. Run the 500-image pilot to measure attrition and tune the relevance thresholds.
+5. Schedule the first real-world capture session so the test set starts accumulating early.

google_drive_export/pipeline/auto_annotate.py

@@ -0,0 +1,157 @@
+"""Automated Zero-Shot Auto-Annotation Pipeline using YOLO-World.
+
+Auto-labels all images in `data/images/` using the updated taxonomy:
+  0: cpu_socket
+  1: gold_finger
+  2: ic_chip
+  3: tantalum_capacitor
+  4: forcibly_desoldered_pad
+  5: factory_unpopulated_pad
+  6: occluded_region
+
+Generates YOLO format bounding box label files (.txt) and data.yaml in `data/annotated_auto/`.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import shutil
+from pathlib import Path
+
+import yaml
+from PIL import Image
+from tqdm import tqdm
+
+# Ensure cache directories reside within workspace
+cache_dir = Path("data/cache").resolve()
+cache_dir.mkdir(parents=True, exist_ok=True)
+os.environ["TORCH_HOME"] = str(cache_dir)
+os.environ["HF_HOME"] = str(cache_dir)
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+log = logging.getLogger(__name__)
+
+CLASS_NAMES = [
+    "cpu_socket",
+    "gold_finger",
+    "ic_chip",
+    "tantalum_capacitor",
+    "forcibly_desoldered_pad",
+    "factory_unpopulated_pad",
+    "occluded_region",
+]
+
+# Prompts tuned for zero-shot YOLO-World detector
+CLASS_PROMPTS = [
+    "CPU socket",
+    "gold finger edge connector",
+    "microchip",
+    "tantalum capacitor",
+    "desoldered solder pad",
+    "unpopulated solder pad",
+    "heatsink shield",
+]
+
+
+def run_auto_annotation(
+    data_dir: str | Path = "data",
+    output_dir: str | Path = "data/annotated_auto",
+    conf_threshold: float = 0.02,
+    max_images: int | None = None,
+) -> dict:
+    data_dir = Path(data_dir)
+    output_dir = Path(output_dir)
+    images_in_dir = data_dir / "images"
+    
+    images_out_dir = output_dir / "images"
+    labels_out_dir = output_dir / "labels"
+    images_out_dir.mkdir(parents=True, exist_ok=True)
+    labels_out_dir.mkdir(parents=True, exist_ok=True)
+
+    log.info("Loading YOLO-World zero-shot model...")
+    from ultralytics import YOLOWorld
+
+    model = YOLOWorld("yolov8s-worldv2.pt")
+    model.set_classes(CLASS_PROMPTS)
+    log.info("YOLO-World model configured with %d classes (conf threshold: %.3f).", len(CLASS_PROMPTS), conf_threshold)
+
+    image_files = sorted(list(images_in_dir.glob("*.jpg")) + list(images_in_dir.glob("*.png")))
+    if max_images:
+        image_files = image_files[:max_images]
+
+    log.info("Found %d images to auto-annotate.", len(image_files))
+
+    class_detection_counts = {name: 0 for name in CLASS_NAMES}
+    total_images_processed = 0
+    total_boxes_generated = 0
+
+    for img_path in tqdm(image_files, desc="Auto-annotating images", unit="img"):
+        img_name = img_path.name
+        stem = img_path.stem
+
+        # Copy image to output directory
+        target_img_path = images_out_dir / img_name
+        if not target_img_path.exists():
+            try:
+                shutil.copy2(img_path, target_img_path)
+            except Exception as e:
+                log.warning("Could not copy %s: %s", img_name, e)
+
+        # Run inference
+        results = model.predict(str(img_path), conf=conf_threshold, verbose=False)
+        label_file = labels_out_dir / f"{stem}.txt"
+
+        lines = []
+        if results and len(results) > 0:
+            boxes = results[0].boxes
+            if boxes is not None and len(boxes) > 0:
+                xywhn = boxes.xywhn.cpu().numpy()
+                cls_ids = boxes.cls.cpu().numpy().astype(int)
+
+                for (x, y, w, h), cls_id in zip(xywhn, cls_ids):
+                    if 0 <= cls_id < len(CLASS_NAMES):
+                        lines.append(f"{cls_id} {x:.6f} {y:.6f} {w:.6f} {h:.6f}")
+                        class_name = CLASS_NAMES[cls_id]
+                        class_detection_counts[class_name] += 1
+                        total_boxes_generated += 1
+
+        with open(label_file, "w", encoding="utf-8") as f:
+            f.write("\n".join(lines) + ("\n" if lines else ""))
+
+        total_images_processed += 1
+
+    # Create dataset yaml specification
+    dataset_yaml = {
+        "path": str(output_dir.resolve()),
+        "train": "images",
+        "val": "images",
+        "names": {i: name for i, name in enumerate(CLASS_NAMES)},
+    }
+    yaml_path = output_dir / "data.yaml"
+    with open(yaml_path, "w", encoding="utf-8") as f:
+        yaml.dump(dataset_yaml, f, default_flow_style=False)
+
+    summary = {
+        "total_images_processed": total_images_processed,
+        "total_boxes_generated": total_boxes_generated,
+        "conf_threshold": conf_threshold,
+        "class_detection_counts": class_detection_counts,
+        "output_directory": str(output_dir.resolve()),
+        "data_yaml": str(yaml_path.resolve()),
+    }
+
+    summary_path = output_dir / "auto_annotation_summary.json"
+    with open(summary_path, "w", encoding="utf-8") as f:
+        json.dump(summary, f, indent=2)
+
+    log.info("Auto-annotation complete! Summary saved to %s", summary_path)
+    return summary
+
+
+if __name__ == "__main__":
+    import sys
+    max_imgs = int(sys.argv[1]) if len(sys.argv) > 1 and sys.argv[1].isdigit() else None
+    conf_val = float(sys.argv[2]) if len(sys.argv) > 2 else 0.02
+    run_auto_annotation(conf_threshold=conf_val, max_images=max_imgs)
+

google_drive_export/pipeline/config.py

@@ -0,0 +1,109 @@
+"""Configuration loading, filesystem layout and logging setup."""
+from __future__ import annotations
+
+import copy
+import logging
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+
+
+def load_yaml(path: Path) -> dict[str, Any]:
+    with open(path, "r", encoding="utf-8") as fh:
+        return yaml.safe_load(fh) or {}
+
+
+def deep_update(base: dict, override: dict) -> dict:
+    """Recursively merge ``override`` into ``base`` (in place) and return it."""
+    for key, value in override.items():
+        if isinstance(value, dict) and isinstance(base.get(key), dict):
+            deep_update(base[key], value)
+        else:
+            base[key] = copy.deepcopy(value)
+    return base
+
+
+def load_config(path: str | Path | None = None, overrides: dict | None = None) -> dict[str, Any]:
+    cfg_path = Path(path) if path else PROJECT_ROOT / "config" / "config.yaml"
+    cfg = load_yaml(cfg_path)
+    cfg["_config_dir"] = str(cfg_path.resolve().parent)
+    if overrides:
+        deep_update(cfg, overrides)
+    return cfg
+
+
+def load_taxonomy(cfg: dict) -> dict[str, Any]:
+    return load_yaml(Path(cfg["_config_dir"]) / "taxonomy.yaml")
+
+
+def load_queries(cfg: dict) -> dict[str, Any]:
+    return load_yaml(Path(cfg["_config_dir"]) / "queries.yaml")
+
+
+@dataclass(frozen=True)
+class Paths:
+    """Filesystem layout. Manifest paths are stored relative to ``data``."""
+
+    base: Path
+    data: Path
+    originals: Path
+    images: Path
+    review: Path
+    realworld: Path
+    reports: Path
+    splits: Path
+    manifest_db: Path
+    manifest_jsonl: Path
+
+    def abs(self, rel: str | Path) -> Path:
+        return self.data / rel
+
+    def rel(self, path: str | Path) -> str:
+        return str(Path(path).resolve().relative_to(self.data.resolve()))
+
+    def ensure(self) -> None:
+        for p in (self.data, self.originals, self.images, self.review, self.realworld,
+                  self.reports, self.splits):
+            p.mkdir(parents=True, exist_ok=True)
+
+
+def get_paths(cfg: dict, base: str | Path | None = None) -> Paths:
+    base_dir = Path(base).resolve() if base else PROJECT_ROOT
+    pcfg = cfg.get("paths", {})
+    data = base_dir / pcfg.get("data_dir", "data")
+    return Paths(
+        base=base_dir,
+        data=data,
+        originals=data / "originals",
+        images=data / "images",
+        review=data / "review",
+        realworld=data / "realworld",
+        reports=base_dir / pcfg.get("reports_dir", "reports"),
+        splits=base_dir / pcfg.get("splits_dir", "splits"),
+        manifest_db=data / "manifest.db",
+        manifest_jsonl=data / "manifest.jsonl",
+    )
+
+
+def setup_logging(verbose: bool = False) -> None:
+    """Configure logging *before* icrawler is imported.
+
+    icrawler calls ``logging.basicConfig`` when a crawler is constructed; that is a
+    no-op once the root logger already has handlers, so configuring first keeps our
+    format and level in charge.
+    """
+    level = logging.DEBUG if verbose else logging.INFO
+    root = logging.getLogger()
+    if not root.handlers:
+        handler = logging.StreamHandler(sys.stderr)
+        handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)-7s %(name)s: %(message)s",
+                                               datefmt="%H:%M:%S"))
+        root.addHandler(handler)
+    root.setLevel(level)
+    logging.getLogger("urllib3").setLevel(logging.WARNING)
+    logging.getLogger("PIL").setLevel(logging.WARNING)

google_drive_export/pipeline/crawler.py

@@ -0,0 +1,275 @@
+"""Harvesting engine: query search engines (icrawler / HTTP fallback) and download raw image binaries.
+
+Flow:
+  1. Build query list from queries.yaml matrix.
+  2. For each query and engine:
+       - Skip if `harvest_runs` records the run as done.
+       - Surface image URLs and store in `sources` and `hits` tables via `manifest.add_hit`.
+       - Record completed run in `harvest_runs`.
+  3. Download pending URLs into `data/originals/`, computing SHA-256 ID.
+  4. Register downloaded files in `images` table with status 'downloaded'.
+"""
+from __future__ import annotations
+
+import hashlib
+import logging
+import mimetypes
+import urllib.request
+import urllib.error
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Sequence
+
+from tqdm import tqdm
+
+from .manifest import Manifest, normalize_url
+from .queries import QuerySpec, build_queries
+
+log = logging.getLogger(__name__)
+
+HEADERS = {
+    "User-Agent": (
+        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
+        "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+    ),
+    "Accept": "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8",
+}
+
+EXT_MAP = {
+    "image/jpeg": ".jpg",
+    "image/jpg": ".jpg",
+    "image/png": ".png",
+    "image/webp": ".webp",
+    "image/gif": ".gif",
+    "image/bmp": ".bmp",
+    "image/tiff": ".tif",
+    "image/heic": ".heic",
+    "image/heif": ".heif",
+}
+
+
+def download_single_url(
+    source: dict, originals_dir: Path, timeout: float = 10.0
+) -> tuple[dict, str | None, str | None, int | None, str | None]:
+    """Download raw binary for one URL.
+
+    Returns (source, image_id, filepath, http_status, error_message).
+    """
+    url = source["url"]
+    url_norm = source["url_norm"]
+    req = urllib.request.Request(url, headers=HEADERS)
+
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            content_type = resp.headers.get("Content-Type", "").split(";")[0].strip().lower()
+            data = resp.read()
+            http_status = resp.status
+    except urllib.error.HTTPError as exc:
+        return source, None, None, exc.code, f"HTTPError: {exc.code}"
+    except Exception as exc:
+        return source, None, None, None, f"{type(exc).__name__}: {exc}"
+
+    if len(data) < 500:
+        return source, None, None, http_status, "file_too_small_raw"
+
+    sha = hashlib.sha256(data).hexdigest()
+    image_id = sha[:16]
+
+    ext = EXT_MAP.get(content_type) or Path(url).suffix.lower()
+    if not ext or len(ext) > 5 or ext not in (".jpg", ".jpeg", ".png", ".webp", ".gif", ".bmp", ".tif", ".heic"):
+        ext = ".jpg"
+
+    dst = originals_dir / f"{image_id}{ext}"
+    if not dst.exists():
+        originals_dir.mkdir(parents=True, exist_ok=True)
+        tmp = dst.with_name(dst.name + f".tmp")
+        tmp.write_bytes(data)
+        tmp.replace(dst)
+
+    return source, image_id, str(dst), http_status, None
+
+
+def download_pending_sources(
+    manifest: Manifest, originals_dir: Path, data_dir: Path, cfg: dict
+) -> dict[str, int]:
+    """Download pending URLs from manifest into `originals_dir`."""
+    ccfg = cfg.get("crawler", {})
+    workers = int(ccfg.get("threads", 4))
+    timeout = float(ccfg.get("timeout", 10.0))
+
+    pending = manifest.pending_sources()
+    stats = {"downloaded": 0, "download_failed": 0}
+    if not pending:
+        log.info("crawler: no pending sources to download")
+        return stats
+
+    log.info("crawler: downloading %d pending URL(s)", len(pending))
+
+    def work(src: dict):
+        return download_single_url(src, originals_dir, timeout=timeout)
+
+    with ThreadPoolExecutor(max_workers=workers) as ex:
+        futures = [ex.submit(work, s) for s in pending]
+        with manifest.transaction():
+            for fut in tqdm(as_completed(futures), total=len(futures), desc="download", unit="url"):
+                src, image_id, dst_path, http_status, err = fut.result()
+                if err is None and image_id and dst_path:
+                    data_file = Path(dst_path)
+                    data = data_file.read_bytes()
+                    sha = hashlib.sha256(data).hexdigest()
+                    rel_path = str(data_file.relative_to(data_dir))
+
+                    manifest.add_image(
+                        image_id=image_id,
+                        sha256=sha,
+                        origin="web",
+                        source_ref=src["url"],
+                        orig_path=rel_path,
+                        orig_format=data_file.suffix.lstrip(".").lower(),
+                        filesize=len(data),
+                        status="downloaded",
+                    )
+                    manifest.mark_source(
+                        src["url_norm"],
+                        status="downloaded",
+                        http_status=http_status,
+                        image_id=image_id,
+                        attempts=1,
+                    )
+                    stats["downloaded"] += 1
+                else:
+                    manifest.mark_source(
+                        src["url_norm"],
+                        status="failed",
+                        http_status=http_status,
+                        error=err,
+                        attempts=1,
+                    )
+                    stats["download_failed"] += 1
+
+    log.info("crawler download stats: %s", stats)
+    return stats
+
+
+def run_icrawler_harvest(
+    manifest: Manifest,
+    queries: Sequence[QuerySpec],
+    data_dir: Path,
+    engine_name: str = "bing",
+    max_num: int = 50,
+    force: bool = False,
+    filter_classes: set[str] | Sequence[str] | None = None,
+) -> dict[str, int]:
+    """Harvest image binaries using icrawler, save to data/originals, and register in manifest."""
+    stats = {"runs": 0, "urls_found": 0, "urls_new": 0, "images_harvested": 0}
+    try:
+        if engine_name.lower() == "bing":
+            from icrawler.builtin import BingImageCrawler as CrawlerEngine
+        elif engine_name.lower() == "flickr":
+            from icrawler.builtin import FlickrImageCrawler as CrawlerEngine
+        elif engine_name.lower() == "baidu":
+            from icrawler.builtin import BaiduImageCrawler as CrawlerEngine
+        else:
+            log.warning("Unknown engine '%s', defaulting to Bing", engine_name)
+            from icrawler.builtin import BingImageCrawler as CrawlerEngine
+    except ImportError:
+        log.warning("icrawler is not installed; skipping search engine crawling")
+        return stats
+
+    import tempfile
+    import shutil
+
+    originals_dir = data_dir / "originals"
+    originals_dir.mkdir(parents=True, exist_ok=True)
+
+    filter_set = set(filter_classes) if filter_classes else None
+
+    for qspec in queries:
+        if filter_set and qspec.class_hint not in filter_set:
+            continue
+        if not force and manifest.run_done(engine_name, qspec.query):
+            log.debug("Skip harvest done run: %s / %s", engine_name, qspec.query)
+            continue
+
+        tmp_dir = Path(tempfile.mkdtemp(prefix="icrawler_"))
+        try:
+            crawler = CrawlerEngine(
+                downloader_threads=2,
+                storage={"root_dir": str(tmp_dir)},
+                log_level=logging.WARNING,
+            )
+            crawler.crawl(keyword=qspec.query, max_num=max_num)
+
+            found_count = 0
+            new_count = 0
+            with manifest.transaction():
+                for img_file in tmp_dir.glob("*"):
+                    if img_file.is_file() and img_file.stat().st_size > 500:
+                        found_count += 1
+                        data = img_file.read_bytes()
+                        sha = hashlib.sha256(data).hexdigest()
+                        image_id = sha[:16]
+                        ext = img_file.suffix.lower()
+                        if not ext or len(ext) > 5 or ext not in (".jpg", ".jpeg", ".png", ".webp", ".gif", ".bmp"):
+                            ext = ".jpg"
+
+                        dst_file = originals_dir / f"{image_id}{ext}"
+                        if not dst_file.exists():
+                            dst_file.write_bytes(data)
+
+                        source_url = f"icrawler://{engine_name}/{qspec.class_hint}/{image_id}"
+                        is_new = manifest.add_hit(
+                            source_url, engine_name, qspec.query, class_hint=qspec.class_hint, lang=qspec.lang
+                        )
+                        if is_new:
+                            new_count += 1
+
+                        rel_path = str(dst_file.relative_to(data_dir))
+                        manifest.add_image(
+                            image_id=image_id,
+                            sha256=sha,
+                            origin="web",
+                            source_ref=source_url,
+                            orig_path=rel_path,
+                            orig_format=ext.lstrip("."),
+                            filesize=len(data),
+                            status="downloaded",
+                        )
+                        manifest.mark_source(
+                            source_url,
+                            status="downloaded",
+                            image_id=image_id,
+                        )
+                        stats["images_harvested"] += 1
+
+            manifest.record_run(
+                engine_name, qspec.query, qspec.class_hint, max_num, found_count, new_count
+            )
+            stats["runs"] += 1
+            stats["urls_found"] += found_count
+            stats["urls_new"] += new_count
+        except Exception as exc:
+            log.error("icrawler harvest failed for %s (%s): %s", qspec.query, engine_name, exc)
+        finally:
+            shutil.rmtree(tmp_dir, ignore_errors=True)
+
+    log.info("harvest stats (%s): %s", engine_name, stats)
+    return stats
+
+
+def run(
+    manifest: Manifest, cfg: dict, data_dir: Path, engine: str = "bing", max_num: int = 50, force: bool = False, filter_classes: set[str] | Sequence[str] | None = None
+) -> dict[str, int]:
+    """Full crawler workflow: harvest queries and download raw images."""
+    qcfg = cfg.get("queries") or {}
+    if not qcfg:
+        from .config import load_queries
+        qcfg = load_queries(cfg)
+
+    queries = build_queries(qcfg)
+    harvest_stats = run_icrawler_harvest(manifest, queries, data_dir, engine_name=engine, max_num=max_num, force=force, filter_classes=filter_classes)
+
+    originals_dir = data_dir / "originals"
+    download_stats = download_pending_sources(manifest, originals_dir, data_dir, cfg)
+
+    return {**harvest_stats, **download_stats}

google_drive_export/pipeline/dedup.py

@@ -0,0 +1,271 @@
+"""Deduplication engine (global across all classes and queries).
+
+Layer 1  exact       SHA-256 of the original bytes (already the image_id, so identical downloads
+                     collapse at download time) + SHA-256 of the decoded normalized pixels.
+Layer 2  near-dup    pHash AND dHash (64-bit each) within a Hamming-distance budget. Every image
+                     also stores the hashes of its horizontally FLIPPED version, and a pair counts
+                     as a duplicate if it matches in either orientation (mirror copies).
+Layer 3  semantic    CLIP-embedding cosine clustering. This layer never deletes anything; it only
+                     merges cluster ids so the splitter keeps "same board, different angle" together.
+
+Layers 1-2 remove images: within a duplicate group the keeper is chosen by
+    (already-processed before new) > (real-world before web) > higher resolution > larger file > id
+so re-running the pipeline never swaps out an image that was already kept or annotated.
+Duplicate groups are connected components (union-find), so chains A~B~C collapse into one group.
+"""
+from __future__ import annotations
+
+import logging
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Sequence
+
+import imagehash
+import numpy as np
+from PIL import Image, ImageOps
+from tqdm import tqdm
+
+from .manifest import Manifest
+
+log = logging.getLogger(__name__)
+
+# Statuses whose images are candidates for duplicate comparison (hashes present).
+_PROCESSED = ("deduped", "kept", "review")
+_CANDIDATES = ("normalized",) + _PROCESSED
+
+_POP8 = np.array([bin(i).count("1") for i in range(256)], dtype=np.uint8)
+
+
+# ------------------------------------------------------------------------------------ hashing
+def compute_hashes(path: str | Path) -> dict[str, str]:
+    """pHash/dHash (8x8 => 64 bit, hex) for an image and for its horizontal mirror."""
+    with Image.open(path) as im:
+        im.draft("RGB", (512, 512))  # cheap JPEG downscale on decode; same procedure for all images
+        im = ImageOps.exif_transpose(im).convert("RGB")
+        flipped = ImageOps.mirror(im)
+        return {
+            "phash": str(imagehash.phash(im, hash_size=8)),
+            "dhash": str(imagehash.dhash(im, hash_size=8)),
+            "phash_flip": str(imagehash.phash(flipped, hash_size=8)),
+            "dhash_flip": str(imagehash.dhash(flipped, hash_size=8)),
+        }
+
+
+def hex_to_u64(values: Sequence[str]) -> np.ndarray:
+    return np.array([int(v, 16) for v in values], dtype=np.uint64)
+
+
+def popcount64(x: np.ndarray) -> np.ndarray:
+    """Per-element population count of a uint64 array."""
+    if hasattr(np, "bitwise_count"):  # numpy >= 2.0
+        return np.bitwise_count(x)
+    x = np.ascontiguousarray(x)
+    return _POP8[x.view(np.uint8).reshape(*x.shape, 8)].sum(axis=-1)
+
+
+# --------------------------------------------------------------------------------- union-find
+class UnionFind:
+    def __init__(self, n: int):
+        self.parent = list(range(n))
+
+    def find(self, a: int) -> int:
+        while self.parent[a] != a:
+            self.parent[a] = self.parent[self.parent[a]]
+            a = self.parent[a]
+        return a
+
+    def union(self, a: int, b: int) -> None:
+        ra, rb = self.find(a), self.find(b)
+        if ra != rb:
+            self.parent[max(ra, rb)] = min(ra, rb)
+
+    def groups(self) -> list[list[int]]:
+        out: dict[int, list[int]] = defaultdict(list)
+        for i in range(len(self.parent)):
+            out[self.find(i)].append(i)
+        return [g for g in out.values() if len(g) > 1]
+
+
+def near_duplicate_pairs(ph: np.ndarray, dh: np.ndarray, phf: np.ndarray, dhf: np.ndarray,
+                         phash_max: int, dhash_max: int, block_cells: int = 4_000_000):
+    """Yield (i, j), i < j, whose pHash *and* dHash are within budget in the same orientation
+    (direct, or with j mirrored). Vectorized in row blocks to bound memory."""
+    n = len(ph)
+    if n < 2:
+        return
+    block = max(1, block_cells // n)
+    cols = np.arange(n)
+    for a in range(0, n, block):
+        b = min(n, a + block)
+        upper = cols[None, :] > np.arange(a, b)[:, None]
+        direct = (popcount64(ph[a:b, None] ^ ph[None, :]) <= phash_max) & \
+                 (popcount64(dh[a:b, None] ^ dh[None, :]) <= dhash_max)
+        mirrored = (popcount64(ph[a:b, None] ^ phf[None, :]) <= phash_max) & \
+                   (popcount64(dh[a:b, None] ^ dhf[None, :]) <= dhash_max)
+        ii, jj = np.nonzero((direct | mirrored) & upper)
+        for i, j in zip(ii + a, jj):
+            yield int(i), int(j)
+
+
+def find_duplicate_groups(rows: list[dict], phash_max: int, dhash_max: int) -> list[list[int]]:
+    """Group row indices by exact pixel hash + near-duplicate hashes (connected components)."""
+    n = len(rows)
+    uf = UnionFind(n)
+    by_pixels: dict[str, int] = {}
+    for i, r in enumerate(rows):
+        px = r.get("pixel_sha256")
+        if px:
+            if px in by_pixels:
+                uf.union(by_pixels[px], i)
+            else:
+                by_pixels[px] = i
+    if n >= 2:
+        ph = hex_to_u64([r["phash"] for r in rows])
+        dh = hex_to_u64([r["dhash"] for r in rows])
+        phf = hex_to_u64([r["phash_flip"] for r in rows])
+        dhf = hex_to_u64([r["dhash_flip"] for r in rows])
+        for i, j in near_duplicate_pairs(ph, dh, phf, dhf, phash_max, dhash_max):
+            uf.union(i, j)
+    return uf.groups()
+
+
+def keeper_rank(row: dict) -> tuple:
+    """Lower sorts first = preferred keeper."""
+    processed = 0 if row["status"] in _PROCESSED else 1
+    realworld = 0 if row.get("origin") == "realworld" else 1
+    pixels = (row.get("norm_width") or row.get("width") or 0) * (row.get("norm_height") or row.get("height") or 0)
+    return (processed, realworld, -pixels, -(row.get("filesize") or 0), row["image_id"])
+
+
+# ------------------------------------------------------------------------------------- stage
+def run(manifest: Manifest, cfg: dict, data_dir: Path) -> dict[str, int]:
+    """Hash new images, then discard exact/near duplicates across the whole candidate pool."""
+    dcfg = cfg["dedup"]
+    stats = {"hashed": 0, "exact_duplicate": 0, "near_duplicate": 0, "deduped": 0, "hash_failed": 0}
+
+    # 1. hashes for images that do not have them yet
+    fresh = [r for r in manifest.images(statuses=["normalized"]) if not r["phash"]]
+    if fresh:
+        def work(r: dict):
+            try:
+                return r, compute_hashes(data_dir / r["norm_path"]), None
+            except Exception as exc:  # noqa: BLE001
+                return r, None, exc
+
+        with ThreadPoolExecutor(max_workers=int(dcfg.get("hash_workers", 4))) as ex:
+            futures = [ex.submit(work, r) for r in fresh]
+            with manifest.transaction():
+                for fut in tqdm(as_completed(futures), total=len(futures), desc="hash", unit="img"):
+                    r, hashes, err = fut.result()
+                    if err is not None:
+                        log.warning("hashing failed for %s: %s", r["image_id"], err)
+                        manifest.discard(r["image_id"], "hash_failed")
+                        stats["hash_failed"] += 1
+                    else:
+                        manifest.update_image(r["image_id"], **hashes)
+                        stats["hashed"] += 1
+
+    # 2. group duplicates over the full candidate pool (new + previously processed)
+    rows = [r for r in manifest.images(statuses=_CANDIDATES) if r["phash"]]
+    groups = find_duplicate_groups(rows, int(dcfg["phash_max_dist"]), int(dcfg["dhash_max_dist"]))
+    log.info("dedup: %d candidates, %d duplicate group(s)", len(rows), len(groups))
+
+    discarded: set[str] = set()
+    cluster_of: dict[str, str] = {}  # cluster ids assigned during this run
+    with manifest.transaction():
+        for group in groups:
+            members = sorted((rows[i] for i in group), key=keeper_rank)
+            keeper, losers = members[0], members[1:]
+            # Reuse the keeper's existing cluster id: a previous semantic merge may have
+            # renamed it, and a rerun must never undo that.
+            cid = keeper["cluster_id"] or keeper["image_id"]
+            for member in members:
+                cluster_of[member["image_id"]] = cid
+                manifest.update_image(member["image_id"], cluster_id=cid)
+            for loser in losers:
+                exact = bool(loser["pixel_sha256"]) and loser["pixel_sha256"] == keeper["pixel_sha256"]
+                reason = "exact_duplicate" if exact else "near_duplicate"
+                if loser["status"] == "normalized":
+                    manifest.discard(loser["image_id"], reason, dup_of=keeper["image_id"])
+                    discarded.add(loser["image_id"])
+                    stats[reason] += 1
+                else:
+                    # An already-processed image is never removed retroactively (it may already
+                    # be annotated); it only joins the cluster so splits stay leak-free.
+                    log.warning("kept %s although it duplicates %s (already processed)",
+                                loser["image_id"], keeper["image_id"])
+        # Survivors advance; singletons get their own cluster id.
+        for r in rows:
+            if r["status"] != "normalized" or r["image_id"] in discarded:
+                continue
+            updates = {"status": "deduped"}
+            if not cluster_of.get(r["image_id"]) and not r["cluster_id"]:
+                updates["cluster_id"] = r["image_id"]
+            manifest.update_image(r["image_id"], **updates)
+            stats["deduped"] += 1
+    log.info("dedup: %s", stats)
+    return stats
+
+
+# ------------------------------------------------------------------------- semantic clustering
+def semantic_clusters(ids: list[str], emb: np.ndarray, threshold: float,
+                      existing: dict[str, str] | None = None, block_cells: int = 4_000_000) -> dict[str, str]:
+    """Merge images into clusters by embedding cosine >= threshold (and by existing cluster ids).
+
+    Returns image_id -> cluster id (the smallest image_id in the component, deterministic).
+    Assumes rows of ``emb`` are L2-normalized.
+    """
+    n = len(ids)
+    uf = UnionFind(n)
+    if existing:
+        first_seen: dict[str, int] = {}
+        for i, image_id in enumerate(ids):
+            cid = existing.get(image_id)
+            if cid:
+                if cid in first_seen:
+                    uf.union(first_seen[cid], i)
+                else:
+                    first_seen[cid] = i
+    if n >= 2:
+        block = max(1, block_cells // n)
+        cols = np.arange(n)
+        for a in range(0, n, block):
+            b = min(n, a + block)
+            sim = emb[a:b] @ emb.T
+            ii, jj = np.nonzero((sim >= threshold) & (cols[None, :] > np.arange(a, b)[:, None]))
+            for i, j in zip(ii + a, jj):
+                uf.union(int(i), int(j))
+    comp: dict[int, list[str]] = defaultdict(list)
+    for i, image_id in enumerate(ids):
+        comp[uf.find(i)].append(image_id)
+    return {image_id: min(members) for members in comp.values() for image_id in members}
+
+
+def run_semantic(manifest: Manifest, cfg: dict) -> dict[str, int]:
+    """Layer 3: merge cluster ids using stored CLIP embeddings (labels only, deletes nothing)."""
+    rows = manifest.images(statuses=["kept", "review"])
+    ids, emb = manifest.load_embeddings([r["image_id"] for r in rows])
+    if not ids:
+        log.warning("cluster: no embeddings found (run `filter` with CLIP first); skipping")
+        return {"clustered": 0, "merged_clusters": 0}
+    existing = {r["image_id"]: r["cluster_id"] or r["image_id"] for r in rows}
+    norms = np.linalg.norm(emb, axis=1, keepdims=True)
+    emb = emb / np.clip(norms, 1e-9, None)
+    new_ids = semantic_clusters(ids, emb, float(cfg["dedup"]["semantic_cosine"]), existing)
+
+    remap: dict[str, str] = {}
+    for image_id, new in new_ids.items():
+        old = existing[image_id]
+        if old != new:
+            remap[old] = new
+    with manifest.transaction():
+        # Update *all* rows (incl. discarded duplicates) that carry a merged cluster id.
+        for old, new in remap.items():
+            manifest.execute("UPDATE images SET cluster_id=? WHERE cluster_id=?", (new, old))
+        for image_id, new in new_ids.items():
+            if image_id not in remap and existing[image_id] != new:
+                manifest.update_image(image_id, cluster_id=new)
+    stats = {"clustered": len(ids), "merged_clusters": len(remap)}
+    log.info("cluster: %s", stats)
+    return stats

google_drive_export/pipeline/manifest.py

@@ -0,0 +1,404 @@
+"""SQLite manifest: the single source of truth for provenance and pipeline state.
+
+Tables
+------
+sources       one row per (normalized) URL; download state
+hits          every (url, engine, query) that surfaced a URL -> class hints and provenance
+harvest_runs  completed (engine, query) harvests so reruns skip them
+images        one row per unique image (sha256 of original bytes) with all pipeline state
+embeddings    optional CLIP embeddings (float16 blobs)
+
+Image status flow
+-----------------
+downloaded -> validated -> normalized -> deduped -> kept | review | discarded
+Every stage only touches rows in its own input status, so all stages are idempotent
+and a rerun after an interruption never repeats finished work.
+"""
+from __future__ import annotations
+
+import json
+import sqlite3
+import threading
+from contextlib import contextmanager
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterable, Iterator
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+
+import numpy as np
+
+STATUSES = ("downloaded", "validated", "normalized", "deduped", "kept", "review", "discarded")
+
+SCHEMA = """
+PRAGMA journal_mode=WAL;
+PRAGMA synchronous=NORMAL;
+
+CREATE TABLE IF NOT EXISTS sources (
+    url_norm      TEXT PRIMARY KEY,
+    url           TEXT NOT NULL,
+    status        TEXT NOT NULL DEFAULT 'pending',
+    attempts      INTEGER NOT NULL DEFAULT 0,
+    http_status   INTEGER,
+    error         TEXT,
+    image_id      TEXT,
+    harvested_at  TEXT,
+    downloaded_at TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_sources_status ON sources(status);
+CREATE INDEX IF NOT EXISTS idx_sources_image  ON sources(image_id);
+
+CREATE TABLE IF NOT EXISTS hits (
+    url_norm     TEXT NOT NULL,
+    engine       TEXT NOT NULL,
+    query        TEXT NOT NULL,
+    class_hint   TEXT,
+    lang         TEXT,
+    harvested_at TEXT,
+    PRIMARY KEY (url_norm, engine, query)
+);
+
+CREATE TABLE IF NOT EXISTS harvest_runs (
+    engine      TEXT NOT NULL,
+    query       TEXT NOT NULL,
+    class_hint  TEXT,
+    max_num     INTEGER,
+    urls_found  INTEGER,
+    urls_new    INTEGER,
+    finished_at TEXT,
+    PRIMARY KEY (engine, query)
+);
+
+CREATE TABLE IF NOT EXISTS images (
+    image_id         TEXT PRIMARY KEY,
+    sha256           TEXT NOT NULL,
+    origin           TEXT NOT NULL DEFAULT 'web',
+    source_ref       TEXT,
+    orig_path        TEXT,
+    orig_format      TEXT,
+    filesize         INTEGER,
+    width            INTEGER,
+    height           INTEGER,
+    aspect_ratio     REAL,
+    norm_path        TEXT,
+    norm_width       INTEGER,
+    norm_height      INTEGER,
+    pixel_sha256     TEXT,
+    phash            TEXT,
+    dhash            TEXT,
+    phash_flip       TEXT,
+    dhash_flip       TEXT,
+    flags            TEXT NOT NULL DEFAULT '[]',
+    status           TEXT NOT NULL,
+    discard_reason   TEXT,
+    dup_of           TEXT,
+    cluster_id       TEXT,
+    clip_score       REAL,
+    relevance_bucket TEXT,
+    board_type       TEXT,
+    condition        TEXT,
+    source_type      TEXT,
+    review_status    TEXT,
+    reviewer         TEXT,
+    reviewed_at      TEXT,
+    split            TEXT,
+    session_id       TEXT,
+    board_id         TEXT,
+    created_at       TEXT,
+    updated_at       TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_images_status  ON images(status);
+CREATE INDEX IF NOT EXISTS idx_images_cluster ON images(cluster_id);
+CREATE INDEX IF NOT EXISTS idx_images_dup_of  ON images(dup_of);
+
+CREATE TABLE IF NOT EXISTS embeddings (
+    image_id TEXT PRIMARY KEY,
+    dim      INTEGER NOT NULL,
+    vec      BLOB NOT NULL
+);
+"""
+
+IMAGE_COLUMNS = {
+    "image_id", "sha256", "origin", "source_ref", "orig_path", "orig_format", "filesize", "width",
+    "height", "aspect_ratio", "norm_path", "norm_width", "norm_height", "pixel_sha256", "phash",
+    "dhash", "phash_flip", "dhash_flip", "flags", "status", "discard_reason", "dup_of", "cluster_id",
+    "clip_score", "relevance_bucket", "board_type", "condition", "source_type", "review_status",
+    "reviewer", "reviewed_at", "split", "session_id", "board_id", "created_at", "updated_at",
+}
+
+_TRACKING_PARAMS = {"fbclid", "gclid", "msclkid", "yclid"}
+_DEFAULT_PORTS = {"http": 80, "https": 443}
+
+
+def utcnow() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+def normalize_url(url: str) -> str:
+    """Canonical form used as the dedup key for URLs (case, default ports, fragment, tracking)."""
+    parts = urlsplit(url.strip())
+    scheme = parts.scheme.lower()
+    host = (parts.hostname or "").lower()
+    try:
+        port = parts.port
+    except ValueError:
+        port = None
+    netloc = host
+    if port and port != _DEFAULT_PORTS.get(scheme):
+        netloc = f"{host}:{port}"
+    query = sorted(
+        (k, v) for k, v in parse_qsl(parts.query, keep_blank_values=True)
+        if not k.lower().startswith("utm_") and k.lower() not in _TRACKING_PARAMS
+    )
+    return urlunsplit((scheme, netloc, parts.path or "/", urlencode(query), ""))
+
+
+def _check_columns(fields: Iterable[str]) -> None:
+    bad = set(fields) - IMAGE_COLUMNS
+    if bad:
+        raise KeyError(f"unknown image column(s): {sorted(bad)}")
+
+
+class Manifest:
+    """Thread-safe SQLite wrapper (one connection, serialized by an RLock)."""
+
+    def __init__(self, db_path: str | Path):
+        self.db_path = Path(db_path)
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._conn = sqlite3.connect(str(self.db_path), check_same_thread=False,
+                                     isolation_level=None, timeout=60)
+        self._conn.row_factory = sqlite3.Row
+        self._lock = threading.RLock()
+        self._tx_depth = 0
+        with self._lock:
+            self._conn.executescript(SCHEMA)
+
+    # -- infrastructure -----------------------------------------------------------------
+    def close(self) -> None:
+        with self._lock:
+            self._conn.close()
+
+    def __enter__(self) -> "Manifest":
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.close()
+
+    @contextmanager
+    def transaction(self) -> Iterator[None]:
+        """Group many writes into one commit (re-entrant)."""
+        with self._lock:
+            outer = self._tx_depth == 0
+            if outer:
+                self._conn.execute("BEGIN")
+            self._tx_depth += 1
+            try:
+                yield
+            except BaseException:
+                self._tx_depth -= 1
+                if outer:
+                    self._conn.execute("ROLLBACK")
+                raise
+            else:
+                self._tx_depth -= 1
+                if outer:
+                    self._conn.execute("COMMIT")
+
+    def execute(self, sql: str, params: Iterable[Any] = ()) -> sqlite3.Cursor:
+        with self._lock:
+            return self._conn.execute(sql, tuple(params))
+
+    def query(self, sql: str, params: Iterable[Any] = ()) -> list[sqlite3.Row]:
+        with self._lock:
+            return self._conn.execute(sql, tuple(params)).fetchall()
+
+    # -- sources / hits -------------------------------------------------------------------
+    def add_hit(self, url: str, engine: str, query: str, class_hint: str | None = None,
+                lang: str | None = None) -> bool:
+        """Record a harvested URL. Returns True if the URL was new."""
+        url_norm = normalize_url(url)
+        now = utcnow()
+        with self._lock:
+            cur = self._conn.execute(
+                "INSERT OR IGNORE INTO sources(url_norm, url, status, harvested_at) "
+                "VALUES (?, ?, 'pending', ?)", (url_norm, url, now))
+            is_new = cur.rowcount == 1
+            self._conn.execute(
+                "INSERT OR IGNORE INTO hits(url_norm, engine, query, class_hint, lang, harvested_at) "
+                "VALUES (?, ?, ?, ?, ?, ?)", (url_norm, engine, query, class_hint, lang, now))
+        return is_new
+
+    def pending_sources(self, limit: int | None = None, include_transient: bool = False) -> list[dict]:
+        statuses = ("pending", "failed_transient") if include_transient else ("pending",)
+        sql = f"SELECT * FROM sources WHERE status IN ({','.join('?' * len(statuses))}) ORDER BY harvested_at, url_norm"
+        params: list[Any] = list(statuses)
+        if limit:
+            sql += " LIMIT ?"
+            params.append(limit)
+        return [dict(r) for r in self.query(sql, params)]
+
+    def mark_source(self, url_norm: str, status: str, http_status: int | None = None,
+                    error: str | None = None, image_id: str | None = None, attempts: int = 0) -> None:
+        self.execute(
+            "UPDATE sources SET status=?, http_status=?, error=?, image_id=?, "
+            "attempts=attempts+?, downloaded_at=? WHERE url_norm=?",
+            (status, http_status, error, image_id, attempts, utcnow(), url_norm))
+
+    # -- harvest runs ---------------------------------------------------------------------
+    def run_done(self, engine: str, query: str) -> bool:
+        return bool(self.query("SELECT 1 FROM harvest_runs WHERE engine=? AND query=?", (engine, query)))
+
+    def record_run(self, engine: str, query: str, class_hint: str | None, max_num: int,
+                   found: int, new: int) -> None:
+        self.execute(
+            "INSERT OR REPLACE INTO harvest_runs VALUES (?, ?, ?, ?, ?, ?, ?)",
+            (engine, query, class_hint, max_num, found, new, utcnow()))
+
+    # -- images ----------------------------------------------------------------------------
+    def add_image(self, **fields: Any) -> bool:
+        """Insert an image row if its image_id is new. Returns True if inserted."""
+        _check_columns(fields)
+        fields.setdefault("origin", "web")
+        now = utcnow()
+        fields.setdefault("created_at", now)
+        fields.setdefault("updated_at", now)
+        if isinstance(fields.get("flags"), (list, tuple, set)):
+            fields["flags"] = json.dumps(sorted(fields["flags"]))
+        cols = list(fields)
+        cur = self.execute(
+            f"INSERT OR IGNORE INTO images({','.join(cols)}) VALUES ({','.join('?' * len(cols))})",
+            [fields[c] for c in cols])
+        return cur.rowcount == 1
+
+    @staticmethod
+    def _row(row: sqlite3.Row | None) -> dict | None:
+        if row is None:
+            return None
+        d = dict(row)
+        d["flags"] = json.loads(d.get("flags") or "[]")
+        return d
+
+    def get_image(self, image_id: str) -> dict | None:
+        rows = self.query("SELECT * FROM images WHERE image_id=?", (image_id,))
+        return self._row(rows[0]) if rows else None
+
+    def images(self, statuses: Iterable[str] | None = None, origin: str | None = None,
+               where: str | None = None, params: Iterable[Any] = ()) -> list[dict]:
+        clauses, args = [], []
+        if statuses:
+            statuses = tuple(statuses)
+            clauses.append(f"status IN ({','.join('?' * len(statuses))})")
+            args += list(statuses)
+        if origin:
+            clauses.append("origin=?")
+            args.append(origin)
+        if where:
+            clauses.append(f"({where})")
+            args += list(params)
+        sql = "SELECT * FROM images" + (" WHERE " + " AND ".join(clauses) if clauses else "")
+        sql += " ORDER BY image_id"
+        return [self._row(r) for r in self.query(sql, args)]
+
+    def update_image(self, image_id: str, **fields: Any) -> None:
+        _check_columns(fields)
+        if not fields:
+            return
+        if isinstance(fields.get("flags"), (list, tuple, set)):
+            fields["flags"] = json.dumps(sorted(fields["flags"]))
+        fields["updated_at"] = utcnow()
+        sets = ", ".join(f"{c}=?" for c in fields)
+        self.execute(f"UPDATE images SET {sets} WHERE image_id=?", [*fields.values(), image_id])
+
+    def add_flags(self, image_id: str, *new_flags: str) -> None:
+        img = self.get_image(image_id)
+        if img is None:
+            return
+        merged = sorted(set(img["flags"]) | set(new_flags))
+        self.update_image(image_id, flags=merged)
+
+    def discard(self, image_id: str, reason: str, dup_of: str | None = None) -> None:
+        self.update_image(image_id, status="discarded", discard_reason=reason, dup_of=dup_of)
+
+    def count_by(self, column: str, where: str = "1=1", params: Iterable[Any] = ()) -> dict[str, int]:
+        _check_columns([column])
+        rows = self.query(
+            f"SELECT {column} AS k, COUNT(*) AS n FROM images WHERE {where} GROUP BY {column}", params)
+        return {(r["k"] if r["k"] is not None else "none"): r["n"] for r in rows}
+
+    # -- provenance ----------------------------------------------------------------------
+    def class_hints_by_image(self) -> dict[str, set[str]]:
+        """image_id -> class hints, folding duplicates (dup_of) into their keeper."""
+        rows = self.query(
+            "SELECT s.image_id AS image_id, h.class_hint AS class_hint "
+            "FROM sources s JOIN hits h ON h.url_norm = s.url_norm "
+            "WHERE s.image_id IS NOT NULL AND h.class_hint IS NOT NULL")
+        direct: dict[str, set[str]] = {}
+        for r in rows:
+            direct.setdefault(r["image_id"], set()).add(r["class_hint"])
+        result = {k: set(v) for k, v in direct.items()}
+        for r in self.query("SELECT image_id, dup_of FROM images WHERE dup_of IS NOT NULL"):
+            if r["image_id"] in direct:
+                result.setdefault(r["dup_of"], set()).update(direct[r["image_id"]])
+        return result
+
+    def provenance(self, image_id: str) -> dict[str, list[str]]:
+        """Source URLs, queries, engines and class hints for an image incl. its duplicates."""
+        rows = self.query(
+            "SELECT s.url AS url, h.engine AS engine, h.query AS query, h.class_hint AS class_hint "
+            "FROM sources s LEFT JOIN hits h ON h.url_norm = s.url_norm "
+            "WHERE s.image_id IN (SELECT ? UNION SELECT image_id FROM images WHERE dup_of = ?)",
+            (image_id, image_id))
+        out: dict[str, set[str]] = {"source_urls": set(), "engines": set(), "queries": set(),
+                                    "class_hints": set()}
+        for r in rows:
+            out["source_urls"].add(r["url"])
+            if r["engine"]:
+                out["engines"].add(r["engine"])
+            if r["query"]:
+                out["queries"].add(r["query"])
+            if r["class_hint"]:
+                out["class_hints"].add(r["class_hint"])
+        return {k: sorted(v) for k, v in out.items()}
+
+    def valid_counts_by_class(self, valid_statuses: Iterable[str] = ("deduped", "kept", "validated", "normalized")) -> dict[str, int]:
+        """Return a mapping of class_hint -> count of valid (non-discarded) images."""
+        statuses = tuple(valid_statuses)
+        sql = f"""
+            SELECT h.class_hint, COUNT(DISTINCT i.image_id)
+            FROM images i
+            JOIN sources s ON i.source_ref = s.url_norm OR i.image_id = s.image_id
+            JOIN hits h ON s.url_norm = h.url_norm
+            WHERE i.status IN ({','.join('?' * len(statuses))})
+            GROUP BY h.class_hint
+        """
+        rows = self.query(sql, statuses)
+        return {r[0]: r[1] for r in rows if r[0]}
+
+    def export_jsonl(self, path: str | Path) -> int:
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        n = 0
+        with open(path, "w", encoding="utf-8") as fh:
+            for img in self.images():
+                img.update(self.provenance(img["image_id"]))
+                fh.write(json.dumps(img, ensure_ascii=False) + "\n")
+                n += 1
+        return n
+
+    # -- embeddings ----------------------------------------------------------------------
+    def save_embeddings(self, vectors: dict[str, np.ndarray]) -> None:
+        with self.transaction():
+            for image_id, vec in vectors.items():
+                arr = np.asarray(vec, dtype=np.float16)
+                self.execute("INSERT OR REPLACE INTO embeddings VALUES (?, ?, ?)",
+                             (image_id, int(arr.shape[0]), arr.tobytes()))
+
+    def load_embeddings(self, image_ids: Iterable[str] | None = None) -> tuple[list[str], np.ndarray]:
+        rows = self.query("SELECT image_id, dim, vec FROM embeddings ORDER BY image_id")
+        if image_ids is not None:
+            wanted = set(image_ids)
+            rows = [r for r in rows if r["image_id"] in wanted]
+        if not rows:
+            return [], np.zeros((0, 0), dtype=np.float32)
+        ids = [r["image_id"] for r in rows]
+        mat = np.stack([np.frombuffer(r["vec"], dtype=np.float16).astype(np.float32) for r in rows])
+        return ids, mat

google_drive_export/pipeline/processor.py

@@ -0,0 +1,145 @@
+"""Normalization engine: turn any validated original into a standard RGB JPEG.
+
+Order matters and follows the plan:
+
+  1. EXIF transpose first (phone photos would otherwise end up rotated).
+  2. Colour handling to RGB:
+       - RGBA / LA / PA / palette-with-transparency -> composited on WHITE
+         (a naive convert("RGB") turns transparent pixels black)
+       - CMYK -> sRGB through the embedded ICC profile when there is one
+       - RGB with a non-sRGB ICC profile -> converted to sRGB when possible
+       - grayscale / 1-bit / 16-bit -> RGB
+  3. Downscale (never upscale) if the long side exceeds ``max_long_side`` (LANCZOS).
+  4. Encode as JPEG q95, 4:4:4 chroma (subsampling=0), optimized, metadata stripped.
+
+Originals are never modified; this only ever writes a derived copy.
+"""
+from __future__ import annotations
+
+import hashlib
+import io
+import logging
+import os
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+from PIL import Image, ImageCms, ImageOps
+from tqdm import tqdm
+
+from .manifest import Manifest
+from .validator import register_heif
+
+log = logging.getLogger(__name__)
+register_heif()
+
+Image.MAX_IMAGE_PIXELS = None  # size is already policed by the validator
+
+
+@dataclass
+class NormalizeResult:
+    width: int
+    height: int
+    pixel_sha256: str
+
+
+def _icc_to_srgb(img: Image.Image) -> Image.Image:
+    """Convert to sRGB via the embedded ICC profile; fall back to a plain convert."""
+    icc = img.info.get("icc_profile")
+    if not icc:
+        return img.convert("RGB")
+    try:
+        src = ImageCms.ImageCmsProfile(io.BytesIO(icc))
+        if img.mode == "RGB" and "srgb" in ImageCms.getProfileDescription(src).lower():
+            return img
+        dst = ImageCms.createProfile("sRGB")
+        return ImageCms.profileToProfile(img, src, dst, outputMode="RGB")
+    except Exception:
+        return img.convert("RGB")
+
+
+def _wide_mode_to_rgb(img: Image.Image) -> Image.Image:
+    """16-bit / int / float single-channel images -> 8-bit RGB with min/max scaling."""
+    arr = np.asarray(img, dtype=np.float64)
+    lo, hi = float(arr.min()), float(arr.max())
+    scaled = np.zeros_like(arr) if hi <= lo else (arr - lo) / (hi - lo) * 255.0
+    return Image.fromarray(scaled.astype(np.uint8), mode="L").convert("RGB")
+
+
+def to_rgb(img: Image.Image) -> Image.Image:
+    mode = img.mode
+    if mode in ("RGBA", "LA", "PA", "RGBa", "La") or (mode == "P" and "transparency" in img.info):
+        rgba = img.convert("RGBA")
+        background = Image.new("RGBA", rgba.size, (255, 255, 255, 255))
+        return Image.alpha_composite(background, rgba).convert("RGB")
+    if mode == "CMYK":
+        return _icc_to_srgb(img)
+    if mode in ("I", "I;16", "I;16L", "I;16B", "F"):
+        return _wide_mode_to_rgb(img)
+    if mode == "RGB":
+        return _icc_to_srgb(img) if img.info.get("icc_profile") else img
+    return img.convert("RGB")  # L, 1, P (opaque), YCbCr, LAB, HSV, ...
+
+
+def normalize_image(src: str | Path, dst: str | Path, pcfg: dict) -> NormalizeResult:
+    src, dst = Path(src), Path(dst)
+    with Image.open(src) as opened:
+        opened.seek(0)  # first frame of animated files
+        img = ImageOps.exif_transpose(opened)
+        img.load()
+        img = to_rgb(img)
+
+    max_long = int(pcfg.get("max_long_side", 2560))
+    long_side = max(img.size)
+    if max_long and long_side > max_long:
+        scale = max_long / long_side
+        new_size = (max(1, round(img.width * scale)), max(1, round(img.height * scale)))
+        img = img.resize(new_size, Image.Resampling.LANCZOS)
+
+    digest = hashlib.sha256(f"{img.width}x{img.height}".encode() + img.tobytes()).hexdigest()
+
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    tmp = dst.with_name(dst.name + f".{os.getpid()}.tmp")
+    try:
+        img.save(tmp, format="JPEG", quality=int(pcfg.get("jpeg_quality", 95)),
+                 subsampling=int(pcfg.get("jpeg_subsampling", 0)), optimize=True)
+        os.replace(tmp, dst)  # atomic: a crash never leaves a half-written JPEG
+    finally:
+        if tmp.exists():
+            tmp.unlink()
+    return NormalizeResult(img.width, img.height, digest)
+
+
+def run(manifest: Manifest, cfg: dict, data_dir: Path, images_dir: Path) -> dict[str, int]:
+    """Normalize every image in status 'validated'."""
+    pcfg = cfg["process"]
+    todo = manifest.images(statuses=["validated"])
+    stats = {"normalized": 0, "normalize_failed": 0}
+    if not todo:
+        log.info("process: nothing to do")
+        return stats
+
+    def work(img: dict):
+        dst = images_dir / f"{img['image_id']}.jpg"
+        try:
+            return img, normalize_image(data_dir / img["orig_path"], dst, pcfg), dst, None
+        except Exception as exc:  # noqa: BLE001 - any decode/encode failure discards the image
+            return img, None, dst, exc
+
+    with ThreadPoolExecutor(max_workers=int(pcfg.get("workers", 4))) as ex:
+        futures = [ex.submit(work, img) for img in todo]
+        with manifest.transaction():
+            for fut in tqdm(as_completed(futures), total=len(futures), desc="process", unit="img"):
+                img, res, dst, err = fut.result()
+                if err is None and res is not None:
+                    manifest.update_image(
+                        img["image_id"], status="normalized", norm_path=str(dst.relative_to(data_dir)),
+                        norm_width=res.width, norm_height=res.height, pixel_sha256=res.pixel_sha256)
+                    stats["normalized"] += 1
+                else:
+                    log.warning("normalize failed for %s: %s", img["image_id"], err)
+                    manifest.discard(img["image_id"], "normalize_failed")
+                    stats["normalize_failed"] += 1
+    log.info("process: %s", stats)
+    return stats

google_drive_export/pipeline/queries.py

@@ -0,0 +1,77 @@
+"""Query registry: expand seed terms along diversity axes (deterministically)."""
+from __future__ import annotations
+
+import random
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class QuerySpec:
+    class_hint: str
+    query: str
+    lang: str = "en"
+    kind: str = "seed"  # seed | expanded | lang
+
+
+def _overlap(phrase: str, words: set[str]) -> float:
+    toks = phrase.lower().split()
+    return sum(t in words for t in toks) / len(toks) if toks else 1.0
+
+
+def build_queries(
+    qcfg: dict,
+    classes: list[str] | None = None,
+    langs: list[str] | None = None,
+) -> list[QuerySpec]:
+    """Build the full query list.
+
+    For every seed term: the seed itself plus up to ``max_variants_per_seed`` variants that
+    append one or two randomly chosen axis values (board type, condition, view/setting).
+    A class may override any axis (e.g. ``desoldered_zone`` never pairs with "intact").
+    Multilingual terms are hand-written per class and appended as-is.
+
+    Output order and content are fully determined by ``expansion.seed``.
+    """
+    exp = qcfg.get("expansion", {}) or {}
+    rng = random.Random(exp.get("seed", 7))
+    per_seed = int(exp.get("max_variants_per_seed", 8))
+    global_axes = qcfg.get("axes", {}) or {}
+
+    out: list[QuerySpec] = []
+    seen: set[tuple[str, str]] = set()
+
+    def add(spec: QuerySpec) -> None:
+        key = (spec.class_hint, spec.query.strip().lower())
+        if key not in seen and spec.query.strip():
+            seen.add(key)
+            out.append(spec)
+
+    for cls, body in (qcfg.get("classes") or {}).items():
+        if classes and cls not in classes:
+            continue
+        body = body or {}
+        axes = {**global_axes, **(body.get("axes") or {})}
+        axis_names = sorted(a for a, vals in axes.items() if vals)
+
+        for seed in body.get("seeds", []) or []:
+            add(QuerySpec(cls, seed, "en", "seed"))
+            seed_words = set(seed.lower().split())
+            variants: set[str] = set()
+            attempts = 0
+            while axis_names and len(variants) < per_seed and attempts < per_seed * 10:
+                attempts += 1
+                chosen = rng.sample(axis_names, min(rng.choice([1, 2]), len(axis_names)))
+                parts = [rng.choice(axes[a]) for a in sorted(chosen)]
+                # Skip axis values the seed already (mostly) says, e.g. "close up" + "close up macro".
+                parts = [p for p in parts if _overlap(p, seed_words) < 0.5]
+                if parts:
+                    variants.add(f"{seed} {' '.join(parts)}")
+            for v in sorted(variants):
+                add(QuerySpec(cls, v, "en", "expanded"))
+
+        for lang, terms in (body.get("multilingual") or {}).items():
+            if langs and lang not in langs:
+                continue
+            for term in terms or []:
+                add(QuerySpec(cls, term, lang, "lang"))
+    return out

google_drive_export/pipeline/requirements.txt

@@ -0,0 +1,7 @@
+icrawler>=0.6.6
+Pillow>=9.0.0
+imagehash>=4.3.1
+pyyaml>=6.0
+tqdm>=4.64.0
+numpy>=1.22.0
+pytest>=7.0.0

google_drive_export/pipeline/scraper.py

@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+"""Unified CLI entry point for E-Waste dataset harvest and pipeline processing.
+
+Subcommands:
+  harvest   Query search engines and download raw images
+  validate  Verify image integrity, dimensions, format, and aspect ratios
+  process   Normalize images (EXIF transpose, alpha composite, JPEG q95)
+  dedup     Multi-layer deduplication (exact SHA-256 + flip-aware pHash/dHash)
+  report    Print pipeline statistics and summary report
+  export    Export SQLite manifest metadata to JSONL
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import sys
+from pathlib import Path
+
+# Auto-reexec inside project .venv if not already active
+_script_dir = Path(__file__).resolve().parent
+_venv_python = _script_dir / ".venv" / "bin" / "python3"
+if _venv_python.exists() and sys.executable != str(_venv_python):
+    os.execv(str(_venv_python), [str(_venv_python)] + sys.argv)
+
+from pipeline.config import get_paths, load_config, setup_logging, load_queries
+from pipeline.manifest import Manifest
+from pipeline import validator, processor, dedup, crawler, splitter
+
+log = logging.getLogger("scraper")
+
+
+def cmd_harvest(args: argparse.Namespace, cfg: dict, manifest: Manifest, paths: get_paths) -> int:
+    force = getattr(args, "force", False)
+    log.info("Starting harvest (engine=%s, max_num=%d, force=%s)...", args.engine, args.max_num, force)
+    stats = crawler.run(manifest, cfg, paths.data, engine=args.engine, max_num=args.max_num, force=force)
+    print(json.dumps(stats, indent=2))
+    return 0
+
+
+def cmd_validate(args: argparse.Namespace, cfg: dict, manifest: Manifest, paths: get_paths) -> int:
+    force = getattr(args, "force", False)
+    log.info("Starting validation (force=%s)...", force)
+    stats = validator.run(manifest, cfg, paths.data, force=force)
+    print(json.dumps(stats, indent=2))
+    return 0
+
+
+def cmd_process(args: argparse.Namespace, cfg: dict, manifest: Manifest, paths: get_paths) -> int:
+    log.info("Starting normalization processing...")
+    stats = processor.run(manifest, cfg, paths.data, paths.images)
+    print(json.dumps(stats, indent=2))
+    return 0
+
+
+def cmd_dedup(args: argparse.Namespace, cfg: dict, manifest: Manifest, paths: get_paths) -> int:
+    log.info("Starting deduplication...")
+    stats = dedup.run(manifest, cfg, paths.data)
+    if args.semantic:
+        log.info("Running semantic CLIP clustering...")
+        sem_stats = dedup.run_semantic(manifest, cfg)
+        stats.update(sem_stats)
+    print(json.dumps(stats, indent=2))
+    return 0
+
+
+def cmd_report(args: argparse.Namespace, cfg: dict, manifest: Manifest, paths: get_paths) -> int:
+    by_status = manifest.count_by("status")
+    by_discard = manifest.count_by("discard_reason", where="status='discarded'")
+    class_hints = manifest.class_hints_by_image()
+
+    hint_counts: dict[str, int] = {}
+    for hints in class_hints.values():
+        for h in hints:
+            hint_counts[h] = hint_counts.get(h, 0) + 1
+
+    report_data = {
+        "status_distribution": by_status,
+        "discard_reasons": by_discard,
+        "class_hint_counts": hint_counts,
+        "total_images": sum(by_status.values()),
+    }
+
+    if args.json:
+        print(json.dumps(report_data, indent=2))
+    else:
+        print("\n=== E-Waste Dataset Pipeline Summary Report ===")
+        print(f"Total Images Tracked: {report_data['total_images']}")
+        print("\nStatus Distribution:")
+        for k, v in by_status.items():
+            print(f"  {k:15s}: {v}")
+        if by_discard:
+            print("\nDiscard Reasons:")
+            for k, v in by_discard.items():
+                print(f"  {k:20s}: {v}")
+        if hint_counts:
+            print("\nClass Hints (via Search Provenance):")
+            for k, v in sorted(hint_counts.items()):
+                print(f"  {k:20s}: {v}")
+        print("================================================\n")
+
+    # Save summary report to file
+    paths.reports.mkdir(parents=True, exist_ok=True)
+    report_file = paths.reports / "summary.json"
+    report_file.write_text(json.dumps(report_data, indent=2), encoding="utf-8")
+    log.info("Wrote summary report to %s", report_file)
+    return 0
+
+
+def cmd_export(args: argparse.Namespace, cfg: dict, manifest: Manifest, paths: get_paths) -> int:
+    out_path = Path(args.output) if args.output else paths.manifest_jsonl
+    log.info("Exporting manifest to %s...", out_path)
+    count = manifest.export_jsonl(out_path)
+    log.info("Exported %d image metadata entries to %s", count, out_path)
+    return 0
+
+
+def cmd_split(args: argparse.Namespace, cfg: dict, manifest: Manifest, paths: get_paths) -> int:
+    log.info("Starting cluster-aware dataset splitting (train=%.2f, val=%.2f, test=%.2f)...", args.train_ratio, args.val_ratio, args.test_ratio)
+    stats = splitter.run(
+        manifest, cfg, paths.data, paths.splits,
+        train_ratio=args.train_ratio, val_ratio=args.val_ratio, test_ratio=args.test_ratio
+    )
+    print(json.dumps(stats, indent=2))
+    return 0
+
+
+def cmd_all(args: argparse.Namespace, cfg: dict, manifest: Manifest, paths: get_paths) -> int:
+    log.info("Running complete pipeline: harvest -> validate -> process -> dedup -> report")
+    cmd_harvest(args, cfg, manifest, paths)
+    cmd_validate(args, cfg, manifest, paths)
+    cmd_process(args, cfg, manifest, paths)
+    cmd_dedup(args, cfg, manifest, paths)
+    return cmd_report(args, cfg, manifest, paths)
+
+
+def cmd_auto(args: argparse.Namespace, cfg: dict, manifest: Manifest, paths: get_paths) -> int:
+    target = getattr(args, "target_per_class", 1500)
+    engines = ["bing", "flickr", "baidu"]
+    all_classes = set(cfg.get("queries", {}).get("classes", {}).keys()) or {
+        "cpu_socket", "gold_finger", "ic_chip", "tantalum_capacitor", "desoldered_zone"
+    }
+    log.info("Starting automated target loop: goal=%d valid images for ALL classes (%s)", target, sorted(all_classes))
+
+    iteration = 0
+    while True:
+        iteration += 1
+        valid_counts = manifest.valid_counts_by_class()
+        log.info("Iteration %d - Current valid counts per class: %s", iteration, valid_counts)
+
+        unsatisfied = {c: target - valid_counts.get(c, 0) for c in all_classes if valid_counts.get(c, 0) < target}
+        if not unsatisfied:
+            log.info("SUCCESS: All classes reached target of %d valid images!", target)
+            break
+
+        log.info("Iteration %d - Deficit classes remaining to satisfy: %s", iteration, unsatisfied)
+        
+        eng = engines[(iteration - 1) % len(engines)]
+        log.info("Harvesting batch for deficit classes using engine=%s (max_num=%d)...", eng, args.max_num)
+        
+        crawler.run(manifest, cfg, paths.data, engine=eng, max_num=args.max_num, force=True, filter_classes=set(unsatisfied.keys()))
+        validator.run(manifest, cfg, paths.data)
+        processor.run(manifest, cfg, paths.data, paths.images)
+        dedup.run(manifest, cfg, paths.data)
+
+        v_now = manifest.valid_counts_by_class()
+        still_needed = {c: target - v_now.get(c, 0) for c in all_classes if v_now.get(c, 0) < target}
+        if not still_needed:
+            log.info("SUCCESS: All classes reached target of %d valid images!", target)
+            break
+
+    return cmd_report(args, cfg, manifest, paths)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="E-Waste PCB Dataset Harvester & Preprocessing Pipeline")
+    parser.add_argument("-v", "--verbose", action="store_true", help="Enable verbose DEBUG logging")
+    parser.add_argument("-c", "--config", type=str, help="Path to config.yaml file")
+
+    subparsers = parser.add_subparsers(dest="command", required=True, help="Pipeline subcommand")
+
+    # auto
+    p_auto = subparsers.add_parser("auto", help="Automated loop: harvest/validate/process/dedup until ALL classes reach target count")
+    p_auto.add_argument("--target-per-class", type=int, default=1500, help="Target valid images per class (default: 1500)")
+    p_auto.add_argument("--max-num", type=int, default=50, help="Max images per query per batch")
+    p_auto.add_argument("--semantic", action="store_true", help="Also run semantic CLIP clustering in dedup stage")
+    p_auto.add_argument("--json", action="store_true", help="Output summary report as raw JSON")
+
+    # all
+    p_all = subparsers.add_parser("all", help="Run full pipeline: harvest -> validate -> process -> dedup -> report")
+    p_all.add_argument("--engine", default="bing", choices=["bing", "flickr", "baidu"], help="Crawler engine")
+    p_all.add_argument("--max-num", type=int, default=50, help="Max images per query")
+    p_all.add_argument("-f", "--force", action="store_true", help="Force re-harvest queries even if already recorded as done")
+    p_all.add_argument("--semantic", action="store_true", help="Also run semantic CLIP clustering in dedup stage")
+    p_all.add_argument("--json", action="store_true", help="Output summary report as raw JSON")
+
+    # harvest
+    p_harvest = subparsers.add_parser("harvest", help="Harvest images from web search engines")
+    p_harvest.add_argument("--engine", default="bing", choices=["bing", "flickr", "baidu"], help="Crawler engine")
+    p_harvest.add_argument("--max-num", type=int, default=50, help="Max images per query")
+    p_harvest.add_argument("-f", "--force", action="store_true", help="Force re-harvest queries even if already recorded as done")
+
+    # validate
+    p_validate = subparsers.add_parser("validate", help="Validate raw images for integrity and dimensions")
+    p_validate.add_argument("-f", "--force", action="store_true", help="Re-check previously validated images for AI metadata")
+
+    # process
+    subparsers.add_parser("process", help="Normalize images (EXIF, alpha composite, JPEG q95)")
+
+    # dedup
+    p_dedup = subparsers.add_parser("dedup", help="Deduplicate images (exact + pHash/dHash)")
+    p_dedup.add_argument("--semantic", action="store_true", help="Also run semantic CLIP clustering")
+
+    # report
+    p_report = subparsers.add_parser("report", help="Display dataset statistics summary")
+    p_report.add_argument("--json", action="store_true", help="Output summary as raw JSON")
+
+    # export
+    p_export = subparsers.add_parser("export", help="Export manifest metadata to JSONL file")
+    p_export.add_argument("-o", "--output", type=str, help="Output path for jsonl export")
+
+    # split
+    p_split = subparsers.add_parser("split", help="Partition dataset into leak-free train/val/test splits")
+    p_split.add_argument("--train-ratio", type=float, default=0.70, help="Train split ratio (default: 0.70)")
+    p_split.add_argument("--val-ratio", type=float, default=0.15, help="Val split ratio (default: 0.15)")
+    p_split.add_argument("--test-ratio", type=float, default=0.15, help="Test split ratio (default: 0.15)")
+
+    args = parser.parse_args()
+    setup_logging(verbose=args.verbose)
+
+    cfg = load_config(args.config)
+    paths = get_paths(cfg)
+    paths.ensure()
+
+    with Manifest(paths.manifest_db) as manifest:
+        if args.command == "auto":
+            return cmd_auto(args, cfg, manifest, paths)
+        elif args.command == "all":
+            return cmd_all(args, cfg, manifest, paths)
+        elif args.command == "harvest":
+            return cmd_harvest(args, cfg, manifest, paths)
+        elif args.command == "validate":
+            return cmd_validate(args, cfg, manifest, paths)
+        elif args.command == "process":
+            return cmd_process(args, cfg, manifest, paths)
+        elif args.command == "dedup":
+            return cmd_dedup(args, cfg, manifest, paths)
+        elif args.command == "split":
+            return cmd_split(args, cfg, manifest, paths)
+        elif args.command == "report":
+            return cmd_report(args, cfg, manifest, paths)
+        elif args.command == "export":
+            return cmd_export(args, cfg, manifest, paths)
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

google_drive_export/pipeline/splitter.py

@@ -0,0 +1,120 @@
+"""Dataset Splitter Engine.
+
+Stratified, cluster-aware train / val / test dataset partitioning:
+- Prevents data leakage by ensuring all images in the same visual `cluster_id`
+  are assigned to the SAME split (train, val, or test).
+- Maintains balanced class distributions across splits according to target ratios (e.g. 70 / 15 / 15).
+- Exports organized image directory symlinks/copies under `splits/` for YOLOv8 training.
+"""
+from __future__ import annotations
+
+import logging
+import random
+import shutil
+from collections import defaultdict
+from pathlib import Path
+from typing import Sequence
+
+from .manifest import Manifest
+
+log = logging.getLogger(__name__)
+
+
+def create_cluster_splits(
+    manifest: Manifest,
+    train_ratio: float = 0.70,
+    val_ratio: float = 0.15,
+    test_ratio: float = 0.15,
+    seed: int = 42,
+) -> dict[str, list[dict]]:
+    """Partition valid images into cluster-isolated train/val/test splits."""
+    random.seed(seed)
+    
+    # Load all valid/kept images
+    rows = manifest.images(statuses=["deduped", "kept", "validated", "normalized"])
+    if not rows:
+        log.warning("splitter: no valid images found to split")
+        return {"train": [], "val": [], "test": []}
+
+    # Group image records by cluster_id
+    clusters: dict[str, list[dict]] = defaultdict(list)
+    for r in rows:
+        cid = r["cluster_id"] or r["image_id"]
+        clusters[cid].append(r)
+
+    cluster_items = list(clusters.items())
+    random.shuffle(cluster_items)
+
+    total_count = len(rows)
+    target_train = int(total_count * train_ratio)
+    target_val = int(total_count * val_ratio)
+
+    splits: dict[str, list[dict]] = {"train": [], "val": [], "test": []}
+
+    current_train = 0
+    current_val = 0
+
+    for cid, members in cluster_items:
+        mem_len = len(members)
+        if current_train + mem_len <= target_train or not splits["val"]:
+            splits["train"].extend(members)
+            current_train += mem_len
+        elif current_val + mem_len <= target_val or not splits["test"]:
+            splits["val"].extend(members)
+            current_val += mem_len
+        else:
+            splits["test"].extend(members)
+
+    return splits
+
+
+def run(
+    manifest: Manifest,
+    cfg: dict,
+    data_dir: Path,
+    splits_dir: Path,
+    train_ratio: float = 0.70,
+    val_ratio: float = 0.15,
+    test_ratio: float = 0.15,
+    copy_files: bool = True,
+    seed: int = 42,
+) -> dict[str, int]:
+    """Execute cluster-isolated dataset split and write files to splits directory."""
+    splits = create_cluster_splits(
+        manifest, train_ratio=train_ratio, val_ratio=val_ratio, test_ratio=test_ratio, seed=seed
+    )
+
+    stats = {
+        "train": len(splits["train"]),
+        "val": len(splits["val"]),
+        "test": len(splits["test"]),
+        "total_split": sum(len(s) for s in splits.values()),
+    }
+
+    if not stats["total_split"]:
+        log.warning("splitter: 0 images split")
+        return stats
+
+    # Update database split assignments
+    with manifest.transaction():
+        for split_name, members in splits.items():
+            for m in members:
+                manifest.update_image(m["image_id"], split=split_name)
+
+    # Export split files to disk
+    if copy_files:
+        for split_name, members in splits.items():
+            dst_img_dir = splits_dir / split_name / "images"
+            dst_img_dir.mkdir(parents=True, exist_ok=True)
+            for m in members:
+                src_rel = m.get("norm_path") or m.get("orig_path")
+                if not src_rel:
+                    continue
+                src_path = data_dir / src_rel
+                if src_path.exists():
+                    dst_path = dst_img_dir / src_path.name
+                    if not dst_path.exists():
+                        shutil.copy2(src_path, dst_path)
+
+    log.info("splitter split summary: %s", stats)
+    return stats

google_drive_export/pipeline/validator.py

@@ -0,0 +1,159 @@
+"""Validation engine.
+
+Checks run cheapest-first so most bad files fail early:
+
+  1. file size            < min_file_bytes                    -> discard  too_small_file
+  2. integrity            open -> verify() -> reopen -> load() -> discard  corrupt
+  3. animated             multi-frame GIF/WEBP/APNG            -> flag     animated (first frame used)
+  4. resolution           short/long side below minimum       -> discard  low_resolution
+  5. aspect (hard)        > hard_aspect : 1                   -> discard  extreme_aspect_hard
+  6. aspect (soft)        > flag_aspect : 1                   -> flag     extreme_aspect (goes to review)
+
+`verify()` alone does not detect truncated JPEGs, so the file is reopened and fully decoded
+with `load()` (verify() invalidates the image object, hence the reopen).
+The soft aspect limit is a *flag*, not a discard: RAM modules and edge-finger strips are
+naturally ~4.5-5:1 and must survive.
+"""
+from __future__ import annotations
+
+import logging
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from PIL import Image, ImageFile
+from tqdm import tqdm
+
+from .manifest import Manifest
+
+log = logging.getLogger(__name__)
+
+ImageFile.LOAD_TRUNCATED_IMAGES = False  # never silently accept truncated files
+# Pillow's own bomb check works through process-global warnings (not thread-safe), so it is
+# disabled and replaced by an explicit header-size check in validate_image().
+Image.MAX_IMAGE_PIXELS = None
+
+ALLOWED_FORMATS = {"JPEG", "MPO", "PNG", "WEBP", "GIF", "BMP", "TIFF"}
+
+
+def register_heif() -> bool:
+    """Enable iPhone HEIC/HEIF photos if the optional `pillow-heif` package is installed."""
+    try:
+        import pillow_heif  # type: ignore
+
+        pillow_heif.register_heif_opener()
+        ALLOWED_FORMATS.add("HEIF")
+        return True
+    except Exception:  # pragma: no cover - optional dependency
+        return False
+
+
+register_heif()
+
+
+@dataclass
+class ValidationResult:
+    ok: bool
+    reason: str | None = None
+    flags: list[str] = field(default_factory=list)
+    width: int | None = None
+    height: int | None = None
+    fmt: str | None = None
+    aspect: float | None = None
+
+
+DEFAULT_AI_KEYWORDS = {
+    "midjourney", "stable diffusion", "dall-e", "dalle", "comfyui",
+    "novelai", "c2pa", "firefly", "bing image creator", "flux.1",
+    "fooocus", "automatic1111", "ai_generated", "generated by"
+}
+
+
+def check_ai_metadata(img: Image.Image, custom_keywords: list[str] | set[str] | None = None) -> bool:
+    """Return True if image metadata contains AI generator signatures."""
+    keywords = set(custom_keywords) if custom_keywords else DEFAULT_AI_KEYWORDS
+    info = getattr(img, "info", {})
+    if not isinstance(info, dict):
+        return False
+    raw_str = " ".join(f"{k} {v}" for k, v in info.items()).lower()
+    return any(kw.lower() in raw_str for kw in keywords)
+
+
+def validate_image(path: str | Path, vcfg: dict) -> ValidationResult:
+    path = Path(path)
+    try:
+        size = path.stat().st_size
+    except OSError:
+        return ValidationResult(False, "missing_file")
+    if size < int(vcfg["min_file_bytes"]):
+        return ValidationResult(False, "too_small_file")
+
+    max_pixels = int(vcfg.get("max_pixels", 120_000_000))
+    flags: list[str] = []
+    try:
+        with Image.open(path) as img:  # lazy: reads the header only
+            if img.width * img.height > max_pixels:
+                return ValidationResult(False, "decompression_bomb", width=img.width, height=img.height)
+            img.verify()
+        with Image.open(path) as img:  # reopen: verify() leaves the object unusable
+            fmt = img.format
+            if fmt not in ALLOWED_FORMATS:
+                return ValidationResult(False, "unsupported_format", fmt=fmt)
+            animated = bool(getattr(img, "is_animated", False))
+            img.load()  # full decode -> catches truncation that verify() misses
+            width, height = img.size
+
+            if check_ai_metadata(img, vcfg.get("ai_keywords")):
+                return ValidationResult(False, "ai_generated_metadata", width=width, height=height, fmt=fmt)
+    except Exception:  # OSError, SyntaxError, ValueError, struct errors, ...
+        return ValidationResult(False, "corrupt")
+
+    if animated:
+        flags.append("animated")
+
+    short, long_ = min(width, height), max(width, height)
+    if short < int(vcfg["min_short_side"]) or long_ < int(vcfg["min_long_side"]):
+        return ValidationResult(False, "low_resolution", flags, width, height, fmt)
+
+    aspect = long_ / short if short else float("inf")
+    if aspect > float(vcfg["hard_aspect"]):
+        return ValidationResult(False, "extreme_aspect_hard", flags, width, height, fmt, aspect)
+    if aspect > float(vcfg["flag_aspect"]):
+        flags.append("extreme_aspect")
+
+    return ValidationResult(True, None, flags, width, height, fmt, round(aspect, 4))
+
+
+def run(manifest: Manifest, cfg: dict, data_dir: Path, force: bool = False) -> dict[str, int]:
+    """Validate images. If force=True, re-checks previously validated/normalized images for AI metadata."""
+    vcfg = cfg["validate"]
+    statuses = ["downloaded", "validated", "normalized", "kept"] if force else ["downloaded"]
+    todo = manifest.images(statuses=statuses)
+    stats: dict[str, int] = {"validated": 0}
+    if not todo:
+        log.info("validate: nothing to do")
+        return stats
+
+    def work(img: dict) -> tuple[dict, ValidationResult]:
+        return img, validate_image(data_dir / img["orig_path"], vcfg)
+
+    workers = int(vcfg.get("workers", 4))
+    with ThreadPoolExecutor(max_workers=workers) as ex:
+        futures = [ex.submit(work, img) for img in todo]
+        with manifest.transaction():
+            for fut in tqdm(as_completed(futures), total=len(futures), desc="validate", unit="img"):
+                img, res = fut.result()
+                if res.ok:
+                    flags = sorted(set(img["flags"]) | set(res.flags))
+                    manifest.update_image(
+                        img["image_id"], status="validated", width=res.width, height=res.height,
+                        aspect_ratio=res.aspect, orig_format=(res.fmt or "").lower(), flags=flags)
+                    stats["validated"] += 1
+                else:
+                    manifest.update_image(
+                        img["image_id"], status="discarded", discard_reason=res.reason,
+                        width=res.width, height=res.height, aspect_ratio=res.aspect,
+                        flags=sorted(set(img["flags"]) | set(res.flags)))
+                    stats[res.reason or "discarded"] = stats.get(res.reason or "discarded", 0) + 1
+    log.info("validate: %s", stats)
+    return stats

implementation_plan.md

@@ -0,0 +1,72 @@
+# Implementation Plan: E-Waste Dataset Scraper & Pipeline (v2 Architecture)
+
+Build a modular, production-grade Python web scraper and image preprocessing pipeline following `scraper_plan_v2.md` to harvest, clean, deduplicate, and prepare high-resolution e-waste PCB dataset images for fine-tuning YOLOv8 micro-component detectors.
+
+## User Review Required
+
+> [!IMPORTANT]
+> **Scraping Target & Volume:** The pilot harvest target will be set to **500 images per query batch** across Bing and Flickr to keep the pilot run under 10–15 minutes while establishing real attrition rates.
+> **Dependency Note:** `icrawler`, `pillow`, `imagehash`, and `open_clip_torch` (or lightweight CLIP filtering) will be installed in the environment.
+
+## Open Questions
+
+> [!NOTE]
+> **CLIP Relevance Filter Mode:** Should the initial script execute CLIP zero-shot relevance filtering locally via PyTorch, or fall back to rule-based aspect-ratio/color-histogram heuristic filtering if PyTorch GPU memory is constrained during background runs? (Default: Rule-based + optional CLIP module).
+
+---
+
+## Proposed Changes
+
+### Scraping & Pipeline Package (`ewaste_dataset_pipeline/`)
+
+Creation of a self-contained, modular Python CLI pipeline under `ewaste_dataset_pipeline/`.
+
+#### [NEW] [`config/taxonomy.yaml`](file:///home/taruns/sih2026_kabadiwala/ewaste_dataset_pipeline/config/taxonomy.yaml)
+- Defines the 5 target YOLO detection classes: `cpu_socket`, `gold_finger`, `ic_chip`, `tantalum_capacitor`, `desoldered_zone`.
+- Defines image-level tags: `board_type`, `condition`, `source_type`.
+
+#### [NEW] [`config/queries.yaml`](file:///home/taruns/sih2026_kabadiwala/ewaste_dataset_pipeline/config/queries.yaml)
+- Search query expansion matrix across search terms, condition variants, board types, and multilingual terms.
+
+#### [NEW] [`pipeline/manifest.py`](file:///home/taruns/sih2026_kabadiwala/ewaste_dataset_pipeline/pipeline/manifest.py)
+- SQLite database abstraction layer (`manifest.db`) tracking URL provenance, download status, MD5 checksums, resolution, pHash values, cluster IDs, and split assignments.
+
+#### [NEW] [`pipeline/crawler.py`](file:///home/taruns/sih2026_kabadiwala/ewaste_dataset_pipeline/pipeline/crawler.py)
+- URL harvester using `icrawler` (Bing, Flickr, Baidu) with exponential backoff retries, custom headers, and rate limiting. Saves raw bytes to `data/originals/`.
+
+#### [NEW] [`pipeline/validator.py`](file:///home/taruns/sih2026_kabadiwala/ewaste_dataset_pipeline/pipeline/validator.py)
+- Validation engine checking file integrity (`verify()` + `load()`), short/long resolution cutoffs ($\ge 480\text{ px}$ short side), and aspect ratio bounds (flag $> 3:1$, drop $> 6:1$).
+
+#### [NEW] [`pipeline/processor.py`](file:///home/taruns/sih2026_kabadiwala/ewaste_dataset_pipeline/pipeline/processor.py)
+- Image normalizer handling EXIF auto-rotation (`exif_transpose`), RGBA alpha white-background compositing, CMYK to RGB conversion, and JPEG 95 quality encoding.
+
+#### [NEW] [`pipeline/dedup.py`](file:///home/taruns/sih2026_kabadiwala/ewaste_dataset_pipeline/pipeline/dedup.py)
+- Multi-tier deduplication engine (SHA-256 exact byte hash + perceptual `pHash`/`dHash` with horizontal flip awareness).
+
+#### [NEW] [`scraper.py`](file:///home/taruns/sih2026_kabadiwala/ewaste_dataset_pipeline/scraper.py)
+- Unified CLI entry point supporting subcommands: `harvest`, `validate`, `process`, `dedup`, `report`.
+
+#### [NEW] [`requirements.txt`](file:///home/taruns/sih2026_kabadiwala/ewaste_dataset_pipeline/requirements.txt)
+- Dependency specifications (`icrawler`, `Pillow`, `imagehash`, `pyyaml`, `tqdm`).
+
+---
+
+## Verification Plan
+
+### Automated Verification
+1. **Unit & Module Tests:**
+   - Test image validation on corrupted, truncated, transparent PNG, CMYK, and EXIF-rotated sample images.
+   - Verify pHash deduplication on identical vs resized/flipped images.
+2. **CLI Execution Runs:**
+   - Execute pilot harvest run:
+     ```bash
+     cd ewaste_dataset_pipeline
+     python3 scraper.py harvest --max-num 50
+     python3 scraper.py validate
+     python3 scraper.py process
+     python3 scraper.py dedup
+     python3 scraper.py report
+     ```
+
+### Manual Verification
+- Inspect generated `reports/summary.json` to verify image yield, discard counts by reason, and clean `dataset_raw/` outputs.

implementation_plan_component_purity_index.md

@@ -0,0 +1,148 @@
+# Implementation Plan: Edge "Component Purity & Cannibalization Index" (Updated)
+
+This feature delivers real-time, on-device detection of PCB cannibalization (stripping/depopulation of valuable components like CPU sockets, gold edge fingers, and tantalum capacitors) to calculate a **Board Integrity Score (BIS)**, generate vernacular voice warnings for scrap pricing adjustments, and propagate integrity data through the Dealer → Recycler chain to catch mid-chain stripping fraud.
+
+Model training data collection is still in progress, so this plan is split into two tracks joined by a single frozen interface (`model_contract.md`): **Track A** builds and trains the detection model; **Track B** builds the full app pipeline against a mock model conforming to that same contract, so integration is not blocked on model readiness. Swapping the mock for the trained model later is a one-line config change, not a rewrite.
+
+---
+
+## User Review Required
+
+> [!IMPORTANT]
+> - **Labeling taxonomy refinement**: Split desoldered footprints into `forcibly_desoldered_pad` (jagged, torn traces, burnt flux) and `factory_unpopulated_pad` (pristine silkscreen, smooth solder dots) to eliminate false cannibalization alerts on unpopulated board regions. Added `occluded_region` to prevent penalizing components covered by heatsinks/dust.
+> - **Form-factor baselines**: Replaced static class-wide component counts with form-factor sub-profiles (`desktop_atx`, `desktop_micro_atx`, `server_1u`, `gpu_pcb`, `ram_dimm`) in `board_profiles.json` to prevent small intact boards from receiving low BIS scores.
+> - **Dynamic price floor**: Replaced the rigid 35% hardcoded price floor with category-based scrap grade floors ($\text{Floor}_{\text{category}}$ = 15% for high-grade server/GPU boards up to 60% for low-grade power boards).
+> - **Sequential edge execution**: Adopted sequential model loading (`dispose()` calls between 21-class category classifier and YOLOv8 micro-model) to prevent memory crashes on 2GB–3GB RAM Android phones.
+> - **BIS-delta tolerance bands**: Updated recycler intake fraud threshold to $>12\%$ for advisory flags and $>25\%$ for critical alerts (up from 5%) to accommodate field-vs-warehouse camera & lighting variances.
+> - **Offline voice fallback**: Standardized pre-recorded `.opus` audio snippets via Service Worker `CacheStorage` as a fallback when Web Speech API offline regional voice packs are missing.
+> - **Data sourcing strategy**: Confirmed that existing open datasets can bootstrap the generic (`*_intact`) component classes, removing most of the annotation burden for those; the fraud-specific classes (`forcibly_desoldered_pad`, `occluded_region`) still require primarily field-staged photography, supplemented — not replaced — by mined web sources. See Phase 1, Component 2a. **Requires a decision on whether forum/marketplace-sourced supplemental images are approved for use** (see licensing note in Component 2a) before any scraping work begins.
+
+---
+
+## Track A: Micro-Component Detection Model
+
+### Phase 1: Data Collection & Labeling (Updated Guidelines)
+
+#### Component 1: Refined Labeling Taxonomy (`taxonomy/component_classes.yaml`)
+- [NEW] Defines fine-grained class states to eliminate false positives:
+  - `bga_cpu_socket_intact`, `bga_cpu_socket_missing`
+  - `gold_edge_finger_intact`, `gold_edge_finger_stripped`
+  - `tantalum_cap_intact`, `tantalum_cap_missing`
+  - `ram_dimm_slot_intact`, `ram_dimm_slot_stripped`
+  - `forcibly_desoldered_pad` (jagged solder, torn traces, blowtorch/burnt flux residue — primary fraud signal)
+  - `factory_unpopulated_pad` (clean silkscreen outline, smooth solder dots — unpopulated from factory, NOT fraud)
+  - `occluded_region` (heatsinks, metal shields, heavy dirt/dust covering component pads)
+
+#### Component 2: Data Collection & Sourcing Protocol (`data_collection/`)
+- [NEW] `capture_protocol.md` — multi-angle capture protocol (Front side top-down, Reverse side top-down, and macro gold edge connector shot) to handle 2-sided PCB inspection.
+- [NEW] `board_sourcing_log.csv` — logs board type, source, form factor (`desktop_atx`, `micro_atx`, `server_4u`, etc.), and intentional stripping state (pristine, blowtorched, organically degraded, factory unpopulated).
+- Sourcing requirements: Must harvest dirty, corroded, dusty, and factory-unpopulated boards alongside pristine and stripped examples to match field scrap yard conditions.
+
+#### Component 2a: Data Sourcing Strategy — Open Datasets, Mined Web Sources, and Field Photography (`data_collection/sourcing_strategy.md`)
+
+Research into publicly available data confirms a **three-tier sourcing strategy**, since scraping alone cannot cover the fraud-specific classes:
+
+**Tier 1 — Open datasets, for bootstrapping `*_intact` classes (use directly, no scraping needed):**
+- A Dataset Ninja "PCB Component Detection" set — 1,410 images, 11,119 bounding-box-labeled objects across 9 classes (capacitor, transformer, MOSFET, resistor, etc.), released CC0 and explicitly tagged for the waste-recycling use case.
+- HuggingFace `PCB_COMPONENTS_LABELLED` — 17-class YOLO-format set (IC, capacitor, connector, crystal oscillator, diode, ferrite bead, fuse, inductor, LED, resistor, switch, transistor, pins, pads, test points).
+- HuggingFace `pcb-object-detection-dataset` — 21-class YOLO set including heatsinks and connectors.
+- Roboflow Universe community PCB datasets (component-level bounding boxes, CC BY 4.0).
+- **Use**: pretrain the detection backbone and pad out the `*_intact` and generic-component classes; re-map class names to `taxonomy/component_classes.yaml`. This does not reduce the need for field data on fraud-specific classes below, but meaningfully cuts the annotation volume needed for the "board still has its parts" side of the taxonomy.
+
+**Tier 2 — Mined web sources, as a supplemental seed set for `forcibly_desoldered_pad` only (not a primary source):**
+- Gold-recovery/e-waste hobbyist forums (e.g. Gold Refining Forum, finishing.com) contain user-posted photos of boards before, during, and after chip/pin removal, and active community discussion distinguishing "unpopulated" from "depopulated" boards — the closest organic analog to the `forcibly_desoldered_pad` class available online.
+- Hobbyist "gold recovery" / heat-gun chip-pulling YouTube videos are a higher-yield variant of the same source: frame-extraction from a single video can produce many more usable images than a forum thread.
+- **Known limitations, by design not treated as a primary source**:
+  - Low volume per source and inconsistent photo quality/angle — doesn't match the phone-camera, scrap-yard conditions defined in `capture_protocol.md`.
+  - No existing bounding boxes — still requires full manual annotation, same as field photos.
+  - Licensing: forum and video content is user-generated and not freely licensed for reuse; scraping is low-risk for an internal/hackathon prototype but is **not cleared for production training data** without explicit permission or a licensed dataset. Flagged in User Review Required above — treat as blocked until a decision is made.
+- **Use**: a small supplemental set to diversify what "stripped" looks like beyond staged photos, mined and annotated in parallel with, not instead of, Tier 3.
+
+**Tier 3 — Deliberately staged field photography, mandatory and primary for fraud classes (this is the existing Component 2 protocol above):**
+- Only source that guarantees: domain match to real collector phone conditions, controlled multi-angle capture, and clean separation between `forcibly_desoldered_pad`, `factory_unpopulated_pad`, and `occluded_region` at capture time (know the ground truth because you staged it, rather than inferring it after the fact from a forum photo).
+- Remains the dataset of record for Phase 4 evaluation thresholds; Tier 1/2 data is for pretraining and augmentation only, not held-out test data.
+
+#### Component 3: Annotation & QA
+- [NEW] Bounding-box annotation via CVAT or Label Studio, exported in COCO/YOLO format.
+- [NEW] `qa_annotation_review.py` — inter-annotator agreement check (min. 2 annotators per image, flag disagreement >10% of boxes for adjudication).
+- Target: minimum 300 images per class, with at least 30% deliberately-stripped/burnt negative examples, before first training run.
+
+### Phase 2: Form-Factor Baseline Definitions
+
+#### Component 4: Dynamic Board Profiles (`baselines/board_profiles.json`)
+- [NEW] Defines expected component counts/area ratios per board class **and form factor**:
+  - `desktop_atx`, `desktop_micro_atx`, `desktop_itx`
+  - `server_1u_2u`, `server_blade_4u`
+  - `gpu_pcb_high_end`, `gpu_pcb_budget`
+  - `ram_dimm_desktop`, `ram_so_dimm_laptop`
+- Sourced from recycling domain experts — consumed downstream by `purity_assay.py`.
+
+### Phase 3: Model Training
+
+#### Component 5: Training Pipeline (`training/train.py`)
+- [NEW] YOLOv8n/s fine-tuning with multi-scale training (`imgsz=960` or `1280`) and custom anchor ratios for elongated `gold_finger` boxes ($>4:1$).
+- Heavy augmentations for field realities: specular glare on gold fingers, lighting variance, dirt noise, and angle tilt.
+- [NEW] `train_config.yaml` — Focal loss & elevated class weights for `forcibly_desoldered_pad` vs `factory_unpopulated_pad`.
+
+#### Component 6: Auxiliary Desoldered Pad Classifier Head
+- [NEW] Secondary classification head specifically trained to distinguish desoldered blowtorch pads from factory empty pads.
+
+#### Component 7: Export & Quantization (`export/export_tflite.py`)
+- [NEW] Export to TFLite INT8 quantized, target size <15MB, target inference <1s on low-end Android hardware.
+- [NEW] `model_contract.md` — freezes input/output tensor schema.
+
+### Phase 4: Evaluation
+
+#### Component 8: Model Evaluation (`eval/evaluate.py`)
+- [NEW] Per-class mAP, plus dedicated fraud recall on `forcibly_desoldered_pad` and false-positive rate on `factory_unpopulated_pad`.
+- Thresholds: $\ge 90\%$ recall on intact classes, $\ge 85\%$ recall on desoldered pad classes, and $\le 5\%$ false positive rate on factory unpopulated pads.
+
+---
+
+## Track B: Integration into Kabadiwala Connect
+
+### Component 9: Purity Engine & Memory-Conscious Orchestrator (`purity_engine/`)
+
+- [NEW] `purity_engine/model_client.py` — wrapper supporting `MockModelClient` and `TFLiteModelClient` with explicit tensor memory management (`model.dispose()` between Stage 1 and Stage 2).
+- [NEW] `purity_engine/purity_assay.py` — implements `calculate_board_integrity_score(detected_components, form_factor)`:
+  - Dynamic price formula:
+    $$\text{Adjusted Price} = \text{Base Price} \times \left( \text{Floor}_{\text{category}} + (1 - \text{Floor}_{\text{category}}) \times \frac{\text{BIS}}{100} \right)$$
+  - Scrap Grade Floors: Server/GPU = 15%, Desktop = 30%, Low-grade Power = 60%.
+- [NEW] `purity_engine/pcb_analyzer.py` — single entry point for Collector Lite & Recycler Portal.
+
+### Component 10: Vernacular Voice Alerts with Audio Fallback (`purity_engine/vernacular_voice.py`)
+
+- [NEW] Extends Collector Lite's 8-language Web Speech API audio system with Service Worker pre-recorded `.opus` audio fallbacks for offline devices lacking regional voice packs.
+- Message templates parameterized by BIS band (Pristine $\ge 85\%$, Partial $50\text{--}84\%$, Severe $<50\%$).
+
+### Component 11: Collector Lite Multi-Angle UI Integration (`mobile/kabadiwala-lite.html`)
+
+- Extend Step 1 of Collector Lite: Stage 1 21-class classifier detects `PCB` $\rightarrow$ prompts guided Front/Back photo capture $\rightarrow$ triggers `pcb_analyzer`.
+- Displays BIS score, missing-component breakdown, and transparent price adjustment in Step 3.
+- Persists assay JSON into IndexedDB with the scrap slip.
+
+### Component 12: QR Handover Payload Enrichment (`mobile/dealer.html`, backend)
+
+- QR payload includes collector BIS score, form factor, and assay report hash.
+
+### Component 13: Recycler Portal BIS-Delta View (`recycler-dashboard-frontend/`)
+
+- Re-scan intake lot via `pcb_analyzer`.
+- Tolerance Bands:
+  - $< 12\%$ BIS Drop $\rightarrow$ Normal capture variance (Pass).
+  - $12\text{--}25\%$ BIS Drop $\rightarrow$ Discrepancy Flagged.
+  - $> 25\%$ BIS Drop $\rightarrow$ Critical Fraud Alert & CPCB Form 6 PDF Audit Log Entry.
+
+### Component 14: Backend API Changes (`backend/`)
+
+- [NEW] `POST /api/lots/{lot_id}/assay` & `GET /api/lots/{lot_id}/bis-delta`.
+
+---
+
+## Sequencing Summary
+
+| | Track A (Model & Dataset) | Track B (App Integration) |
+|---|---|---|
+| Now | Tier 1: bootstrap from open datasets. Tier 3: harvest dirty/stripped/unpopulated boards; annotate fine-grained taxonomy. Tier 2 (mined web sources) blocked pending licensing decision | Build multi-angle UI & pricing engine against `MockModelClient` |
+| Parallel | Multi-scale YOLOv8 training with focal loss & TFLite INT8 quantization | Collector Lite, audio fallbacks, Recycler Portal BIS-delta tolerance UI |
+| Hand-off | Ship model clearing Phase 4 thresholds | Swap `TFLiteModelClient` in with zero code changes |

pipeline/auto_annotate.py

@@ -0,0 +1,176 @@
+"""Automated Zero-Shot Auto-Annotation Pipeline using YOLO-World (Ultra-Lightweight / Resumable Mode).
+
+Auto-labels images in `data/images/` using the updated 7-class taxonomy:
+  0: cpu_socket
+  1: gold_finger
+  2: ic_chip
+  3: tantalum_capacitor
+  4: forcibly_desoldered_pad
+  5: factory_unpopulated_pad
+  6: occluded_region
+
+Features:
+  - Resumable (`skip_existing=True`): Skips already auto-labeled non-empty `.txt` files.
+  - Ultra-Low Memory (<500 MB RAM): Standard single-pass inference + per-image `gc.collect()`.
+"""
+from __future__ import annotations
+
+import gc
+import json
+import logging
+import os
+import shutil
+from pathlib import Path
+
+import torch
+import yaml
+from PIL import Image
+from tqdm import tqdm
+
+cache_dir = Path("data/cache").resolve()
+cache_dir.mkdir(parents=True, exist_ok=True)
+os.environ["TORCH_HOME"] = str(cache_dir)
+os.environ["HF_HOME"] = str(cache_dir)
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+log = logging.getLogger(__name__)
+
+CLASS_NAMES = [
+    "cpu_socket",
+    "gold_finger",
+    "ic_chip",
+    "tantalum_capacitor",
+    "forcibly_desoldered_pad",
+    "factory_unpopulated_pad",
+    "occluded_region",
+]
+
+CLASS_PROMPTS = [
+    "CPU socket square slot",
+    "gold edge connector pins",
+    "black IC microchip",
+    "yellow SMD capacitor",
+    "desoldered solder pad footprint",
+    "empty unpopulated solder pad",
+    "metal heatsink shield cover",
+]
+
+
+def run_auto_annotation(
+    data_dir: str | Path = "data",
+    output_dir: str | Path = "data/annotated_auto",
+    conf_threshold: float = 0.015,
+    max_images: int | None = None,
+    skip_existing: bool = True,
+) -> dict:
+    torch.set_num_threads(1)
+
+    data_dir = Path(data_dir)
+    output_dir = Path(output_dir)
+    images_in_dir = data_dir / "images"
+
+    images_out_dir = output_dir / "images"
+    labels_out_dir = output_dir / "labels"
+    images_out_dir.mkdir(parents=True, exist_ok=True)
+    labels_out_dir.mkdir(parents=True, exist_ok=True)
+
+    log.info("Loading YOLO-World model (Resumable Low-Memory Mode)...")
+    from ultralytics import YOLOWorld
+
+    model = YOLOWorld("yolov8s-worldv2.pt")
+    model.set_classes(CLASS_PROMPTS)
+
+    image_files = sorted(list(images_in_dir.glob("*.jpg")) + list(images_in_dir.glob("*.png")))
+    if max_images:
+        image_files = image_files[:max_images]
+
+    log.info("Starting Resumable Auto-Annotation across %d images...", len(image_files))
+
+    class_detection_counts = {name: 0 for name in CLASS_NAMES}
+    total_images_processed = 0
+    total_boxes_generated = 0
+    skipped_count = 0
+
+    for img_path in tqdm(image_files, desc="Resumable Auto-Annotating", unit="img"):
+        img_name = img_path.name
+        stem = img_path.stem
+
+        label_file = labels_out_dir / f"{stem}.txt"
+        dst_path = images_out_dir / img_name
+
+        if not dst_path.exists():
+            try:
+                shutil.copy2(img_path, dst_path)
+            except Exception as e:
+                log.warning("Could not copy %s: %s", img_name, e)
+
+        # Skip if label file exists and is non-empty
+        if skip_existing and label_file.exists() and label_file.stat().st_size > 0:
+            lines = label_file.read_text(encoding="utf-8").strip().splitlines()
+            for l in lines:
+                if not l: continue
+                parts = l.split()
+                cls_id = int(parts[0])
+                if 0 <= cls_id < len(CLASS_NAMES):
+                    class_detection_counts[CLASS_NAMES[cls_id]] += 1
+                    total_boxes_generated += 1
+            total_images_processed += 1
+            skipped_count += 1
+            continue
+
+        # Standard single-pass inference (lightweight)
+        results = model.predict(str(img_path), conf=conf_threshold, verbose=False)
+
+        lines = []
+        if results and len(results) > 0:
+            boxes = results[0].boxes
+            if boxes is not None and len(boxes) > 0:
+                xywhn = boxes.xywhn.cpu().numpy()
+                cls_ids = boxes.cls.cpu().numpy().astype(int)
+
+                for (x, y, w, h), cls_id in zip(xywhn, cls_ids):
+                    if 0 <= cls_id < len(CLASS_NAMES):
+                        lines.append(f"{cls_id} {x:.6f} {y:.6f} {w:.6f} {h:.6f}")
+                        class_name = CLASS_NAMES[cls_id]
+                        class_detection_counts[class_name] += 1
+                        total_boxes_generated += 1
+
+        label_file.write_text("\n".join(lines) + ("\n" if lines else ""), encoding="utf-8")
+        total_images_processed += 1
+
+        del results
+        gc.collect()
+
+    dataset_yaml = {
+        "path": str(output_dir.resolve()),
+        "train": "images",
+        "val": "images",
+        "names": {i: name for i, name in enumerate(CLASS_NAMES)},
+    }
+    yaml_path = output_dir / "data.yaml"
+    with open(yaml_path, "w", encoding="utf-8") as f:
+        yaml.dump(dataset_yaml, f, default_flow_style=False)
+
+    summary = {
+        "total_images_processed": total_images_processed,
+        "total_boxes_generated": total_boxes_generated,
+        "skipped_already_annotated": skipped_count,
+        "conf_threshold": conf_threshold,
+        "class_detection_counts": class_detection_counts,
+        "output_directory": str(output_dir.resolve()),
+        "data_yaml": str(yaml_path.resolve()),
+    }
+
+    summary_path = output_dir / "auto_annotation_summary.json"
+    with open(summary_path, "w", encoding="utf-8") as f:
+        json.dump(summary, f, indent=2)
+
+    log.info("Auto-annotation complete! Summary saved to %s", summary_path)
+    return summary
+
+
+if __name__ == "__main__":
+    import sys
+    max_imgs = int(sys.argv[1]) if len(sys.argv) > 1 and sys.argv[1].isdigit() else None
+    conf_val = float(sys.argv[2]) if len(sys.argv) > 2 else 0.015
+    run_auto_annotation(conf_threshold=conf_val, max_images=max_imgs)

pipeline/config.py

@@ -0,0 +1,109 @@
+"""Configuration loading, filesystem layout and logging setup."""
+from __future__ import annotations
+
+import copy
+import logging
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+
+
+def load_yaml(path: Path) -> dict[str, Any]:
+    with open(path, "r", encoding="utf-8") as fh:
+        return yaml.safe_load(fh) or {}
+
+
+def deep_update(base: dict, override: dict) -> dict:
+    """Recursively merge ``override`` into ``base`` (in place) and return it."""
+    for key, value in override.items():
+        if isinstance(value, dict) and isinstance(base.get(key), dict):
+            deep_update(base[key], value)
+        else:
+            base[key] = copy.deepcopy(value)
+    return base
+
+
+def load_config(path: str | Path | None = None, overrides: dict | None = None) -> dict[str, Any]:
+    cfg_path = Path(path) if path else PROJECT_ROOT / "config" / "config.yaml"
+    cfg = load_yaml(cfg_path)
+    cfg["_config_dir"] = str(cfg_path.resolve().parent)
+    if overrides:
+        deep_update(cfg, overrides)
+    return cfg
+
+
+def load_taxonomy(cfg: dict) -> dict[str, Any]:
+    return load_yaml(Path(cfg["_config_dir"]) / "taxonomy.yaml")
+
+
+def load_queries(cfg: dict) -> dict[str, Any]:
+    return load_yaml(Path(cfg["_config_dir"]) / "queries.yaml")
+
+
+@dataclass(frozen=True)
+class Paths:
+    """Filesystem layout. Manifest paths are stored relative to ``data``."""
+
+    base: Path
+    data: Path
+    originals: Path
+    images: Path
+    review: Path
+    realworld: Path
+    reports: Path
+    splits: Path
+    manifest_db: Path
+    manifest_jsonl: Path
+
+    def abs(self, rel: str | Path) -> Path:
+        return self.data / rel
+
+    def rel(self, path: str | Path) -> str:
+        return str(Path(path).resolve().relative_to(self.data.resolve()))
+
+    def ensure(self) -> None:
+        for p in (self.data, self.originals, self.images, self.review, self.realworld,
+                  self.reports, self.splits):
+            p.mkdir(parents=True, exist_ok=True)
+
+
+def get_paths(cfg: dict, base: str | Path | None = None) -> Paths:
+    base_dir = Path(base).resolve() if base else PROJECT_ROOT
+    pcfg = cfg.get("paths", {})
+    data = base_dir / pcfg.get("data_dir", "data")
+    return Paths(
+        base=base_dir,
+        data=data,
+        originals=data / "originals",
+        images=data / "images",
+        review=data / "review",
+        realworld=data / "realworld",
+        reports=base_dir / pcfg.get("reports_dir", "reports"),
+        splits=base_dir / pcfg.get("splits_dir", "splits"),
+        manifest_db=data / "manifest.db",
+        manifest_jsonl=data / "manifest.jsonl",
+    )
+
+
+def setup_logging(verbose: bool = False) -> None:
+    """Configure logging *before* icrawler is imported.
+
+    icrawler calls ``logging.basicConfig`` when a crawler is constructed; that is a
+    no-op once the root logger already has handlers, so configuring first keeps our
+    format and level in charge.
+    """
+    level = logging.DEBUG if verbose else logging.INFO
+    root = logging.getLogger()
+    if not root.handlers:
+        handler = logging.StreamHandler(sys.stderr)
+        handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)-7s %(name)s: %(message)s",
+                                               datefmt="%H:%M:%S"))
+        root.addHandler(handler)
+    root.setLevel(level)
+    logging.getLogger("urllib3").setLevel(logging.WARNING)
+    logging.getLogger("PIL").setLevel(logging.WARNING)

pipeline/crawler.py

@@ -0,0 +1,275 @@
+"""Harvesting engine: query search engines (icrawler / HTTP fallback) and download raw image binaries.
+
+Flow:
+  1. Build query list from queries.yaml matrix.
+  2. For each query and engine:
+       - Skip if `harvest_runs` records the run as done.
+       - Surface image URLs and store in `sources` and `hits` tables via `manifest.add_hit`.
+       - Record completed run in `harvest_runs`.
+  3. Download pending URLs into `data/originals/`, computing SHA-256 ID.
+  4. Register downloaded files in `images` table with status 'downloaded'.
+"""
+from __future__ import annotations
+
+import hashlib
+import logging
+import mimetypes
+import urllib.request
+import urllib.error
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Sequence
+
+from tqdm import tqdm
+
+from .manifest import Manifest, normalize_url
+from .queries import QuerySpec, build_queries
+
+log = logging.getLogger(__name__)
+
+HEADERS = {
+    "User-Agent": (
+        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
+        "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+    ),
+    "Accept": "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8",
+}
+
+EXT_MAP = {
+    "image/jpeg": ".jpg",
+    "image/jpg": ".jpg",
+    "image/png": ".png",
+    "image/webp": ".webp",
+    "image/gif": ".gif",
+    "image/bmp": ".bmp",
+    "image/tiff": ".tif",
+    "image/heic": ".heic",
+    "image/heif": ".heif",
+}
+
+
+def download_single_url(
+    source: dict, originals_dir: Path, timeout: float = 10.0
+) -> tuple[dict, str | None, str | None, int | None, str | None]:
+    """Download raw binary for one URL.
+
+    Returns (source, image_id, filepath, http_status, error_message).
+    """
+    url = source["url"]
+    url_norm = source["url_norm"]
+    req = urllib.request.Request(url, headers=HEADERS)
+
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            content_type = resp.headers.get("Content-Type", "").split(";")[0].strip().lower()
+            data = resp.read()
+            http_status = resp.status
+    except urllib.error.HTTPError as exc:
+        return source, None, None, exc.code, f"HTTPError: {exc.code}"
+    except Exception as exc:
+        return source, None, None, None, f"{type(exc).__name__}: {exc}"
+
+    if len(data) < 500:
+        return source, None, None, http_status, "file_too_small_raw"
+
+    sha = hashlib.sha256(data).hexdigest()
+    image_id = sha[:16]
+
+    ext = EXT_MAP.get(content_type) or Path(url).suffix.lower()
+    if not ext or len(ext) > 5 or ext not in (".jpg", ".jpeg", ".png", ".webp", ".gif", ".bmp", ".tif", ".heic"):
+        ext = ".jpg"
+
+    dst = originals_dir / f"{image_id}{ext}"
+    if not dst.exists():
+        originals_dir.mkdir(parents=True, exist_ok=True)
+        tmp = dst.with_name(dst.name + f".tmp")
+        tmp.write_bytes(data)
+        tmp.replace(dst)
+
+    return source, image_id, str(dst), http_status, None
+
+
+def download_pending_sources(
+    manifest: Manifest, originals_dir: Path, data_dir: Path, cfg: dict
+) -> dict[str, int]:
+    """Download pending URLs from manifest into `originals_dir`."""
+    ccfg = cfg.get("crawler", {})
+    workers = int(ccfg.get("threads", 4))
+    timeout = float(ccfg.get("timeout", 10.0))
+
+    pending = manifest.pending_sources()
+    stats = {"downloaded": 0, "download_failed": 0}
+    if not pending:
+        log.info("crawler: no pending sources to download")
+        return stats
+
+    log.info("crawler: downloading %d pending URL(s)", len(pending))
+
+    def work(src: dict):
+        return download_single_url(src, originals_dir, timeout=timeout)
+
+    with ThreadPoolExecutor(max_workers=workers) as ex:
+        futures = [ex.submit(work, s) for s in pending]
+        with manifest.transaction():
+            for fut in tqdm(as_completed(futures), total=len(futures), desc="download", unit="url"):
+                src, image_id, dst_path, http_status, err = fut.result()
+                if err is None and image_id and dst_path:
+                    data_file = Path(dst_path)
+                    data = data_file.read_bytes()
+                    sha = hashlib.sha256(data).hexdigest()
+                    rel_path = str(data_file.relative_to(data_dir))
+
+                    manifest.add_image(
+                        image_id=image_id,
+                        sha256=sha,
+                        origin="web",
+                        source_ref=src["url"],
+                        orig_path=rel_path,
+                        orig_format=data_file.suffix.lstrip(".").lower(),
+                        filesize=len(data),
+                        status="downloaded",
+                    )
+                    manifest.mark_source(
+                        src["url_norm"],
+                        status="downloaded",
+                        http_status=http_status,
+                        image_id=image_id,
+                        attempts=1,
+                    )
+                    stats["downloaded"] += 1
+                else:
+                    manifest.mark_source(
+                        src["url_norm"],
+                        status="failed",
+                        http_status=http_status,
+                        error=err,
+                        attempts=1,
+                    )
+                    stats["download_failed"] += 1
+
+    log.info("crawler download stats: %s", stats)
+    return stats
+
+
+def run_icrawler_harvest(
+    manifest: Manifest,
+    queries: Sequence[QuerySpec],
+    data_dir: Path,
+    engine_name: str = "bing",
+    max_num: int = 50,
+    force: bool = False,
+    filter_classes: set[str] | Sequence[str] | None = None,
+) -> dict[str, int]:
+    """Harvest image binaries using icrawler, save to data/originals, and register in manifest."""
+    stats = {"runs": 0, "urls_found": 0, "urls_new": 0, "images_harvested": 0}
+    try:
+        if engine_name.lower() == "bing":
+            from icrawler.builtin import BingImageCrawler as CrawlerEngine
+        elif engine_name.lower() == "flickr":
+            from icrawler.builtin import FlickrImageCrawler as CrawlerEngine
+        elif engine_name.lower() == "baidu":
+            from icrawler.builtin import BaiduImageCrawler as CrawlerEngine
+        else:
+            log.warning("Unknown engine '%s', defaulting to Bing", engine_name)
+            from icrawler.builtin import BingImageCrawler as CrawlerEngine
+    except ImportError:
+        log.warning("icrawler is not installed; skipping search engine crawling")
+        return stats
+
+    import tempfile
+    import shutil
+
+    originals_dir = data_dir / "originals"
+    originals_dir.mkdir(parents=True, exist_ok=True)
+
+    filter_set = set(filter_classes) if filter_classes else None
+
+    for qspec in queries:
+        if filter_set and qspec.class_hint not in filter_set:
+            continue
+        if not force and manifest.run_done(engine_name, qspec.query):
+            log.debug("Skip harvest done run: %s / %s", engine_name, qspec.query)
+            continue
+
+        tmp_dir = Path(tempfile.mkdtemp(prefix="icrawler_"))
+        try:
+            crawler = CrawlerEngine(
+                downloader_threads=2,
+                storage={"root_dir": str(tmp_dir)},
+                log_level=logging.WARNING,
+            )
+            crawler.crawl(keyword=qspec.query, max_num=max_num)
+
+            found_count = 0
+            new_count = 0
+            with manifest.transaction():
+                for img_file in tmp_dir.glob("*"):
+                    if img_file.is_file() and img_file.stat().st_size > 500:
+                        found_count += 1
+                        data = img_file.read_bytes()
+                        sha = hashlib.sha256(data).hexdigest()
+                        image_id = sha[:16]
+                        ext = img_file.suffix.lower()
+                        if not ext or len(ext) > 5 or ext not in (".jpg", ".jpeg", ".png", ".webp", ".gif", ".bmp"):
+                            ext = ".jpg"
+
+                        dst_file = originals_dir / f"{image_id}{ext}"
+                        if not dst_file.exists():
+                            dst_file.write_bytes(data)
+
+                        source_url = f"icrawler://{engine_name}/{qspec.class_hint}/{image_id}"
+                        is_new = manifest.add_hit(
+                            source_url, engine_name, qspec.query, class_hint=qspec.class_hint, lang=qspec.lang
+                        )
+                        if is_new:
+                            new_count += 1
+
+                        rel_path = str(dst_file.relative_to(data_dir))
+                        manifest.add_image(
+                            image_id=image_id,
+                            sha256=sha,
+                            origin="web",
+                            source_ref=source_url,
+                            orig_path=rel_path,
+                            orig_format=ext.lstrip("."),
+                            filesize=len(data),
+                            status="downloaded",
+                        )
+                        manifest.mark_source(
+                            source_url,
+                            status="downloaded",
+                            image_id=image_id,
+                        )
+                        stats["images_harvested"] += 1
+
+            manifest.record_run(
+                engine_name, qspec.query, qspec.class_hint, max_num, found_count, new_count
+            )
+            stats["runs"] += 1
+            stats["urls_found"] += found_count
+            stats["urls_new"] += new_count
+        except Exception as exc:
+            log.error("icrawler harvest failed for %s (%s): %s", qspec.query, engine_name, exc)
+        finally:
+            shutil.rmtree(tmp_dir, ignore_errors=True)
+
+    log.info("harvest stats (%s): %s", engine_name, stats)
+    return stats
+
+
+def run(
+    manifest: Manifest, cfg: dict, data_dir: Path, engine: str = "bing", max_num: int = 50, force: bool = False, filter_classes: set[str] | Sequence[str] | None = None
+) -> dict[str, int]:
+    """Full crawler workflow: harvest queries and download raw images."""
+    qcfg = cfg.get("queries") or {}
+    if not qcfg:
+        from .config import load_queries
+        qcfg = load_queries(cfg)
+
+    queries = build_queries(qcfg)
+    harvest_stats = run_icrawler_harvest(manifest, queries, data_dir, engine_name=engine, max_num=max_num, force=force, filter_classes=filter_classes)
+
+    originals_dir = data_dir / "originals"
+    download_stats = download_pending_sources(manifest, originals_dir, data_dir, cfg)
+
+    return {**harvest_stats, **download_stats}

pipeline/dedup.py

@@ -0,0 +1,271 @@
+"""Deduplication engine (global across all classes and queries).
+
+Layer 1  exact       SHA-256 of the original bytes (already the image_id, so identical downloads
+                     collapse at download time) + SHA-256 of the decoded normalized pixels.
+Layer 2  near-dup    pHash AND dHash (64-bit each) within a Hamming-distance budget. Every image
+                     also stores the hashes of its horizontally FLIPPED version, and a pair counts
+                     as a duplicate if it matches in either orientation (mirror copies).
+Layer 3  semantic    CLIP-embedding cosine clustering. This layer never deletes anything; it only
+                     merges cluster ids so the splitter keeps "same board, different angle" together.
+
+Layers 1-2 remove images: within a duplicate group the keeper is chosen by
+    (already-processed before new) > (real-world before web) > higher resolution > larger file > id
+so re-running the pipeline never swaps out an image that was already kept or annotated.
+Duplicate groups are connected components (union-find), so chains A~B~C collapse into one group.
+"""
+from __future__ import annotations
+
+import logging
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Sequence
+
+import imagehash
+import numpy as np
+from PIL import Image, ImageOps
+from tqdm import tqdm
+
+from .manifest import Manifest
+
+log = logging.getLogger(__name__)
+
+# Statuses whose images are candidates for duplicate comparison (hashes present).
+_PROCESSED = ("deduped", "kept", "review")
+_CANDIDATES = ("normalized",) + _PROCESSED
+
+_POP8 = np.array([bin(i).count("1") for i in range(256)], dtype=np.uint8)
+
+
+# ------------------------------------------------------------------------------------ hashing
+def compute_hashes(path: str | Path) -> dict[str, str]:
+    """pHash/dHash (8x8 => 64 bit, hex) for an image and for its horizontal mirror."""
+    with Image.open(path) as im:
+        im.draft("RGB", (512, 512))  # cheap JPEG downscale on decode; same procedure for all images
+        im = ImageOps.exif_transpose(im).convert("RGB")
+        flipped = ImageOps.mirror(im)
+        return {
+            "phash": str(imagehash.phash(im, hash_size=8)),
+            "dhash": str(imagehash.dhash(im, hash_size=8)),
+            "phash_flip": str(imagehash.phash(flipped, hash_size=8)),
+            "dhash_flip": str(imagehash.dhash(flipped, hash_size=8)),
+        }
+
+
+def hex_to_u64(values: Sequence[str]) -> np.ndarray:
+    return np.array([int(v, 16) for v in values], dtype=np.uint64)
+
+
+def popcount64(x: np.ndarray) -> np.ndarray:
+    """Per-element population count of a uint64 array."""
+    if hasattr(np, "bitwise_count"):  # numpy >= 2.0
+        return np.bitwise_count(x)
+    x = np.ascontiguousarray(x)
+    return _POP8[x.view(np.uint8).reshape(*x.shape, 8)].sum(axis=-1)
+
+
+# --------------------------------------------------------------------------------- union-find
+class UnionFind:
+    def __init__(self, n: int):
+        self.parent = list(range(n))
+
+    def find(self, a: int) -> int:
+        while self.parent[a] != a:
+            self.parent[a] = self.parent[self.parent[a]]
+            a = self.parent[a]
+        return a
+
+    def union(self, a: int, b: int) -> None:
+        ra, rb = self.find(a), self.find(b)
+        if ra != rb:
+            self.parent[max(ra, rb)] = min(ra, rb)
+
+    def groups(self) -> list[list[int]]:
+        out: dict[int, list[int]] = defaultdict(list)
+        for i in range(len(self.parent)):
+            out[self.find(i)].append(i)
+        return [g for g in out.values() if len(g) > 1]
+
+
+def near_duplicate_pairs(ph: np.ndarray, dh: np.ndarray, phf: np.ndarray, dhf: np.ndarray,
+                         phash_max: int, dhash_max: int, block_cells: int = 4_000_000):
+    """Yield (i, j), i < j, whose pHash *and* dHash are within budget in the same orientation
+    (direct, or with j mirrored). Vectorized in row blocks to bound memory."""
+    n = len(ph)
+    if n < 2:
+        return
+    block = max(1, block_cells // n)
+    cols = np.arange(n)
+    for a in range(0, n, block):
+        b = min(n, a + block)
+        upper = cols[None, :] > np.arange(a, b)[:, None]
+        direct = (popcount64(ph[a:b, None] ^ ph[None, :]) <= phash_max) & \
+                 (popcount64(dh[a:b, None] ^ dh[None, :]) <= dhash_max)
+        mirrored = (popcount64(ph[a:b, None] ^ phf[None, :]) <= phash_max) & \
+                   (popcount64(dh[a:b, None] ^ dhf[None, :]) <= dhash_max)
+        ii, jj = np.nonzero((direct | mirrored) & upper)
+        for i, j in zip(ii + a, jj):
+            yield int(i), int(j)
+
+
+def find_duplicate_groups(rows: list[dict], phash_max: int, dhash_max: int) -> list[list[int]]:
+    """Group row indices by exact pixel hash + near-duplicate hashes (connected components)."""
+    n = len(rows)
+    uf = UnionFind(n)
+    by_pixels: dict[str, int] = {}
+    for i, r in enumerate(rows):
+        px = r.get("pixel_sha256")
+        if px:
+            if px in by_pixels:
+                uf.union(by_pixels[px], i)
+            else:
+                by_pixels[px] = i
+    if n >= 2:
+        ph = hex_to_u64([r["phash"] for r in rows])
+        dh = hex_to_u64([r["dhash"] for r in rows])
+        phf = hex_to_u64([r["phash_flip"] for r in rows])
+        dhf = hex_to_u64([r["dhash_flip"] for r in rows])
+        for i, j in near_duplicate_pairs(ph, dh, phf, dhf, phash_max, dhash_max):
+            uf.union(i, j)
+    return uf.groups()
+
+
+def keeper_rank(row: dict) -> tuple:
+    """Lower sorts first = preferred keeper."""
+    processed = 0 if row["status"] in _PROCESSED else 1
+    realworld = 0 if row.get("origin") == "realworld" else 1
+    pixels = (row.get("norm_width") or row.get("width") or 0) * (row.get("norm_height") or row.get("height") or 0)
+    return (processed, realworld, -pixels, -(row.get("filesize") or 0), row["image_id"])
+
+
+# ------------------------------------------------------------------------------------- stage
+def run(manifest: Manifest, cfg: dict, data_dir: Path) -> dict[str, int]:
+    """Hash new images, then discard exact/near duplicates across the whole candidate pool."""
+    dcfg = cfg["dedup"]
+    stats = {"hashed": 0, "exact_duplicate": 0, "near_duplicate": 0, "deduped": 0, "hash_failed": 0}
+
+    # 1. hashes for images that do not have them yet
+    fresh = [r for r in manifest.images(statuses=["normalized"]) if not r["phash"]]
+    if fresh:
+        def work(r: dict):
+            try:
+                return r, compute_hashes(data_dir / r["norm_path"]), None
+            except Exception as exc:  # noqa: BLE001
+                return r, None, exc
+
+        with ThreadPoolExecutor(max_workers=int(dcfg.get("hash_workers", 4))) as ex:
+            futures = [ex.submit(work, r) for r in fresh]
+            with manifest.transaction():
+                for fut in tqdm(as_completed(futures), total=len(futures), desc="hash", unit="img"):
+                    r, hashes, err = fut.result()
+                    if err is not None:
+                        log.warning("hashing failed for %s: %s", r["image_id"], err)
+                        manifest.discard(r["image_id"], "hash_failed")
+                        stats["hash_failed"] += 1
+                    else:
+                        manifest.update_image(r["image_id"], **hashes)
+                        stats["hashed"] += 1
+
+    # 2. group duplicates over the full candidate pool (new + previously processed)
+    rows = [r for r in manifest.images(statuses=_CANDIDATES) if r["phash"]]
+    groups = find_duplicate_groups(rows, int(dcfg["phash_max_dist"]), int(dcfg["dhash_max_dist"]))
+    log.info("dedup: %d candidates, %d duplicate group(s)", len(rows), len(groups))
+
+    discarded: set[str] = set()
+    cluster_of: dict[str, str] = {}  # cluster ids assigned during this run
+    with manifest.transaction():
+        for group in groups:
+            members = sorted((rows[i] for i in group), key=keeper_rank)
+            keeper, losers = members[0], members[1:]
+            # Reuse the keeper's existing cluster id: a previous semantic merge may have
+            # renamed it, and a rerun must never undo that.
+            cid = keeper["cluster_id"] or keeper["image_id"]
+            for member in members:
+                cluster_of[member["image_id"]] = cid
+                manifest.update_image(member["image_id"], cluster_id=cid)
+            for loser in losers:
+                exact = bool(loser["pixel_sha256"]) and loser["pixel_sha256"] == keeper["pixel_sha256"]
+                reason = "exact_duplicate" if exact else "near_duplicate"
+                if loser["status"] == "normalized":
+                    manifest.discard(loser["image_id"], reason, dup_of=keeper["image_id"])
+                    discarded.add(loser["image_id"])
+                    stats[reason] += 1
+                else:
+                    # An already-processed image is never removed retroactively (it may already
+                    # be annotated); it only joins the cluster so splits stay leak-free.
+                    log.warning("kept %s although it duplicates %s (already processed)",
+                                loser["image_id"], keeper["image_id"])
+        # Survivors advance; singletons get their own cluster id.
+        for r in rows:
+            if r["status"] != "normalized" or r["image_id"] in discarded:
+                continue
+            updates = {"status": "deduped"}
+            if not cluster_of.get(r["image_id"]) and not r["cluster_id"]:
+                updates["cluster_id"] = r["image_id"]
+            manifest.update_image(r["image_id"], **updates)
+            stats["deduped"] += 1
+    log.info("dedup: %s", stats)
+    return stats
+
+
+# ------------------------------------------------------------------------- semantic clustering
+def semantic_clusters(ids: list[str], emb: np.ndarray, threshold: float,
+                      existing: dict[str, str] | None = None, block_cells: int = 4_000_000) -> dict[str, str]:
+    """Merge images into clusters by embedding cosine >= threshold (and by existing cluster ids).
+
+    Returns image_id -> cluster id (the smallest image_id in the component, deterministic).
+    Assumes rows of ``emb`` are L2-normalized.
+    """
+    n = len(ids)
+    uf = UnionFind(n)
+    if existing:
+        first_seen: dict[str, int] = {}
+        for i, image_id in enumerate(ids):
+            cid = existing.get(image_id)
+            if cid:
+                if cid in first_seen:
+                    uf.union(first_seen[cid], i)
+                else:
+                    first_seen[cid] = i
+    if n >= 2:
+        block = max(1, block_cells // n)
+        cols = np.arange(n)
+        for a in range(0, n, block):
+            b = min(n, a + block)
+            sim = emb[a:b] @ emb.T
+            ii, jj = np.nonzero((sim >= threshold) & (cols[None, :] > np.arange(a, b)[:, None]))
+            for i, j in zip(ii + a, jj):
+                uf.union(int(i), int(j))
+    comp: dict[int, list[str]] = defaultdict(list)
+    for i, image_id in enumerate(ids):
+        comp[uf.find(i)].append(image_id)
+    return {image_id: min(members) for members in comp.values() for image_id in members}
+
+
+def run_semantic(manifest: Manifest, cfg: dict) -> dict[str, int]:
+    """Layer 3: merge cluster ids using stored CLIP embeddings (labels only, deletes nothing)."""
+    rows = manifest.images(statuses=["kept", "review"])
+    ids, emb = manifest.load_embeddings([r["image_id"] for r in rows])
+    if not ids:
+        log.warning("cluster: no embeddings found (run `filter` with CLIP first); skipping")
+        return {"clustered": 0, "merged_clusters": 0}
+    existing = {r["image_id"]: r["cluster_id"] or r["image_id"] for r in rows}
+    norms = np.linalg.norm(emb, axis=1, keepdims=True)
+    emb = emb / np.clip(norms, 1e-9, None)
+    new_ids = semantic_clusters(ids, emb, float(cfg["dedup"]["semantic_cosine"]), existing)
+
+    remap: dict[str, str] = {}
+    for image_id, new in new_ids.items():
+        old = existing[image_id]
+        if old != new:
+            remap[old] = new
+    with manifest.transaction():
+        # Update *all* rows (incl. discarded duplicates) that carry a merged cluster id.
+        for old, new in remap.items():
+            manifest.execute("UPDATE images SET cluster_id=? WHERE cluster_id=?", (new, old))
+        for image_id, new in new_ids.items():
+            if image_id not in remap and existing[image_id] != new:
+                manifest.update_image(image_id, cluster_id=new)
+    stats = {"clustered": len(ids), "merged_clusters": len(remap)}
+    log.info("cluster: %s", stats)
+    return stats

pipeline/manifest.py

@@ -0,0 +1,404 @@
+"""SQLite manifest: the single source of truth for provenance and pipeline state.
+
+Tables
+------
+sources       one row per (normalized) URL; download state
+hits          every (url, engine, query) that surfaced a URL -> class hints and provenance
+harvest_runs  completed (engine, query) harvests so reruns skip them
+images        one row per unique image (sha256 of original bytes) with all pipeline state
+embeddings    optional CLIP embeddings (float16 blobs)
+
+Image status flow
+-----------------
+downloaded -> validated -> normalized -> deduped -> kept | review | discarded
+Every stage only touches rows in its own input status, so all stages are idempotent
+and a rerun after an interruption never repeats finished work.
+"""
+from __future__ import annotations
+
+import json
+import sqlite3
+import threading
+from contextlib import contextmanager
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterable, Iterator
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+
+import numpy as np
+
+STATUSES = ("downloaded", "validated", "normalized", "deduped", "kept", "review", "discarded")
+
+SCHEMA = """
+PRAGMA journal_mode=WAL;
+PRAGMA synchronous=NORMAL;
+
+CREATE TABLE IF NOT EXISTS sources (
+    url_norm      TEXT PRIMARY KEY,
+    url           TEXT NOT NULL,
+    status        TEXT NOT NULL DEFAULT 'pending',
+    attempts      INTEGER NOT NULL DEFAULT 0,
+    http_status   INTEGER,
+    error         TEXT,
+    image_id      TEXT,
+    harvested_at  TEXT,
+    downloaded_at TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_sources_status ON sources(status);
+CREATE INDEX IF NOT EXISTS idx_sources_image  ON sources(image_id);
+
+CREATE TABLE IF NOT EXISTS hits (
+    url_norm     TEXT NOT NULL,
+    engine       TEXT NOT NULL,
+    query        TEXT NOT NULL,
+    class_hint   TEXT,
+    lang         TEXT,
+    harvested_at TEXT,
+    PRIMARY KEY (url_norm, engine, query)
+);
+
+CREATE TABLE IF NOT EXISTS harvest_runs (
+    engine      TEXT NOT NULL,
+    query       TEXT NOT NULL,
+    class_hint  TEXT,
+    max_num     INTEGER,
+    urls_found  INTEGER,
+    urls_new    INTEGER,
+    finished_at TEXT,
+    PRIMARY KEY (engine, query)
+);
+
+CREATE TABLE IF NOT EXISTS images (
+    image_id         TEXT PRIMARY KEY,
+    sha256           TEXT NOT NULL,
+    origin           TEXT NOT NULL DEFAULT 'web',
+    source_ref       TEXT,
+    orig_path        TEXT,
+    orig_format      TEXT,
+    filesize         INTEGER,
+    width            INTEGER,
+    height           INTEGER,
+    aspect_ratio     REAL,
+    norm_path        TEXT,
+    norm_width       INTEGER,
+    norm_height      INTEGER,
+    pixel_sha256     TEXT,
+    phash            TEXT,
+    dhash            TEXT,
+    phash_flip       TEXT,
+    dhash_flip       TEXT,
+    flags            TEXT NOT NULL DEFAULT '[]',
+    status           TEXT NOT NULL,
+    discard_reason   TEXT,
+    dup_of           TEXT,
+    cluster_id       TEXT,
+    clip_score       REAL,
+    relevance_bucket TEXT,
+    board_type       TEXT,
+    condition        TEXT,
+    source_type      TEXT,
+    review_status    TEXT,
+    reviewer         TEXT,
+    reviewed_at      TEXT,
+    split            TEXT,
+    session_id       TEXT,
+    board_id         TEXT,
+    created_at       TEXT,
+    updated_at       TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_images_status  ON images(status);
+CREATE INDEX IF NOT EXISTS idx_images_cluster ON images(cluster_id);
+CREATE INDEX IF NOT EXISTS idx_images_dup_of  ON images(dup_of);
+
+CREATE TABLE IF NOT EXISTS embeddings (
+    image_id TEXT PRIMARY KEY,
+    dim      INTEGER NOT NULL,
+    vec      BLOB NOT NULL
+);
+"""
+
+IMAGE_COLUMNS = {
+    "image_id", "sha256", "origin", "source_ref", "orig_path", "orig_format", "filesize", "width",
+    "height", "aspect_ratio", "norm_path", "norm_width", "norm_height", "pixel_sha256", "phash",
+    "dhash", "phash_flip", "dhash_flip", "flags", "status", "discard_reason", "dup_of", "cluster_id",
+    "clip_score", "relevance_bucket", "board_type", "condition", "source_type", "review_status",
+    "reviewer", "reviewed_at", "split", "session_id", "board_id", "created_at", "updated_at",
+}
+
+_TRACKING_PARAMS = {"fbclid", "gclid", "msclkid", "yclid"}
+_DEFAULT_PORTS = {"http": 80, "https": 443}
+
+
+def utcnow() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+def normalize_url(url: str) -> str:
+    """Canonical form used as the dedup key for URLs (case, default ports, fragment, tracking)."""
+    parts = urlsplit(url.strip())
+    scheme = parts.scheme.lower()
+    host = (parts.hostname or "").lower()
+    try:
+        port = parts.port
+    except ValueError:
+        port = None
+    netloc = host
+    if port and port != _DEFAULT_PORTS.get(scheme):
+        netloc = f"{host}:{port}"
+    query = sorted(
+        (k, v) for k, v in parse_qsl(parts.query, keep_blank_values=True)
+        if not k.lower().startswith("utm_") and k.lower() not in _TRACKING_PARAMS
+    )
+    return urlunsplit((scheme, netloc, parts.path or "/", urlencode(query), ""))
+
+
+def _check_columns(fields: Iterable[str]) -> None:
+    bad = set(fields) - IMAGE_COLUMNS
+    if bad:
+        raise KeyError(f"unknown image column(s): {sorted(bad)}")
+
+
+class Manifest:
+    """Thread-safe SQLite wrapper (one connection, serialized by an RLock)."""
+
+    def __init__(self, db_path: str | Path):
+        self.db_path = Path(db_path)
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._conn = sqlite3.connect(str(self.db_path), check_same_thread=False,
+                                     isolation_level=None, timeout=60)
+        self._conn.row_factory = sqlite3.Row
+        self._lock = threading.RLock()
+        self._tx_depth = 0
+        with self._lock:
+            self._conn.executescript(SCHEMA)
+
+    # -- infrastructure -----------------------------------------------------------------
+    def close(self) -> None:
+        with self._lock:
+            self._conn.close()
+
+    def __enter__(self) -> "Manifest":
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.close()
+
+    @contextmanager
+    def transaction(self) -> Iterator[None]:
+        """Group many writes into one commit (re-entrant)."""
+        with self._lock:
+            outer = self._tx_depth == 0
+            if outer:
+                self._conn.execute("BEGIN")
+            self._tx_depth += 1
+            try:
+                yield
+            except BaseException:
+                self._tx_depth -= 1
+                if outer:
+                    self._conn.execute("ROLLBACK")
+                raise
+            else:
+                self._tx_depth -= 1
+                if outer:
+                    self._conn.execute("COMMIT")
+
+    def execute(self, sql: str, params: Iterable[Any] = ()) -> sqlite3.Cursor:
+        with self._lock:
+            return self._conn.execute(sql, tuple(params))
+
+    def query(self, sql: str, params: Iterable[Any] = ()) -> list[sqlite3.Row]:
+        with self._lock:
+            return self._conn.execute(sql, tuple(params)).fetchall()
+
+    # -- sources / hits -------------------------------------------------------------------
+    def add_hit(self, url: str, engine: str, query: str, class_hint: str | None = None,
+                lang: str | None = None) -> bool:
+        """Record a harvested URL. Returns True if the URL was new."""
+        url_norm = normalize_url(url)
+        now = utcnow()
+        with self._lock:
+            cur = self._conn.execute(
+                "INSERT OR IGNORE INTO sources(url_norm, url, status, harvested_at) "
+                "VALUES (?, ?, 'pending', ?)", (url_norm, url, now))
+            is_new = cur.rowcount == 1
+            self._conn.execute(
+                "INSERT OR IGNORE INTO hits(url_norm, engine, query, class_hint, lang, harvested_at) "
+                "VALUES (?, ?, ?, ?, ?, ?)", (url_norm, engine, query, class_hint, lang, now))
+        return is_new
+
+    def pending_sources(self, limit: int | None = None, include_transient: bool = False) -> list[dict]:
+        statuses = ("pending", "failed_transient") if include_transient else ("pending",)
+        sql = f"SELECT * FROM sources WHERE status IN ({','.join('?' * len(statuses))}) ORDER BY harvested_at, url_norm"
+        params: list[Any] = list(statuses)
+        if limit:
+            sql += " LIMIT ?"
+            params.append(limit)
+        return [dict(r) for r in self.query(sql, params)]
+
+    def mark_source(self, url_norm: str, status: str, http_status: int | None = None,
+                    error: str | None = None, image_id: str | None = None, attempts: int = 0) -> None:
+        self.execute(
+            "UPDATE sources SET status=?, http_status=?, error=?, image_id=?, "
+            "attempts=attempts+?, downloaded_at=? WHERE url_norm=?",
+            (status, http_status, error, image_id, attempts, utcnow(), url_norm))
+
+    # -- harvest runs ---------------------------------------------------------------------
+    def run_done(self, engine: str, query: str) -> bool:
+        return bool(self.query("SELECT 1 FROM harvest_runs WHERE engine=? AND query=?", (engine, query)))
+
+    def record_run(self, engine: str, query: str, class_hint: str | None, max_num: int,
+                   found: int, new: int) -> None:
+        self.execute(
+            "INSERT OR REPLACE INTO harvest_runs VALUES (?, ?, ?, ?, ?, ?, ?)",
+            (engine, query, class_hint, max_num, found, new, utcnow()))
+
+    # -- images ----------------------------------------------------------------------------
+    def add_image(self, **fields: Any) -> bool:
+        """Insert an image row if its image_id is new. Returns True if inserted."""
+        _check_columns(fields)
+        fields.setdefault("origin", "web")
+        now = utcnow()
+        fields.setdefault("created_at", now)
+        fields.setdefault("updated_at", now)
+        if isinstance(fields.get("flags"), (list, tuple, set)):
+            fields["flags"] = json.dumps(sorted(fields["flags"]))
+        cols = list(fields)
+        cur = self.execute(
+            f"INSERT OR IGNORE INTO images({','.join(cols)}) VALUES ({','.join('?' * len(cols))})",
+            [fields[c] for c in cols])
+        return cur.rowcount == 1
+
+    @staticmethod
+    def _row(row: sqlite3.Row | None) -> dict | None:
+        if row is None:
+            return None
+        d = dict(row)
+        d["flags"] = json.loads(d.get("flags") or "[]")
+        return d
+
+    def get_image(self, image_id: str) -> dict | None:
+        rows = self.query("SELECT * FROM images WHERE image_id=?", (image_id,))
+        return self._row(rows[0]) if rows else None
+
+    def images(self, statuses: Iterable[str] | None = None, origin: str | None = None,
+               where: str | None = None, params: Iterable[Any] = ()) -> list[dict]:
+        clauses, args = [], []
+        if statuses:
+            statuses = tuple(statuses)
+            clauses.append(f"status IN ({','.join('?' * len(statuses))})")
+            args += list(statuses)
+        if origin:
+            clauses.append("origin=?")
+            args.append(origin)
+        if where:
+            clauses.append(f"({where})")
+            args += list(params)
+        sql = "SELECT * FROM images" + (" WHERE " + " AND ".join(clauses) if clauses else "")
+        sql += " ORDER BY image_id"
+        return [self._row(r) for r in self.query(sql, args)]
+
+    def update_image(self, image_id: str, **fields: Any) -> None:
+        _check_columns(fields)
+        if not fields:
+            return
+        if isinstance(fields.get("flags"), (list, tuple, set)):
+            fields["flags"] = json.dumps(sorted(fields["flags"]))
+        fields["updated_at"] = utcnow()
+        sets = ", ".join(f"{c}=?" for c in fields)
+        self.execute(f"UPDATE images SET {sets} WHERE image_id=?", [*fields.values(), image_id])
+
+    def add_flags(self, image_id: str, *new_flags: str) -> None:
+        img = self.get_image(image_id)
+        if img is None:
+            return
+        merged = sorted(set(img["flags"]) | set(new_flags))
+        self.update_image(image_id, flags=merged)
+
+    def discard(self, image_id: str, reason: str, dup_of: str | None = None) -> None:
+        self.update_image(image_id, status="discarded", discard_reason=reason, dup_of=dup_of)
+
+    def count_by(self, column: str, where: str = "1=1", params: Iterable[Any] = ()) -> dict[str, int]:
+        _check_columns([column])
+        rows = self.query(
+            f"SELECT {column} AS k, COUNT(*) AS n FROM images WHERE {where} GROUP BY {column}", params)
+        return {(r["k"] if r["k"] is not None else "none"): r["n"] for r in rows}
+
+    # -- provenance ----------------------------------------------------------------------
+    def class_hints_by_image(self) -> dict[str, set[str]]:
+        """image_id -> class hints, folding duplicates (dup_of) into their keeper."""
+        rows = self.query(
+            "SELECT s.image_id AS image_id, h.class_hint AS class_hint "
+            "FROM sources s JOIN hits h ON h.url_norm = s.url_norm "
+            "WHERE s.image_id IS NOT NULL AND h.class_hint IS NOT NULL")
+        direct: dict[str, set[str]] = {}
+        for r in rows:
+            direct.setdefault(r["image_id"], set()).add(r["class_hint"])
+        result = {k: set(v) for k, v in direct.items()}
+        for r in self.query("SELECT image_id, dup_of FROM images WHERE dup_of IS NOT NULL"):
+            if r["image_id"] in direct:
+                result.setdefault(r["dup_of"], set()).update(direct[r["image_id"]])
+        return result
+
+    def provenance(self, image_id: str) -> dict[str, list[str]]:
+        """Source URLs, queries, engines and class hints for an image incl. its duplicates."""
+        rows = self.query(
+            "SELECT s.url AS url, h.engine AS engine, h.query AS query, h.class_hint AS class_hint "
+            "FROM sources s LEFT JOIN hits h ON h.url_norm = s.url_norm "
+            "WHERE s.image_id IN (SELECT ? UNION SELECT image_id FROM images WHERE dup_of = ?)",
+            (image_id, image_id))
+        out: dict[str, set[str]] = {"source_urls": set(), "engines": set(), "queries": set(),
+                                    "class_hints": set()}
+        for r in rows:
+            out["source_urls"].add(r["url"])
+            if r["engine"]:
+                out["engines"].add(r["engine"])
+            if r["query"]:
+                out["queries"].add(r["query"])
+            if r["class_hint"]:
+                out["class_hints"].add(r["class_hint"])
+        return {k: sorted(v) for k, v in out.items()}
+
+    def valid_counts_by_class(self, valid_statuses: Iterable[str] = ("deduped", "kept", "validated", "normalized")) -> dict[str, int]:
+        """Return a mapping of class_hint -> count of valid (non-discarded) images."""
+        statuses = tuple(valid_statuses)
+        sql = f"""
+            SELECT h.class_hint, COUNT(DISTINCT i.image_id)
+            FROM images i
+            JOIN sources s ON i.source_ref = s.url_norm OR i.image_id = s.image_id
+            JOIN hits h ON s.url_norm = h.url_norm
+            WHERE i.status IN ({','.join('?' * len(statuses))})
+            GROUP BY h.class_hint
+        """
+        rows = self.query(sql, statuses)
+        return {r[0]: r[1] for r in rows if r[0]}
+
+    def export_jsonl(self, path: str | Path) -> int:
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        n = 0
+        with open(path, "w", encoding="utf-8") as fh:
+            for img in self.images():
+                img.update(self.provenance(img["image_id"]))
+                fh.write(json.dumps(img, ensure_ascii=False) + "\n")
+                n += 1
+        return n
+
+    # -- embeddings ----------------------------------------------------------------------
+    def save_embeddings(self, vectors: dict[str, np.ndarray]) -> None:
+        with self.transaction():
+            for image_id, vec in vectors.items():
+                arr = np.asarray(vec, dtype=np.float16)
+                self.execute("INSERT OR REPLACE INTO embeddings VALUES (?, ?, ?)",
+                             (image_id, int(arr.shape[0]), arr.tobytes()))
+
+    def load_embeddings(self, image_ids: Iterable[str] | None = None) -> tuple[list[str], np.ndarray]:
+        rows = self.query("SELECT image_id, dim, vec FROM embeddings ORDER BY image_id")
+        if image_ids is not None:
+            wanted = set(image_ids)
+            rows = [r for r in rows if r["image_id"] in wanted]
+        if not rows:
+            return [], np.zeros((0, 0), dtype=np.float32)
+        ids = [r["image_id"] for r in rows]
+        mat = np.stack([np.frombuffer(r["vec"], dtype=np.float16).astype(np.float32) for r in rows])
+        return ids, mat

pipeline/processor.py

@@ -0,0 +1,145 @@
+"""Normalization engine: turn any validated original into a standard RGB JPEG.
+
+Order matters and follows the plan:
+
+  1. EXIF transpose first (phone photos would otherwise end up rotated).
+  2. Colour handling to RGB:
+       - RGBA / LA / PA / palette-with-transparency -> composited on WHITE
+         (a naive convert("RGB") turns transparent pixels black)
+       - CMYK -> sRGB through the embedded ICC profile when there is one
+       - RGB with a non-sRGB ICC profile -> converted to sRGB when possible
+       - grayscale / 1-bit / 16-bit -> RGB
+  3. Downscale (never upscale) if the long side exceeds ``max_long_side`` (LANCZOS).
+  4. Encode as JPEG q95, 4:4:4 chroma (subsampling=0), optimized, metadata stripped.
+
+Originals are never modified; this only ever writes a derived copy.
+"""
+from __future__ import annotations
+
+import hashlib
+import io
+import logging
+import os
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+from PIL import Image, ImageCms, ImageOps
+from tqdm import tqdm
+
+from .manifest import Manifest
+from .validator import register_heif
+
+log = logging.getLogger(__name__)
+register_heif()
+
+Image.MAX_IMAGE_PIXELS = None  # size is already policed by the validator
+
+
+@dataclass
+class NormalizeResult:
+    width: int
+    height: int
+    pixel_sha256: str
+
+
+def _icc_to_srgb(img: Image.Image) -> Image.Image:
+    """Convert to sRGB via the embedded ICC profile; fall back to a plain convert."""
+    icc = img.info.get("icc_profile")
+    if not icc:
+        return img.convert("RGB")
+    try:
+        src = ImageCms.ImageCmsProfile(io.BytesIO(icc))
+        if img.mode == "RGB" and "srgb" in ImageCms.getProfileDescription(src).lower():
+            return img
+        dst = ImageCms.createProfile("sRGB")
+        return ImageCms.profileToProfile(img, src, dst, outputMode="RGB")
+    except Exception:
+        return img.convert("RGB")
+
+
+def _wide_mode_to_rgb(img: Image.Image) -> Image.Image:
+    """16-bit / int / float single-channel images -> 8-bit RGB with min/max scaling."""
+    arr = np.asarray(img, dtype=np.float64)
+    lo, hi = float(arr.min()), float(arr.max())
+    scaled = np.zeros_like(arr) if hi <= lo else (arr - lo) / (hi - lo) * 255.0
+    return Image.fromarray(scaled.astype(np.uint8), mode="L").convert("RGB")
+
+
+def to_rgb(img: Image.Image) -> Image.Image:
+    mode = img.mode
+    if mode in ("RGBA", "LA", "PA", "RGBa", "La") or (mode == "P" and "transparency" in img.info):
+        rgba = img.convert("RGBA")
+        background = Image.new("RGBA", rgba.size, (255, 255, 255, 255))
+        return Image.alpha_composite(background, rgba).convert("RGB")
+    if mode == "CMYK":
+        return _icc_to_srgb(img)
+    if mode in ("I", "I;16", "I;16L", "I;16B", "F"):
+        return _wide_mode_to_rgb(img)
+    if mode == "RGB":
+        return _icc_to_srgb(img) if img.info.get("icc_profile") else img
+    return img.convert("RGB")  # L, 1, P (opaque), YCbCr, LAB, HSV, ...
+
+
+def normalize_image(src: str | Path, dst: str | Path, pcfg: dict) -> NormalizeResult:
+    src, dst = Path(src), Path(dst)
+    with Image.open(src) as opened:
+        opened.seek(0)  # first frame of animated files
+        img = ImageOps.exif_transpose(opened)
+        img.load()
+        img = to_rgb(img)
+
+    max_long = int(pcfg.get("max_long_side", 2560))
+    long_side = max(img.size)
+    if max_long and long_side > max_long:
+        scale = max_long / long_side
+        new_size = (max(1, round(img.width * scale)), max(1, round(img.height * scale)))
+        img = img.resize(new_size, Image.Resampling.LANCZOS)
+
+    digest = hashlib.sha256(f"{img.width}x{img.height}".encode() + img.tobytes()).hexdigest()
+
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    tmp = dst.with_name(dst.name + f".{os.getpid()}.tmp")
+    try:
+        img.save(tmp, format="JPEG", quality=int(pcfg.get("jpeg_quality", 95)),
+                 subsampling=int(pcfg.get("jpeg_subsampling", 0)), optimize=True)
+        os.replace(tmp, dst)  # atomic: a crash never leaves a half-written JPEG
+    finally:
+        if tmp.exists():
+            tmp.unlink()
+    return NormalizeResult(img.width, img.height, digest)
+
+
+def run(manifest: Manifest, cfg: dict, data_dir: Path, images_dir: Path) -> dict[str, int]:
+    """Normalize every image in status 'validated'."""
+    pcfg = cfg["process"]
+    todo = manifest.images(statuses=["validated"])
+    stats = {"normalized": 0, "normalize_failed": 0}
+    if not todo:
+        log.info("process: nothing to do")
+        return stats
+
+    def work(img: dict):
+        dst = images_dir / f"{img['image_id']}.jpg"
+        try:
+            return img, normalize_image(data_dir / img["orig_path"], dst, pcfg), dst, None
+        except Exception as exc:  # noqa: BLE001 - any decode/encode failure discards the image
+            return img, None, dst, exc
+
+    with ThreadPoolExecutor(max_workers=int(pcfg.get("workers", 4))) as ex:
+        futures = [ex.submit(work, img) for img in todo]
+        with manifest.transaction():
+            for fut in tqdm(as_completed(futures), total=len(futures), desc="process", unit="img"):
+                img, res, dst, err = fut.result()
+                if err is None and res is not None:
+                    manifest.update_image(
+                        img["image_id"], status="normalized", norm_path=str(dst.relative_to(data_dir)),
+                        norm_width=res.width, norm_height=res.height, pixel_sha256=res.pixel_sha256)
+                    stats["normalized"] += 1
+                else:
+                    log.warning("normalize failed for %s: %s", img["image_id"], err)
+                    manifest.discard(img["image_id"], "normalize_failed")
+                    stats["normalize_failed"] += 1
+    log.info("process: %s", stats)
+    return stats

pipeline/queries.py

@@ -0,0 +1,77 @@
+"""Query registry: expand seed terms along diversity axes (deterministically)."""
+from __future__ import annotations
+
+import random
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class QuerySpec:
+    class_hint: str
+    query: str
+    lang: str = "en"
+    kind: str = "seed"  # seed | expanded | lang
+
+
+def _overlap(phrase: str, words: set[str]) -> float:
+    toks = phrase.lower().split()
+    return sum(t in words for t in toks) / len(toks) if toks else 1.0
+
+
+def build_queries(
+    qcfg: dict,
+    classes: list[str] | None = None,
+    langs: list[str] | None = None,
+) -> list[QuerySpec]:
+    """Build the full query list.
+
+    For every seed term: the seed itself plus up to ``max_variants_per_seed`` variants that
+    append one or two randomly chosen axis values (board type, condition, view/setting).
+    A class may override any axis (e.g. ``desoldered_zone`` never pairs with "intact").
+    Multilingual terms are hand-written per class and appended as-is.
+
+    Output order and content are fully determined by ``expansion.seed``.
+    """
+    exp = qcfg.get("expansion", {}) or {}
+    rng = random.Random(exp.get("seed", 7))
+    per_seed = int(exp.get("max_variants_per_seed", 8))
+    global_axes = qcfg.get("axes", {}) or {}
+
+    out: list[QuerySpec] = []
+    seen: set[tuple[str, str]] = set()
+
+    def add(spec: QuerySpec) -> None:
+        key = (spec.class_hint, spec.query.strip().lower())
+        if key not in seen and spec.query.strip():
+            seen.add(key)
+            out.append(spec)
+
+    for cls, body in (qcfg.get("classes") or {}).items():
+        if classes and cls not in classes:
+            continue
+        body = body or {}
+        axes = {**global_axes, **(body.get("axes") or {})}
+        axis_names = sorted(a for a, vals in axes.items() if vals)
+
+        for seed in body.get("seeds", []) or []:
+            add(QuerySpec(cls, seed, "en", "seed"))
+            seed_words = set(seed.lower().split())
+            variants: set[str] = set()
+            attempts = 0
+            while axis_names and len(variants) < per_seed and attempts < per_seed * 10:
+                attempts += 1
+                chosen = rng.sample(axis_names, min(rng.choice([1, 2]), len(axis_names)))
+                parts = [rng.choice(axes[a]) for a in sorted(chosen)]
+                # Skip axis values the seed already (mostly) says, e.g. "close up" + "close up macro".
+                parts = [p for p in parts if _overlap(p, seed_words) < 0.5]
+                if parts:
+                    variants.add(f"{seed} {' '.join(parts)}")
+            for v in sorted(variants):
+                add(QuerySpec(cls, v, "en", "expanded"))
+
+        for lang, terms in (body.get("multilingual") or {}).items():
+            if langs and lang not in langs:
+                continue
+            for term in terms or []:
+                add(QuerySpec(cls, term, lang, "lang"))
+    return out

pipeline/splitter.py

@@ -0,0 +1,129 @@
+"""Dataset Splitter Engine.
+
+Stratified, cluster-aware train / val / test dataset partitioning:
+- Prevents data leakage by ensuring all images in the same visual `cluster_id`
+  are assigned to the SAME split (train, val, or test).
+- Maintains balanced class distributions across splits according to target ratios (e.g. 70 / 15 / 15).
+- Exports organized image & label directories under `data/splits/` for YOLOv8 model training.
+"""
+from __future__ import annotations
+
+import logging
+import random
+import shutil
+from collections import defaultdict
+from pathlib import Path
+from typing import Sequence
+
+from .manifest import Manifest
+
+log = logging.getLogger(__name__)
+
+
+def create_cluster_splits(
+    manifest: Manifest,
+    train_ratio: float = 0.70,
+    val_ratio: float = 0.15,
+    test_ratio: float = 0.15,
+    seed: int = 42,
+) -> dict[str, list[dict]]:
+    """Partition valid images into cluster-isolated train/val/test splits."""
+    random.seed(seed)
+
+    rows = manifest.images(statuses=["deduped", "kept", "validated", "normalized"])
+    if not rows:
+        log.warning("splitter: no valid images found to split")
+        return {"train": [], "val": [], "test": []}
+
+    clusters: dict[str, list[dict]] = defaultdict(list)
+    for r in rows:
+        cid = r["cluster_id"] or r["image_id"]
+        clusters[cid].append(r)
+
+    cluster_items = list(clusters.items())
+    random.shuffle(cluster_items)
+
+    total_count = len(rows)
+    target_train = int(total_count * train_ratio)
+    target_val = int(total_count * val_ratio)
+
+    splits: dict[str, list[dict]] = {"train": [], "val": [], "test": []}
+
+    current_train = 0
+    current_val = 0
+
+    for cid, members in cluster_items:
+        mem_len = len(members)
+        if current_train < target_train:
+            splits["train"].extend(members)
+            current_train += mem_len
+        elif current_val < target_val:
+            splits["val"].extend(members)
+            current_val += mem_len
+        else:
+            splits["test"].extend(members)
+
+    return splits
+
+
+def run(
+    manifest: Manifest,
+    cfg: dict,
+    data_dir: Path,
+    splits_dir: Path,
+    train_ratio: float = 0.70,
+    val_ratio: float = 0.15,
+    test_ratio: float = 0.15,
+    copy_files: bool = True,
+    seed: int = 42,
+) -> dict[str, int]:
+    """Execute cluster-isolated dataset split and write image & label files to splits directory."""
+    splits = create_cluster_splits(
+        manifest, train_ratio=train_ratio, val_ratio=val_ratio, test_ratio=test_ratio, seed=seed
+    )
+
+    stats = {
+        "train": len(splits["train"]),
+        "val": len(splits["val"]),
+        "test": len(splits["test"]),
+        "total_split": sum(len(s) for s in splits.values()),
+    }
+
+    if not stats["total_split"]:
+        log.warning("splitter: 0 images split")
+        return stats
+
+    with manifest.transaction():
+        for split_name, members in splits.items():
+            for m in members:
+                manifest.update_image(m["image_id"], split=split_name)
+
+    auto_labels_dir = data_dir / "annotated_auto" / "labels"
+
+    if copy_files:
+        for split_name, members in splits.items():
+            dst_img_dir = splits_dir / split_name / "images"
+            dst_lbl_dir = splits_dir / split_name / "labels"
+            dst_img_dir.mkdir(parents=True, exist_ok=True)
+            dst_lbl_dir.mkdir(parents=True, exist_ok=True)
+
+            for m in members:
+                src_rel = m.get("norm_path") or m.get("orig_path")
+                if not src_rel:
+                    continue
+                src_path = data_dir / src_rel
+                if src_path.exists():
+                    dst_path = dst_img_dir / src_path.name
+                    if not dst_path.exists():
+                        shutil.copy2(src_path, dst_path)
+
+                    # Copy matching label file if available
+                    label_name = f"{src_path.stem}.txt"
+                    src_label = auto_labels_dir / label_name
+                    if src_label.exists():
+                        dst_label = dst_lbl_dir / label_name
+                        if not dst_label.exists():
+                            shutil.copy2(src_label, dst_label)
+
+    log.info("splitter split summary: %s", stats)
+    return stats

pipeline/validator.py

@@ -0,0 +1,159 @@
+"""Validation engine.
+
+Checks run cheapest-first so most bad files fail early:
+
+  1. file size            < min_file_bytes                    -> discard  too_small_file
+  2. integrity            open -> verify() -> reopen -> load() -> discard  corrupt
+  3. animated             multi-frame GIF/WEBP/APNG            -> flag     animated (first frame used)
+  4. resolution           short/long side below minimum       -> discard  low_resolution
+  5. aspect (hard)        > hard_aspect : 1                   -> discard  extreme_aspect_hard
+  6. aspect (soft)        > flag_aspect : 1                   -> flag     extreme_aspect (goes to review)
+
+`verify()` alone does not detect truncated JPEGs, so the file is reopened and fully decoded
+with `load()` (verify() invalidates the image object, hence the reopen).
+The soft aspect limit is a *flag*, not a discard: RAM modules and edge-finger strips are
+naturally ~4.5-5:1 and must survive.
+"""
+from __future__ import annotations
+
+import logging
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from PIL import Image, ImageFile
+from tqdm import tqdm
+
+from .manifest import Manifest
+
+log = logging.getLogger(__name__)
+
+ImageFile.LOAD_TRUNCATED_IMAGES = False  # never silently accept truncated files
+# Pillow's own bomb check works through process-global warnings (not thread-safe), so it is
+# disabled and replaced by an explicit header-size check in validate_image().
+Image.MAX_IMAGE_PIXELS = None
+
+ALLOWED_FORMATS = {"JPEG", "MPO", "PNG", "WEBP", "GIF", "BMP", "TIFF"}
+
+
+def register_heif() -> bool:
+    """Enable iPhone HEIC/HEIF photos if the optional `pillow-heif` package is installed."""
+    try:
+        import pillow_heif  # type: ignore
+
+        pillow_heif.register_heif_opener()
+        ALLOWED_FORMATS.add("HEIF")
+        return True
+    except Exception:  # pragma: no cover - optional dependency
+        return False
+
+
+register_heif()
+
+
+@dataclass
+class ValidationResult:
+    ok: bool
+    reason: str | None = None
+    flags: list[str] = field(default_factory=list)
+    width: int | None = None
+    height: int | None = None
+    fmt: str | None = None
+    aspect: float | None = None
+
+
+DEFAULT_AI_KEYWORDS = {
+    "midjourney", "stable diffusion", "dall-e", "dalle", "comfyui",
+    "novelai", "c2pa", "firefly", "bing image creator", "flux.1",
+    "fooocus", "automatic1111", "ai_generated", "generated by"
+}
+
+
+def check_ai_metadata(img: Image.Image, custom_keywords: list[str] | set[str] | None = None) -> bool:
+    """Return True if image metadata contains AI generator signatures."""
+    keywords = set(custom_keywords) if custom_keywords else DEFAULT_AI_KEYWORDS
+    info = getattr(img, "info", {})
+    if not isinstance(info, dict):
+        return False
+    raw_str = " ".join(f"{k} {v}" for k, v in info.items()).lower()
+    return any(kw.lower() in raw_str for kw in keywords)
+
+
+def validate_image(path: str | Path, vcfg: dict) -> ValidationResult:
+    path = Path(path)
+    try:
+        size = path.stat().st_size
+    except OSError:
+        return ValidationResult(False, "missing_file")
+    if size < int(vcfg["min_file_bytes"]):
+        return ValidationResult(False, "too_small_file")
+
+    max_pixels = int(vcfg.get("max_pixels", 120_000_000))
+    flags: list[str] = []
+    try:
+        with Image.open(path) as img:  # lazy: reads the header only
+            if img.width * img.height > max_pixels:
+                return ValidationResult(False, "decompression_bomb", width=img.width, height=img.height)
+            img.verify()
+        with Image.open(path) as img:  # reopen: verify() leaves the object unusable
+            fmt = img.format
+            if fmt not in ALLOWED_FORMATS:
+                return ValidationResult(False, "unsupported_format", fmt=fmt)
+            animated = bool(getattr(img, "is_animated", False))
+            img.load()  # full decode -> catches truncation that verify() misses
+            width, height = img.size
+
+            if check_ai_metadata(img, vcfg.get("ai_keywords")):
+                return ValidationResult(False, "ai_generated_metadata", width=width, height=height, fmt=fmt)
+    except Exception:  # OSError, SyntaxError, ValueError, struct errors, ...
+        return ValidationResult(False, "corrupt")
+
+    if animated:
+        flags.append("animated")
+
+    short, long_ = min(width, height), max(width, height)
+    if short < int(vcfg["min_short_side"]) or long_ < int(vcfg["min_long_side"]):
+        return ValidationResult(False, "low_resolution", flags, width, height, fmt)
+
+    aspect = long_ / short if short else float("inf")
+    if aspect > float(vcfg["hard_aspect"]):
+        return ValidationResult(False, "extreme_aspect_hard", flags, width, height, fmt, aspect)
+    if aspect > float(vcfg["flag_aspect"]):
+        flags.append("extreme_aspect")
+
+    return ValidationResult(True, None, flags, width, height, fmt, round(aspect, 4))
+
+
+def run(manifest: Manifest, cfg: dict, data_dir: Path, force: bool = False) -> dict[str, int]:
+    """Validate images. If force=True, re-checks previously validated/normalized images for AI metadata."""
+    vcfg = cfg["validate"]
+    statuses = ["downloaded", "validated", "normalized", "kept"] if force else ["downloaded"]
+    todo = manifest.images(statuses=statuses)
+    stats: dict[str, int] = {"validated": 0}
+    if not todo:
+        log.info("validate: nothing to do")
+        return stats
+
+    def work(img: dict) -> tuple[dict, ValidationResult]:
+        return img, validate_image(data_dir / img["orig_path"], vcfg)
+
+    workers = int(vcfg.get("workers", 4))
+    with ThreadPoolExecutor(max_workers=workers) as ex:
+        futures = [ex.submit(work, img) for img in todo]
+        with manifest.transaction():
+            for fut in tqdm(as_completed(futures), total=len(futures), desc="validate", unit="img"):
+                img, res = fut.result()
+                if res.ok:
+                    flags = sorted(set(img["flags"]) | set(res.flags))
+                    manifest.update_image(
+                        img["image_id"], status="validated", width=res.width, height=res.height,
+                        aspect_ratio=res.aspect, orig_format=(res.fmt or "").lower(), flags=flags)
+                    stats["validated"] += 1
+                else:
+                    manifest.update_image(
+                        img["image_id"], status="discarded", discard_reason=res.reason,
+                        width=res.width, height=res.height, aspect_ratio=res.aspect,
+                        flags=sorted(set(img["flags"]) | set(res.flags)))
+                    stats[res.reason or "discarded"] = stats.get(res.reason or "discarded", 0) + 1
+    log.info("validate: %s", stats)
+    return stats

purity_engine/__init__.py

@@ -0,0 +1,17 @@
+"""Purity Engine Package for Edge PCB Component Purity & Cannibalization Index."""
+
+from .model_client import BaseModelClient, MockModelClient, Detection
+from .purity_assay import calculate_board_integrity_score, calculate_adjusted_scrap_price, AssayedBoard
+from .vernacular_voice import generate_vernacular_voice_alert
+from .pcb_analyzer import PCBAnalyzer
+
+__all__ = [
+    "BaseModelClient",
+    "MockModelClient",
+    "Detection",
+    "calculate_board_integrity_score",
+    "calculate_adjusted_scrap_price",
+    "AssayedBoard",
+    "generate_vernacular_voice_alert",
+    "PCBAnalyzer",
+]