Upload tarot_labyrinthos_scraper_rag_sft_nlp_pipeline.py

tarot_labyrinthos_scraper_rag_sft_nlp_pipeline.py

@@ -0,0 +1,799 @@
+# -*- 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()