Delete tarot_labyrinthos_scraper_rag_sft_nlp_pipeline.py

tarot_labyrinthos_scraper_rag_sft_nlp_pipeline.py

@@ -1,799 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Tarot Labyrinthos Dataset Builder (MAX)
-
-This script scrapes labyrinthos.co tarot meanings pages and generates:
-
-1) FULL MASTER JSON (raw structured dump)
-   output/tarot_cards_labyrinthos_full.json
-
-2) RAG DATASET (chunked JSONL)
-   output/rag_chunks.jsonl
-
-3) SFT TRAINING DATASET (ChatML-style JSONL)
-   output/train_sft.jsonl
-
-4) NLP DATASETS (classification/NER-like + keyword normalization)
-   output/nlp_intents.jsonl
-   output/nlp_keywords.jsonl
-
-Notes:
-- This script is designed to be robust against HTML changes.
-- It uses heading-based extraction (h2/h3) + fallback regex extraction.
-- It includes throttling to reduce ban risk.
-
-Requirements:
-  pip install requests beautifulsoup4 lxml tqdm
-
-Run:
-  python tarot_labyrinthos_pipeline.py
-
-"""
-
-import os
-import re
-import json
-import time
-import random
-import hashlib
-import requests
-from bs4 import BeautifulSoup
-from tqdm import tqdm
-
-
-BASE = "https://labyrinthos.co"
-LIST_URL = "https://labyrinthos.co/blogs/tarot-card-meanings-list"
-
-OUT_DIR = "output"
-
-FULL_JSON = os.path.join(OUT_DIR, "tarot_cards_labyrinthos_full.json")
-RAG_JSONL = os.path.join(OUT_DIR, "rag_chunks.jsonl")
-SFT_JSONL = os.path.join(OUT_DIR, "train_sft.jsonl")
-
-NLP_INTENTS_JSONL = os.path.join(OUT_DIR, "nlp_intents.jsonl")
-NLP_KEYWORDS_JSONL = os.path.join(OUT_DIR, "nlp_keywords.jsonl")
-
-HEADERS = {
-    "User-Agent": (
-        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
-        "(KHTML, like Gecko) Chrome/122.0 Safari/537.36"
-    )
-}
-
-
-# ----------------------------
-# Utils
-# ----------------------------
-
-def clean_text(text: str) -> str:
-    if not text:
-        return ""
-    text = re.sub(r"\r", "", text)
-    text = re.sub(r"[ \t]+", " ", text)
-    text = re.sub(r"\n{3,}", "\n\n", text)
-    return text.strip()
-
-
-def slugify(name: str) -> str:
-    s = name.lower().strip()
-    s = re.sub(r"[’']", "", s)
-    s = re.sub(r"[^a-z0-9]+", "-", s)
-    s = re.sub(r"-{2,}", "-", s)
-    return s.strip("-")
-
-
-def safe_sleep():
-    # Anti-ban: jittered sleep
-    time.sleep(random.uniform(0.7, 1.6))
-
-
-def sha1_id(text: str) -> str:
-    return hashlib.sha1(text.encode("utf-8")).hexdigest()[:16]
-
-
-# ----------------------------
-# Networking
-# ----------------------------
-
-def request_html(url: str, retries: int = 6) -> str:
-    last_err = None
-
-    for attempt in range(retries):
-        try:
-            r = requests.get(url, headers=HEADERS, timeout=60)
-
-            if r.status_code == 429:
-                # rate limited
-                time.sleep(8 + attempt * 2)
-                continue
-
-            if r.status_code >= 500:
-                time.sleep(4 + attempt)
-                continue
-
-            r.raise_for_status()
-            return r.text
-
-        except Exception as e:
-            last_err = e
-            time.sleep(2 + attempt)
-
-    raise last_err
-
-
-# ----------------------------
-# Scraping
-# ----------------------------
-
-def get_card_links() -> list:
-    html = request_html(LIST_URL)
-    soup = BeautifulSoup(html, "lxml")
-
-    links = set()
-
-    for a in soup.select("a[href]"):
-        href = a.get("href", "").strip()
-
-        # Example:
-        # /blogs/tarot-card-meanings-list/the-tower-meaning-major-arcana-tarot-card-meanings
-        if href.startswith("/blogs/tarot-card-meanings-list/") and "meaning" in href:
-            links.add(BASE + href)
-
-    return sorted(list(links))
-
-
-def extract_article_container(soup: BeautifulSoup):
-    # Try known containers
-    candidates = []
-
-    for selector in ["article", ".rte", ".article__content", ".blog__content", ".main-content"]:
-        node = soup.select_one(selector)
-        if node:
-            txt = node.get_text("\n", strip=True)
-            if len(txt) > 500:
-                candidates.append((len(txt), node))
-
-    if candidates:
-        candidates.sort(key=lambda x: x[0], reverse=True)
-        return candidates[0][1]
-
-    # fallback
-    return soup
-
-
-def normalize_heading(h: str) -> str:
-    if not h:
-        return ""
-    h = clean_text(h).lower()
-    h = re.sub(r"[^a-z0-9\s]", "", h)
-    h = re.sub(r"\s+", " ", h).strip()
-    return h
-
-
-def extract_sections_from_html(container) -> dict:
-    """
-    Splits article into sections using headings (h1/h2/h3).
-    Returns dict: {section_title: section_text}
-
-    This is the key part that makes Love/Career/Health parsing possible.
-    """
-
-    sections = {}
-    current_title = "main"
-    buffer = []
-
-    def flush():
-        nonlocal buffer, current_title
-        if buffer:
-            content = clean_text("\n".join(buffer))
-            if content:
-                if current_title in sections:
-                    sections[current_title] += "\n\n" + content
-                else:
-                    sections[current_title] = content
-        buffer = []
-
-    for elem in container.find_all(["h1", "h2", "h3", "p", "ul", "ol", "blockquote"], recursive=True):
-        if elem.name in ["h1", "h2", "h3"]:
-            flush()
-            current_title = normalize_heading(elem.get_text(" ", strip=True))
-        else:
-            text = elem.get_text("\n", strip=True)
-            if text:
-                buffer.append(text)
-
-    flush()
-    return sections
-
-
-def parse_keywords_from_text(text: str) -> str:
-    if not text:
-        return ""
-
-    m = re.search(r"(keywords|key words)\s*[:\-]\s*(.+)", text, re.IGNORECASE)
-    if m:
-        return clean_text(m.group(2))
-
-    return ""
-
-
-def pick_section(sections: dict, keys: list) -> str:
-    for k in keys:
-        nk = normalize_heading(k)
-        for title, content in sections.items():
-            if nk in title:
-                return content
-    return ""
-
-
-# ----------------------------
-# Tarot card metadata guessing
-# ----------------------------
-
-def guess_arcana_and_suit(name: str):
-    n = name.lower().strip()
-
-    major_names = {
-        "the fool", "the magician", "the high priestess", "the empress", "the emperor",
-        "the hierophant", "the lovers", "the chariot", "strength", "the hermit",
-        "wheel of fortune", "justice", "the hanged man", "death", "temperance",
-        "the devil", "the tower", "the star", "the moon", "the sun",
-        "judgement", "judgment", "the world"
-    }
-
-    if n in major_names:
-        return "Major Arcana", None, "major"
-
-    if " of wands" in n:
-        return "Minor Arcana", "Wands", "minor"
-    if " of cups" in n:
-        return "Minor Arcana", "Cups", "minor"
-    if " of swords" in n:
-        return "Minor Arcana", "Swords", "minor"
-    if " of pentacles" in n:
-        return "Minor Arcana", "Pentacles", "minor"
-
-    return "Major Arcana", None, "major"
-
-
-def guess_value(name: str) -> int:
-    major_map = {
-        "the fool": 0,
-        "the magician": 1,
-        "the high priestess": 2,
-        "the empress": 3,
-        "the emperor": 4,
-        "the hierophant": 5,
-        "the lovers": 6,
-        "the chariot": 7,
-        "strength": 8,
-        "the hermit": 9,
-        "wheel of fortune": 10,
-        "justice": 11,
-        "the hanged man": 12,
-        "death": 13,
-        "temperance": 14,
-        "the devil": 15,
-        "the tower": 16,
-        "the star": 17,
-        "the moon": 18,
-        "the sun": 19,
-        "judgement": 20,
-        "judgment": 20,
-        "the world": 21
-    }
-
-    n = name.lower().strip()
-    if n in major_map:
-        return major_map[n]
-
-    if n.startswith("ace of"):
-        return 1
-    if n.startswith("two of"):
-        return 2
-    if n.startswith("three of"):
-        return 3
-    if n.startswith("four of"):
-        return 4
-    if n.startswith("five of"):
-        return 5
-    if n.startswith("six of"):
-        return 6
-    if n.startswith("seven of"):
-        return 7
-    if n.startswith("eight of"):
-        return 8
-    if n.startswith("nine of"):
-        return 9
-    if n.startswith("ten of"):
-        return 10
-    if n.startswith("page of"):
-        return 11
-    if n.startswith("knight of"):
-        return 12
-    if n.startswith("queen of"):
-        return 13
-    if n.startswith("king of"):
-        return 14
-
-    return -1
-
-
-# ----------------------------
-# Main parser per card
-# ----------------------------
-
-def parse_card_page(url: str):
-    html = request_html(url)
-    soup = BeautifulSoup(html, "lxml")
-
-    h1 = soup.find("h1")
-    if not h1:
-        return None
-
-    title = clean_text(h1.get_text(" ", strip=True))
-
-    container = extract_article_container(soup)
-    sections = extract_sections_from_html(container)
-
-    full_text = clean_text(container.get_text("\n", strip=True))
-    keywords = parse_keywords_from_text(full_text)
-
-    # Core meanings
-    upright = pick_section(sections, ["upright meaning", "upright"])
-    reversed_ = pick_section(sections, ["reversed meaning", "reversed"])
-
-    # Extended meaning sections
-    symbolism = pick_section(sections, ["symbolism", "symbols"])
-    correspondences = pick_section(sections, ["correspondences", "astrology", "element"])
-    historical = pick_section(sections, ["history", "historical"])
-    psychological = pick_section(sections, ["psychological", "psychology"])
-
-    love = pick_section(sections, ["love meaning", "love tarot meaning", "love"])
-    career = pick_section(sections, ["career meaning", "career"])
-    money = pick_section(sections, ["money meaning", "finance meaning", "finances", "money"])
-    health = pick_section(sections, ["health meaning", "health"])
-    spirituality = pick_section(sections, ["spiritual meaning", "spirituality meaning", "spirituality"])
-
-    faq = pick_section(sections, ["faq", "questions"])
-
-    # Description heuristic: first long paragraph
-    paragraphs = [p.strip() for p in full_text.split("\n") if len(p.strip()) > 70]
-    description = paragraphs[0] if paragraphs else ""
-
-    arcana, suit, ctype = guess_arcana_and_suit(title)
-    value = guess_value(title)
-
-    card = {
-        "slug": slugify(title),
-        "name": title,
-        "arcana": arcana,
-        "suit": suit,
-        "type": ctype,
-        "value": value,
-        "image_url": "",
-        "source_url": url,
-        "translations": {
-            "en": {
-                "name": title,
-                "keywords": keywords,
-                "upright_meaning": upright,
-                "reversed_meaning": reversed_,
-                "description": description,
-                "full_interpretation": full_text,
-                "symbolism": symbolism,
-                "historical": historical,
-                "psychological": psychological,
-                "correspondences": correspondences,
-                "faq": faq,
-
-                # EXTRA FIELDS FOR NLP/RAG
-                "love": love,
-                "career": career,
-                "money": money,
-                "health": health,
-                "spirituality": spirituality
-            }
-        }
-    }
-
-    return card
-
-
-# ----------------------------
-# Chunking for RAG
-# ----------------------------
-
-def chunk_text(text: str, chunk_size: int = 1200, overlap: int = 220):
-    text = clean_text(text)
-    if not text:
-        return []
-
-    chunks = []
-    start = 0
-
-    while start < len(text):
-        end = start + chunk_size
-        chunk = text[start:end]
-        chunk = chunk.strip()
-
-        if chunk:
-            chunks.append(chunk)
-
-        start = end - overlap
-        if start < 0:
-            start = 0
-
-    return chunks
-
-
-def write_jsonl(path: str, rows: list):
-    with open(path, "w", encoding="utf-8") as f:
-        for r in rows:
-            f.write(json.dumps(r, ensure_ascii=False) + "\n")
-
-
-def make_rag_chunks(cards: list):
-    rows = []
-
-    for card in cards:
-        en = card["translations"]["en"]
-
-        base_tags = [
-            card["type"],
-            card["arcana"].replace(" ", "_").lower(),
-            card["slug"],
-        ]
-
-        if card["suit"]:
-            base_tags.append(card["suit"].lower())
-
-        section_map = {
-            "keywords": en.get("keywords", ""),
-            "upright_meaning": en.get("upright_meaning", ""),
-            "reversed_meaning": en.get("reversed_meaning", ""),
-            "description": en.get("description", ""),
-            "symbolism": en.get("symbolism", ""),
-            "historical": en.get("historical", ""),
-            "psychological": en.get("psychological", ""),
-            "correspondences": en.get("correspondences", ""),
-            "faq": en.get("faq", ""),
-            "love": en.get("love", ""),
-            "career": en.get("career", ""),
-            "money": en.get("money", ""),
-            "health": en.get("health", ""),
-            "spirituality": en.get("spirituality", ""),
-            "full_interpretation": en.get("full_interpretation", ""),
-        }
-
-        for section, content in section_map.items():
-            content = clean_text(content)
-            if not content or len(content) < 60:
-                continue
-
-            for idx, chunk in enumerate(chunk_text(content)):
-                rows.append({
-                    "id": f"{card['slug']}_{section}_{idx}",
-                    "hash": sha1_id(card["slug"] + section + chunk),
-                    "card": card["name"],
-                    "slug": card["slug"],
-                    "arcana": card["arcana"],
-                    "suit": card["suit"],
-                    "type": card["type"],
-                    "value": card["value"],
-                    "section": section,
-                    "text": chunk,
-                    "tags": base_tags + [section],
-                    "source_url": card["source_url"],
-                    "lang": "en"
-                })
-
-    return rows
-
-
-# ----------------------------
-# SFT dataset generator
-# ----------------------------
-
-def make_sft_dataset(cards: list):
-    system_prompt = (
-        "You are a professional tarot reader. "
-        "Answer clearly, mystically, but without unnecessary filler. "
-        "Do not invent meanings. Use tarot interpretations." 
-        "Keep the tone confident and structured."
-    )
-
-    rows = []
-
-    for card in cards:
-        en = card["translations"]["en"]
-        name = card["name"]
-
-        def add_sample(user, assistant):
-            assistant = clean_text(assistant)
-            if not assistant or len(assistant) < 40:
-                return
-
-            rows.append({
-                "messages": [
-                    {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": user},
-                    {"role": "assistant", "content": assistant}
-                ]
-            })
-
-        upright = en.get("upright_meaning", "")
-        reversed_ = en.get("reversed_meaning", "")
-
-        love = en.get("love", "")
-        career = en.get("career", "")
-        money = en.get("money", "")
-        health = en.get("health", "")
-        spirituality = en.get("spirituality", "")
-
-        symbolism = en.get("symbolism", "")
-        psychological = en.get("psychological", "")
-        historical = en.get("historical", "")
-        correspondences = en.get("correspondences", "")
-        faq = en.get("faq", "")
-
-        full = en.get("full_interpretation", "")
-
-        add_sample(f"What does the tarot card {name} mean upright?", upright)
-        add_sample(f"What does the tarot card {name} mean reversed?", reversed_)
-
-        add_sample(f"Interpret the tarot card {name} in love and relationships.", love)
-        add_sample(f"Interpret the tarot card {name} in career and work.", career)
-        add_sample(f"Interpret the tarot card {name} for money and finances.", money)
-        add_sample(f"Interpret the tarot card {name} for health.", health)
-        add_sample(f"Interpret the tarot card {name} for spirituality.", spirituality)
-
-        add_sample(f"Explain the symbolism of the tarot card {name}.", symbolism)
-        add_sample(f"Explain the psychological meaning of the tarot card {name}.", psychological)
-        add_sample(f"Explain the historical context of the tarot card {name}.", historical)
-        add_sample(f"What correspondences does the tarot card {name} have (astrology, elements)?", correspondences)
-
-        add_sample(f"FAQ: common questions about the tarot card {name}.", faq)
-        add_sample(f"Give a full detailed interpretation of the tarot card {name}.", full)
-
-        # Advice-of-the-day sample
-        advice_source = upright if upright else full
-        add_sample(f"What advice does the tarot card {name} give as a card of the day?", advice_source)
-
-        # Spread position samples
-        if upright:
-            add_sample(
-                f"In a 3-card spread (past-present-future), what does {name} mean in the Past position?",
-                upright
-            )
-            add_sample(
-                f"In a 3-card spread (past-present-future), what does {name} mean in the Present position?",
-                upright
-            )
-            add_sample(
-                f"In a 3-card spread (past-present-future), what does {name} mean in the Future position?",
-                upright
-            )
-
-    return rows
-
-
-# ----------------------------
-# NLP datasets
-# ----------------------------
-
-def normalize_keywords(keywords: str) -> list:
-    if not keywords:
-        return []
-
-    # split by comma or semicolon
-    parts = re.split(r"[,;\n]", keywords)
-    out = []
-
-    for p in parts:
-        p = p.strip().lower()
-        p = re.sub(r"[^a-z0-9\-\s]", "", p)
-        p = re.sub(r"\s+", " ", p).strip()
-        if p and len(p) > 1:
-            out.append(p)
-
-    # deduplicate preserving order
-    seen = set()
-    uniq = []
-    for k in out:
-        if k not in seen:
-            uniq.append(k)
-            seen.add(k)
-
-    return uniq
-
-
-def make_nlp_keywords_dataset(cards: list):
-    """
-    Generates a dataset mapping each card -> normalized keywords list.
-    Useful for NLP classification, tagger, query expansion.
-
-    Output rows:
-      { card, slug, arcana, suit, type, value, keywords: [..] }
-    """
-
-    rows = []
-
-    for card in cards:
-        en = card["translations"]["en"]
-        kw = normalize_keywords(en.get("keywords", ""))
-
-        if not kw:
-            continue
-
-        rows.append({
-            "card": card["name"],
-            "slug": card["slug"],
-            "arcana": card["arcana"],
-            "suit": card["suit"],
-            "type": card["type"],
-            "value": card["value"],
-            "keywords": kw,
-            "source_url": card["source_url"],
-            "lang": "en"
-        })
-
-    return rows
-
-
-def make_nlp_intents_dataset(cards: list):
-    """
-    Generates an intent classification dataset.
-
-    Example:
-      input: "What does The Tower mean in love?"
-      label: "love"
-
-    This can train:
-    - intent classifier
-    - routing model (RAG retrieval filter)
-
-    Output format:
-      { "text": ..., "intent": ..., "card": ..., "slug": ... }
-    """
-
-    templates = {
-        "upright": [
-            "What does {card} mean upright?",
-            "Explain {card} upright meaning.",
-            "Tarot meaning of {card} upright.",
-        ],
-        "reversed": [
-            "What does {card} mean reversed?",
-            "Explain {card} reversed meaning.",
-            "Tarot meaning of {card} reversed.",
-        ],
-        "love": [
-            "What does {card} mean in love?",
-            "Love reading: interpret {card}.",
-            "Relationship meaning of {card} tarot.",
-        ],
-        "career": [
-            "What does {card} mean for career?",
-            "Work reading: interpret {card}.",
-            "Job meaning of {card} tarot.",
-        ],
-        "money": [
-            "What does {card} mean for money?",
-            "Financial meaning of {card} tarot.",
-            "Interpret {card} for finances.",
-        ],
-        "health": [
-            "What does {card} mean for health?",
-            "Health reading: interpret {card}.",
-            "Physical wellbeing meaning of {card} tarot.",
-        ],
-        "spirituality": [
-            "What does {card} mean spiritually?",
-            "Spiritual meaning of {card} tarot.",
-            "Interpret {card} for spiritual growth.",
-        ],
-        "symbolism": [
-            "Explain the symbolism of {card}.",
-            "What symbols are on {card} and what do they mean?",
-        ],
-        "psychological": [
-            "Explain the psychological meaning of {card}.",
-            "What does {card} represent psychologically?",
-        ],
-        "historical": [
-            "Tell me the history of {card} tarot card.",
-            "Historical background of {card}.",
-        ],
-        "correspondences": [
-            "What correspondences does {card} have?",
-            "Astrology and elements correspondences of {card} tarot.",
-        ],
-        "general": [
-            "Give a full interpretation of {card}.",
-            "Explain the tarot card {card}.",
-        ]
-    }
-
-    rows = []
-
-    for card in cards:
-        for intent, tpls in templates.items():
-            for tpl in tpls:
-                text = tpl.format(card=card["name"])
-                rows.append({
-                    "text": text,
-                    "intent": intent,
-                    "card": card["name"],
-                    "slug": card["slug"],
-                    "arcana": card["arcana"],
-                    "suit": card["suit"],
-                    "type": card["type"],
-                    "value": card["value"],
-                    "lang": "en"
-                })
-
-    random.shuffle(rows)
-    return rows
-
-
-# ----------------------------
-# Main
-# ----------------------------
-
-def main():
-    os.makedirs(OUT_DIR, exist_ok=True)
-
-    print("[+] Fetching card links...")
-    links = get_card_links()
-    print(f"[+] Found {len(links)} links")
-
-    cards = []
-
-    for url in tqdm(links, desc="Scraping cards"):
-        try:
-            card = parse_card_page(url)
-            if card:
-                cards.append(card)
-        except Exception as e:
-            print(f"[!] Failed: {url} -> {e}")
-
-        safe_sleep()
-
-    # Sort: major first, then minor by value
-    cards.sort(key=lambda x: (0 if x["type"] == "major" else 1, x["value"], x["name"]))
-
-    # Assign IDs
-    for i, c in enumerate(cards, start=1):
-        c["id"] = i
-
-    # Save full master dump
-    with open(FULL_JSON, "w", encoding="utf-8") as f:
-        json.dump(cards, f, ensure_ascii=False, indent=2)
-
-    print(f"[+] Saved FULL JSON: {FULL_JSON}")
-
-    # Build RAG chunks
-    rag_rows = make_rag_chunks(cards)
-    write_jsonl(RAG_JSONL, rag_rows)
-    print(f"[+] Saved RAG JSONL: {RAG_JSONL} (rows={len(rag_rows)})")
-
-    # Build SFT dataset
-    sft_rows = make_sft_dataset(cards)
-    write_jsonl(SFT_JSONL, sft_rows)
-    print(f"[+] Saved SFT JSONL: {SFT_JSONL} (rows={len(sft_rows)})")
-
-    # NLP datasets
-    nlp_intents = make_nlp_intents_dataset(cards)
-    write_jsonl(NLP_INTENTS_JSONL, nlp_intents)
-    print(f"[+] Saved NLP intents JSONL: {NLP_INTENTS_JSONL} (rows={len(nlp_intents)})")
-
-    nlp_keywords = make_nlp_keywords_dataset(cards)
-    write_jsonl(NLP_KEYWORDS_JSONL, nlp_keywords)
-    print(f"[+] Saved NLP keywords JSONL: {NLP_KEYWORDS_JSONL} (rows={len(nlp_keywords)})")
-
-    print("[✓] DONE")
-
-
-if __name__ == "__main__":
-    main()