| |
| """Build a vision-language cannabis strain dataset with local images.""" |
| from __future__ import annotations |
|
|
| import csv |
| import json |
| import sys |
| from collections import Counter |
| from pathlib import Path |
| from typing import Dict, Iterable, List, Sequence, Tuple |
| from urllib.parse import urlparse |
| from urllib.request import Request, urlopen |
|
|
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| DATA_DIR = ROOT / "data" |
| LEAFLY_PATH = DATA_DIR / "leafly_strain_data.csv" |
| OUTPUT_DIR = DATA_DIR / "canna-corpus-vision" |
| IMAGE_DIR = OUTPUT_DIR / "images" |
| METADATA_PATH = OUTPUT_DIR / "metadata.jsonl" |
|
|
|
|
| def clean_text(value: str | None) -> str: |
| """Normalize whitespace.""" |
| if not value: |
| return "" |
| return " ".join(value.replace("\xa0", " ").split()) |
|
|
|
|
| def slugify(value: str) -> str: |
| """Convert strain name into a filesystem-friendly slug.""" |
| slug = value.lower() |
| cleaned: List[str] = [] |
| for segment in slug.split(): |
| segment = "".join(ch for ch in segment if ch.isalnum() or ch == "-") |
| if segment: |
| cleaned.append(segment) |
| slug = "-".join(cleaned) |
| return slug or "item" |
|
|
|
|
| def collect_ranked_items( |
| row: Dict[str, str], |
| keys: Iterable[str], |
| limit: int = 5, |
| ) -> List[str]: |
| """Return labels for the highest-percentage fields in the source row.""" |
| scored: List[Tuple[float, str]] = [] |
| for key in keys: |
| raw = clean_text(row.get(key, "")) |
| if not raw: |
| continue |
| if raw.endswith("%"): |
| raw = raw[:-1] |
| try: |
| value = float(raw) |
| except ValueError: |
| continue |
| if value <= 0: |
| continue |
| scored.append((value, key.replace("_", " "))) |
| scored.sort(key=lambda item: item[0], reverse=True) |
| return [label for _, label in scored[:limit]] |
|
|
|
|
| def build_text(segments: Sequence[str]) -> str: |
| """Join non-empty segments into a multi-line description.""" |
| return "\n".join([segment for segment in segments if segment]) |
|
|
|
|
| def infer_extension(url: str) -> str: |
| """Guess a file extension from the URL path.""" |
| path = urlparse(url).path |
| suffix = Path(path).suffix.lower() |
| if suffix in {".jpg", ".jpeg"}: |
| return ".jpg" |
| if suffix in {".png", ".webp"}: |
| return suffix |
| return ".jpg" |
|
|
|
|
| def download_image(url: str, destination: Path) -> bool: |
| """Download an image to the given destination path.""" |
| if destination.exists(): |
| return True |
| try: |
| request = Request(url, headers={"User-Agent": "Mozilla/5.0"}) |
| with urlopen(request, timeout=30) as response: |
| destination.write_bytes(response.read()) |
| return True |
| except Exception as exc: |
| print(f"[warn] Failed to download {url}: {exc}", file=sys.stderr) |
| return False |
|
|
|
|
| def rows_with_images() -> List[Dict[str, str]]: |
| """Load Leafly CSV rows that include an image URL.""" |
| if not LEAFLY_PATH.exists(): |
| raise FileNotFoundError(f"Leafly CSV not found at {LEAFLY_PATH}") |
| rows: List[Dict[str, str]] = [] |
| with LEAFLY_PATH.open("r", encoding="utf-8", newline="") as handle: |
| reader = csv.DictReader(handle) |
| for row in reader: |
| img_url = clean_text(row.get("img_url")) |
| if img_url: |
| row["img_url"] = img_url |
| rows.append(row) |
| return rows |
|
|
|
|
| def positive_keys() -> set[str]: |
| return { |
| "relaxed", |
| "happy", |
| "euphoric", |
| "uplifted", |
| "sleepy", |
| "hungry", |
| "talkative", |
| "creative", |
| "energetic", |
| "focused", |
| "giggly", |
| "tingly", |
| "aroused", |
| } |
|
|
|
|
| def negative_keys() -> set[str]: |
| return { |
| "dry_mouth", |
| "dry_eyes", |
| "dizzy", |
| "paranoid", |
| "anxious", |
| "headache", |
| } |
|
|
|
|
| def build_metadata(row: Dict[str, str], image_path: Path) -> Dict[str, object]: |
| """Convert a CSV row into a structured metadata record.""" |
| strain = clean_text(row.get("name")) |
| strain_type = clean_text(row.get("type")) |
| thc_level = clean_text(row.get("thc_level")) |
| terpene = clean_text(row.get("most_common_terpene")) |
| description = clean_text(row.get("description")) |
| positives_set = positive_keys() |
| negatives_set = negative_keys() |
| positives = collect_ranked_items(row, positives_set) |
| negatives = collect_ranked_items(row, negatives_set) |
| ignore = { |
| "name", |
| "img_url", |
| "type", |
| "thc_level", |
| "most_common_terpene", |
| "description", |
| } |
| all_keys = set(row.keys()) |
| relief_pool = all_keys - positives_set - negatives_set - ignore |
| reliefs = collect_ranked_items(row, relief_pool) |
| text_segments = [ |
| f"Strain: {strain}" if strain else "", |
| f"Type: {strain_type}" if strain_type else "", |
| f"THC level: {thc_level}" if thc_level else "", |
| f"Dominant terpene: {terpene}" if terpene else "", |
| f"Reported effects: {', '.join(positives)}" if positives else "", |
| f"Common uses: {', '.join(reliefs)}" if reliefs else "", |
| f"Possible side effects: {', '.join(negatives)}" if negatives else "", |
| f"Description: {description}" if description else "", |
| ] |
| return { |
| "id": f"leafly:{slugify(strain)}", |
| "source": "leafly_strain_data_with_images", |
| "strain": strain, |
| "strain_type": strain_type or None, |
| "thc_level": thc_level or None, |
| "dominant_terpene": terpene or None, |
| "effects": positives, |
| "reliefs": reliefs, |
| "side_effects": negatives, |
| "text": build_text(text_segments), |
| "image": str(image_path.as_posix()), |
| "image_url": row.get("img_url"), |
| } |
|
|
|
|
| def main() -> None: |
| OUTPUT_DIR.mkdir(parents=True, exist_ok=True) |
| IMAGE_DIR.mkdir(parents=True, exist_ok=True) |
|
|
| rows = rows_with_images() |
| if not rows: |
| print("[info] No rows with image URLs were found.", file=sys.stderr) |
| return |
|
|
| slug_counts: Counter[str] = Counter() |
| records: List[Dict[str, object]] = [] |
| for row in rows: |
| strain = clean_text(row.get("name")) |
| if not strain: |
| continue |
| slug = slugify(strain) |
| slug_counts[slug] += 1 |
| if slug_counts[slug] > 1: |
| slug = f"{slug}-{slug_counts[slug]}" |
| url = row["img_url"] |
| extension = infer_extension(url) |
| image_path = IMAGE_DIR / f"{slug}{extension}" |
| downloaded = download_image(url, image_path) |
| if not downloaded: |
| continue |
| record = build_metadata(row, image_path.relative_to(OUTPUT_DIR)) |
| records.append(record) |
|
|
| if not records: |
| print("[warn] No records were produced; aborting.", file=sys.stderr) |
| return |
|
|
| with METADATA_PATH.open("w", encoding="utf-8") as handle: |
| for record in records: |
| json.dump(record, handle, ensure_ascii=False) |
| handle.write("\n") |
|
|
| summary = { |
| "count": len(records), |
| "image_dir": str(IMAGE_DIR.relative_to(OUTPUT_DIR)), |
| } |
| summary_path = OUTPUT_DIR / "stats.json" |
| with summary_path.open("w", encoding="utf-8") as handle: |
| json.dump(summary, handle, indent=2) |
|
|
| print(f"[info] Wrote {len(records)} records to {METADATA_PATH}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
