705 lines
22 KiB
Python
705 lines
22 KiB
Python
#!/usr/bin/env python3
|
||
"""Extract Light of the Bhāgavata (1983) from other.html.
|
||
|
||
The book has 4 intro segments (front-pages, preface, acknowledgement, the-artist)
|
||
and 48 numbered texts, each with a verse translation and commentary paragraphs.
|
||
|
||
Output:
|
||
lib/jsons/books/lob/intro.json — Book metadata
|
||
lib/jsons/books/lob/intro/*.json — Intro segments
|
||
lib/jsons/books/lob/chapters/*.json — 48 texts
|
||
|
||
Usage:
|
||
python3 scripts/lob_extract.py
|
||
"""
|
||
|
||
import json
|
||
import os
|
||
import re
|
||
import sys
|
||
|
||
from bs4 import BeautifulSoup, Tag
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# ScaGoudy → IAST Unicode mapping
|
||
# ---------------------------------------------------------------------------
|
||
SCAGOUDY_TO_IAST = {
|
||
"ä": "ā",
|
||
"Ä": "Ā",
|
||
"å": "ṛ",
|
||
"Å": "Ṛ",
|
||
"ñ": "ṣ",
|
||
"Ñ": "Ṣ",
|
||
"ö": "ṭ",
|
||
"Ö": "Ṭ",
|
||
"ë": "ṇ",
|
||
"Ë": "Ṇ",
|
||
"ò": "ḍ",
|
||
"Ò": "Ḍ",
|
||
"ç": "ś",
|
||
"Ç": "Ś",
|
||
"ì": "ṅ",
|
||
"ï": "ñ",
|
||
"ü": "ū",
|
||
"Ü": "Ū",
|
||
"é": "ī",
|
||
"É": "Ī",
|
||
"à": "ṁ",
|
||
"ù": "ḥ",
|
||
"è": "ṝ",
|
||
"û": "ṁl",
|
||
"ÿ": "ḷ",
|
||
}
|
||
|
||
|
||
def decode_scagoudy(text: str) -> str:
|
||
"""Replace ScaGoudy-encoded characters with proper IAST Unicode."""
|
||
for src, dst in SCAGOUDY_TO_IAST.items():
|
||
text = text.replace(src, dst)
|
||
return text
|
||
|
||
|
||
def decode_html_content(tag: Tag) -> str:
|
||
"""Extract inner HTML from a tag, decode ScaGoudy, preserve formatting tags."""
|
||
inner = "".join(str(child) for child in tag.children)
|
||
inner = decode_scagoudy(inner)
|
||
# Remove span tags with CSS classes (RTF conversion artifacts)
|
||
inner = re.sub(
|
||
r'<span[^>]*class="[^"]*"[^>]*>(.*?)</span>', r"\1", inner, flags=re.DOTALL
|
||
)
|
||
# Clean up Apple-tab-span leftovers (tab characters)
|
||
inner = inner.replace("\t", " ")
|
||
# Normalize whitespace
|
||
inner = re.sub(r"\s+", " ", inner).strip()
|
||
return inner
|
||
|
||
|
||
def decode_text(tag: Tag) -> str:
|
||
"""Get plain text from a tag with ScaGoudy decoding."""
|
||
return decode_scagoudy(tag.get_text().strip())
|
||
|
||
|
||
def get_css_class(tag: Tag) -> str:
|
||
"""Get the first CSS class of a tag, or empty string."""
|
||
classes = tag.get("class", [])
|
||
return classes[0] if classes else ""
|
||
|
||
|
||
def is_empty(tag: Tag) -> bool:
|
||
"""Check if a tag is empty or whitespace-only."""
|
||
text = tag.get_text().strip()
|
||
return not text or text == "\xa0"
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# CSS class categorization for LoB
|
||
# ---------------------------------------------------------------------------
|
||
|
||
# Book title header class
|
||
BOOK_HEADER_CLASS = "p12"
|
||
|
||
# Bookmark class — used for section boundary detection
|
||
BOOKMARK_CLASS = "p49"
|
||
|
||
# Body paragraph classes (primary content)
|
||
BODY_CLASS = "p198"
|
||
|
||
# First commentary paragraph (slightly different styling, same role as p198)
|
||
FIRST_COMMENTARY_CLASS = "p201"
|
||
|
||
# Verse translation inside <table> elements
|
||
VERSE_TRANSLATION_CLASS = "p200"
|
||
|
||
# Text number heading (bold, e.g. <b>1</b>)
|
||
TEXT_NUMBER_CLASS = "p199"
|
||
|
||
# Section heading (bold, e.g. "Preface", "Acknowledgement")
|
||
SECTION_HEADING_CLASS = "p27"
|
||
|
||
# Sanskrit verse pādas (italic)
|
||
VERSE_PADA_CLASS = "p5"
|
||
|
||
# Front pages text
|
||
FRONT_PAGES_CLASS = "p196"
|
||
|
||
# Verse reference text (e.g. [Bg. 15.17])
|
||
VERSE_REF_CLASS = "p203"
|
||
|
||
# Classes to skip entirely (empty/decorative/breaks)
|
||
SKIP_CLASSES = frozenset(["p195", "p197", "p15", "p202"])
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Bookmark parsers
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
def parse_text_bookmark(text: str) -> int | None:
|
||
"""Parse a text bookmark like 'LoB:1' or 'LoB:48'.
|
||
Returns text number (1-48) or None.
|
||
"""
|
||
text = text.strip()
|
||
m = re.match(r"LoB:(\d+)", text)
|
||
if m:
|
||
return int(m.group(1))
|
||
return None
|
||
|
||
|
||
def parse_intro_bookmark(text: str) -> str | None:
|
||
"""Parse intro section bookmarks. Returns slug or None."""
|
||
text = text.strip()
|
||
if text == "LoB: Preface":
|
||
return "preface"
|
||
if text == "LoB: Acknowledgement":
|
||
return "acknowledgement"
|
||
if text == "LoB: The Artist":
|
||
return "the-artist"
|
||
return None
|
||
|
||
|
||
INTRO_SLUG_TO_TITLE = {
|
||
"preface": "Preface",
|
||
"acknowledgement": "Acknowledgement",
|
||
"the-artist": "The Artist",
|
||
}
|
||
|
||
INTRO_SLUG_TO_ORDER = {
|
||
"front-pages": 1,
|
||
"preface": 2,
|
||
"acknowledgement": 3,
|
||
"the-artist": 4,
|
||
}
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Boundary detection
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
def find_lob_boundaries(all_paragraphs: list) -> tuple:
|
||
"""Find the start and end paragraph indices of the LoB content.
|
||
|
||
Start: <p class="p12"> containing "Light of the Bhägawata"
|
||
End: next <p class="p12"> after start
|
||
"""
|
||
start_idx = None
|
||
end_idx = len(all_paragraphs)
|
||
|
||
for i, p in enumerate(all_paragraphs):
|
||
cls = get_css_class(p)
|
||
if cls != BOOK_HEADER_CLASS:
|
||
continue
|
||
text = decode_text(p)
|
||
if "Light of the Bh" in text and "gawata" in text:
|
||
start_idx = i
|
||
elif start_idx is not None:
|
||
# Next p12 after LoB start = end of LoB
|
||
end_idx = i
|
||
break
|
||
|
||
if start_idx is None:
|
||
print("ERROR: Could not find 'Light of the Bhāgawata' header in other.html!")
|
||
sys.exit(1)
|
||
|
||
return start_idx, end_idx
|
||
|
||
|
||
def find_all_bookmarks(all_paragraphs: list, start_idx: int, end_idx: int) -> list:
|
||
"""Find all p49 bookmark tags in the LoB range.
|
||
|
||
Returns list of (paragraph_index, bookmark_text).
|
||
"""
|
||
bookmarks = []
|
||
for i in range(start_idx, end_idx):
|
||
p = all_paragraphs[i]
|
||
cls = get_css_class(p)
|
||
if cls == BOOKMARK_CLASS:
|
||
text = decode_text(p).strip()
|
||
if text.startswith("LoB"):
|
||
bookmarks.append((i, text))
|
||
return bookmarks
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Paragraph extraction
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
def extract_paragraphs(
|
||
all_paragraphs: list,
|
||
start_idx: int,
|
||
end_idx: int,
|
||
is_front_pages: bool = False,
|
||
is_numbered_text: bool = False,
|
||
) -> list:
|
||
"""Extract paragraphs for a section.
|
||
|
||
Handles all CSS classes within the LoB content.
|
||
Groups consecutive p5 verse pādas into centered italic divs.
|
||
Handles p200 verse translation paragraphs (from inside tables).
|
||
"""
|
||
result = []
|
||
verse_accumulator = []
|
||
|
||
def flush_verse():
|
||
if verse_accumulator:
|
||
joined = "<br>".join(verse_accumulator)
|
||
result.append(f'<div style="text-align:center"><i>{joined}</i></div>')
|
||
verse_accumulator.clear()
|
||
|
||
for i in range(start_idx, end_idx):
|
||
p = all_paragraphs[i]
|
||
cls = get_css_class(p)
|
||
|
||
# Skip empty paragraphs
|
||
if is_empty(p):
|
||
continue
|
||
|
||
# Skip noise classes
|
||
if cls in SKIP_CLASSES:
|
||
continue
|
||
|
||
# Skip bookmark tags (p49)
|
||
if cls == BOOKMARK_CLASS:
|
||
continue
|
||
|
||
# Skip book title header (p12)
|
||
if cls == BOOK_HEADER_CLASS:
|
||
continue
|
||
|
||
# Skip text number headings (p199) — we already know the text number
|
||
if cls == TEXT_NUMBER_CLASS:
|
||
continue
|
||
|
||
# Sanskrit verse pādas (p5) — accumulate into centered block
|
||
if cls == VERSE_PADA_CLASS:
|
||
html = decode_html_content(p)
|
||
if html:
|
||
# Remove inner <i> tags before re-wrapping
|
||
stripped = re.sub(r"</?i>", "", html)
|
||
verse_accumulator.append(stripped)
|
||
continue
|
||
|
||
# Non-verse paragraph — flush any accumulated verse first
|
||
flush_verse()
|
||
|
||
# Verse translation (p200) — bold translation from table
|
||
if cls == VERSE_TRANSLATION_CLASS:
|
||
html = decode_html_content(p)
|
||
if html:
|
||
# Clean up trailing empty <b></b> artifacts
|
||
html = re.sub(r"<b>\s*</b>", "", html).strip()
|
||
# Normalize nested/split bold tags: strip all <b>/<\/b> and
|
||
# re-wrap the whole text in a single <b>…</b>.
|
||
# This fixes source artifacts like "Attracted b<b>y...up</b>on"
|
||
inner = re.sub(r"</?b>", "", html).strip()
|
||
html = f"<b>{inner}</b>"
|
||
result.append(html)
|
||
continue
|
||
|
||
# First commentary paragraph (p201) — treat same as body
|
||
if cls == FIRST_COMMENTARY_CLASS:
|
||
html = decode_html_content(p)
|
||
if html:
|
||
result.append(html)
|
||
continue
|
||
|
||
# Body/commentary paragraphs (p198)
|
||
if cls == BODY_CLASS:
|
||
html = decode_html_content(p)
|
||
if html:
|
||
result.append(html)
|
||
continue
|
||
|
||
# Section heading (p27, bold)
|
||
if cls == SECTION_HEADING_CLASS:
|
||
html = decode_html_content(p)
|
||
if html:
|
||
result.append(html)
|
||
continue
|
||
|
||
# Front pages text (p196)
|
||
if cls == FRONT_PAGES_CLASS:
|
||
html = decode_html_content(p)
|
||
if html:
|
||
result.append(html)
|
||
continue
|
||
|
||
# Verse reference text (p203) — include as-is
|
||
if cls == VERSE_REF_CLASS:
|
||
html = decode_html_content(p)
|
||
if html:
|
||
result.append(html)
|
||
continue
|
||
|
||
# Any other class — try to extract content (be permissive)
|
||
html = decode_html_content(p)
|
||
if html:
|
||
result.append(html)
|
||
|
||
# Flush any trailing verse
|
||
flush_verse()
|
||
|
||
return result
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Main extraction logic
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
def extract_lob(soup: BeautifulSoup) -> dict:
|
||
"""Extract the entire Light of the Bhāgavata from the parsed HTML.
|
||
|
||
Returns a dict with:
|
||
"intro_segments": list of intro segment dicts
|
||
"texts": list of numbered text dicts (1-48)
|
||
"chapter_listing": list of {number, title} for intro.json
|
||
"""
|
||
all_paragraphs = list(soup.find_all("p"))
|
||
|
||
# Step 1: Find LoB boundaries
|
||
lob_start, lob_end = find_lob_boundaries(all_paragraphs)
|
||
print(f" LoB content: paragraphs {lob_start} to {lob_end}")
|
||
print(f" Total paragraphs in range: {lob_end - lob_start}")
|
||
|
||
# Step 2: Find all bookmarks
|
||
bookmarks = find_all_bookmarks(all_paragraphs, lob_start, lob_end)
|
||
print(f" Found {len(bookmarks)} LoB bookmarks")
|
||
for pos, text in bookmarks:
|
||
print(f" Line ~{pos}: {text}")
|
||
|
||
# Step 3: Categorize bookmarks
|
||
intro_bookmarks = [] # (para_idx, slug)
|
||
text_bookmarks = [] # (para_idx, text_num)
|
||
|
||
for pos, text in bookmarks:
|
||
text_num = parse_text_bookmark(text)
|
||
if text_num is not None:
|
||
text_bookmarks.append((pos, text_num))
|
||
else:
|
||
slug = parse_intro_bookmark(text)
|
||
if slug is not None:
|
||
intro_bookmarks.append((pos, slug))
|
||
|
||
print(f" Intro bookmarks: {len(intro_bookmarks)}")
|
||
print(f" Text bookmarks: {len(text_bookmarks)}")
|
||
|
||
# Step 4: Extract front-pages (from p12 header to first intro bookmark)
|
||
front_pages_start = lob_start + 1 # after p12 header
|
||
if intro_bookmarks:
|
||
front_pages_end = intro_bookmarks[0][0]
|
||
elif text_bookmarks:
|
||
front_pages_end = text_bookmarks[0][0]
|
||
else:
|
||
front_pages_end = lob_end
|
||
|
||
front_pages_paras = extract_paragraphs(
|
||
all_paragraphs, front_pages_start, front_pages_end, is_front_pages=True
|
||
)
|
||
|
||
front_pages = {
|
||
"slug": "front-pages",
|
||
"title": "Front Pages",
|
||
"type": "intro-segment",
|
||
"book": "lob",
|
||
"order": 1,
|
||
"paragraphs": front_pages_paras,
|
||
}
|
||
|
||
# Step 5: Extract intro segments (preface, acknowledgement, the-artist)
|
||
intro_segments = [front_pages]
|
||
|
||
# Build ordered list of all section starts for boundary computation
|
||
all_section_starts = sorted(
|
||
[pos for pos, _ in intro_bookmarks] + [pos for pos, _ in text_bookmarks]
|
||
)
|
||
|
||
for idx, (bm_pos, slug) in enumerate(intro_bookmarks):
|
||
content_start = bm_pos + 1 # after the bookmark paragraph
|
||
|
||
# Content ends at the next bookmark/section start
|
||
next_starts = [s for s in all_section_starts if s > bm_pos]
|
||
content_end = next_starts[0] if next_starts else lob_end
|
||
|
||
paras = extract_paragraphs(all_paragraphs, content_start, content_end)
|
||
|
||
segment = {
|
||
"slug": slug,
|
||
"title": INTRO_SLUG_TO_TITLE.get(slug, slug.replace("-", " ").title()),
|
||
"type": "intro-segment",
|
||
"book": "lob",
|
||
"order": INTRO_SLUG_TO_ORDER.get(slug, 10 + idx),
|
||
"paragraphs": paras,
|
||
}
|
||
intro_segments.append(segment)
|
||
|
||
# Step 6: Extract texts 1-48
|
||
texts = []
|
||
for idx, (txt_pos, txt_num) in enumerate(text_bookmarks):
|
||
content_start = txt_pos + 1 # after the bookmark paragraph
|
||
|
||
# Content ends at the next text bookmark or lob_end
|
||
if idx + 1 < len(text_bookmarks):
|
||
content_end = text_bookmarks[idx + 1][0]
|
||
else:
|
||
content_end = lob_end
|
||
|
||
paragraphs = extract_paragraphs(
|
||
all_paragraphs, content_start, content_end, is_numbered_text=True
|
||
)
|
||
|
||
txt = {
|
||
"book": "lob",
|
||
"chapter": txt_num,
|
||
"title": f"Text {txt_num}",
|
||
"type": "chapter",
|
||
"paragraphs": paragraphs,
|
||
}
|
||
texts.append(txt)
|
||
|
||
# Step 7: Build chapter listing for intro.json
|
||
chapter_listing = [{"number": t["chapter"], "title": t["title"]} for t in texts]
|
||
|
||
return {
|
||
"intro_segments": intro_segments,
|
||
"texts": texts,
|
||
"chapter_listing": chapter_listing,
|
||
}
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Output
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
def write_json(data, filepath):
|
||
"""Write data as formatted JSON to filepath, creating directories as needed."""
|
||
os.makedirs(os.path.dirname(filepath), exist_ok=True)
|
||
with open(filepath, "w", encoding="utf-8") as f:
|
||
json.dump(data, f, ensure_ascii=False, indent=2)
|
||
|
||
|
||
def main():
|
||
base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||
html_path = os.path.join(base_dir, "public", "html", "other.html")
|
||
output_base = os.path.join(base_dir, "lib", "jsons", "books", "lob")
|
||
|
||
if not os.path.exists(html_path):
|
||
print(f"ERROR: {html_path} not found!")
|
||
sys.exit(1)
|
||
|
||
print(f"Reading {html_path}...")
|
||
with open(html_path, "r", encoding="utf-8") as f:
|
||
soup = BeautifulSoup(f, "html.parser")
|
||
|
||
print("Extracting Light of the Bhāgavata (1983)...\n")
|
||
result = extract_lob(soup)
|
||
|
||
intro_segments = result["intro_segments"]
|
||
texts = result["texts"]
|
||
chapter_listing = result["chapter_listing"]
|
||
|
||
# --- Write intro.json ---
|
||
intro_meta = {
|
||
"book": "lob",
|
||
"title": "Light of the Bhāgavata",
|
||
"author": "His Divine Grace A.C. Bhaktivedanta Swami Prabhupāda",
|
||
"year": 1983,
|
||
"description": "A unique blend of Vedic wisdom and art — 48 poetic descriptions of the autumn season with spiritual commentaries.",
|
||
"totalChapters": 48,
|
||
"chapters": chapter_listing,
|
||
}
|
||
intro_path = os.path.join(output_base, "intro.json")
|
||
write_json(intro_meta, intro_path)
|
||
print(f"\n Written: {intro_path}")
|
||
|
||
# --- Write intro segments ---
|
||
print(f"\n--- Intro Segments ---")
|
||
for seg in intro_segments:
|
||
filepath = os.path.join(output_base, "intro", f"{seg['slug']}.json")
|
||
write_json(seg, filepath)
|
||
print(
|
||
f" {seg['order']}. {seg['title']}: {len(seg['paragraphs'])} paragraphs → {filepath}"
|
||
)
|
||
|
||
# --- Write texts (chapters) ---
|
||
print(f"\n--- Texts ---")
|
||
for txt in texts:
|
||
num_str = str(txt["chapter"]).zfill(2)
|
||
filepath = os.path.join(output_base, "chapters", f"{num_str}.json")
|
||
write_json(txt, filepath)
|
||
print(
|
||
f" Text {txt['chapter']:>2}: {len(txt['paragraphs']):>3} paragraphs — "
|
||
f"{txt['title']}"
|
||
)
|
||
|
||
# --- Summary ---
|
||
total_intro_paras = sum(len(s["paragraphs"]) for s in intro_segments)
|
||
total_text_paras = sum(len(t["paragraphs"]) for t in texts)
|
||
total_paras = total_intro_paras + total_text_paras
|
||
|
||
print(f"\n{'=' * 60}")
|
||
print(f" EXTRACTION SUMMARY")
|
||
print(f"{'=' * 60}")
|
||
print(f" Intro segments: {len(intro_segments)}")
|
||
for seg in intro_segments:
|
||
print(
|
||
f" {seg['order']}. {seg['title']}: {len(seg['paragraphs'])} paragraphs"
|
||
)
|
||
print(f" Texts: {len(texts)}")
|
||
print(f" Total paragraphs: {total_paras}")
|
||
print(f" Intro: {total_intro_paras}")
|
||
print(f" Texts: {total_text_paras}")
|
||
if texts:
|
||
print(f" Avg paras/text: {total_text_paras / len(texts):.1f}")
|
||
print(f" Output directory: {output_base}/")
|
||
|
||
# --- Samples ---
|
||
print(f"\n--- Sample: Text 1 ---")
|
||
if texts:
|
||
t1 = texts[0]
|
||
for i, p in enumerate(t1["paragraphs"][:4]):
|
||
preview = re.sub(r"<[^>]+>", "", p)[:120]
|
||
print(f" [{i}] {preview}...")
|
||
|
||
if len(texts) >= 24:
|
||
print(f"\n--- Sample: Text 24 ---")
|
||
t24 = texts[23]
|
||
for i, p in enumerate(t24["paragraphs"][:3]):
|
||
preview = re.sub(r"<[^>]+>", "", p)[:120]
|
||
print(f" [{i}] {preview}...")
|
||
|
||
if len(texts) >= 48:
|
||
print(f"\n--- Sample: Text 48 (last) ---")
|
||
t48 = texts[47]
|
||
for i, p in enumerate(t48["paragraphs"][:3]):
|
||
preview = re.sub(r"<[^>]+>", "", p)[:120]
|
||
print(f" [{i}] {preview}...")
|
||
|
||
# --- Quality Checks ---
|
||
print(f"\n--- Quality Checks ---")
|
||
|
||
# Check all 48 texts present
|
||
expected_texts = set(range(1, 49))
|
||
actual_texts = set(t["chapter"] for t in texts)
|
||
missing = expected_texts - actual_texts
|
||
extra = actual_texts - expected_texts
|
||
if missing:
|
||
print(f" ⚠ Missing texts: {sorted(missing)}")
|
||
if extra:
|
||
print(f" ⚠ Extra texts: {sorted(extra)}")
|
||
if not missing and not extra:
|
||
print(f" ✅ All 48 texts present")
|
||
|
||
# Check all 4 intro segments present
|
||
expected_intros = {"front-pages", "preface", "acknowledgement", "the-artist"}
|
||
actual_intros = {s["slug"] for s in intro_segments}
|
||
missing_intros = expected_intros - actual_intros
|
||
if missing_intros:
|
||
print(f" ⚠ Missing intro segments: {missing_intros}")
|
||
else:
|
||
print(f" ✅ All 4 intro segments present")
|
||
|
||
# Check each text has at least 2 paragraphs (1 translation + 1 commentary)
|
||
thin_texts = [t["chapter"] for t in texts if len(t["paragraphs"]) < 2]
|
||
if thin_texts:
|
||
print(f" ⚠ Texts with fewer than 2 paragraphs: {thin_texts}")
|
||
else:
|
||
print(f" ✅ All texts have at least 2 paragraphs (translation + commentary)")
|
||
|
||
# Check empty texts
|
||
empty_texts = [t["chapter"] for t in texts if len(t["paragraphs"]) == 0]
|
||
if empty_texts:
|
||
print(f" ⚠ Empty texts (0 paragraphs): {empty_texts}")
|
||
else:
|
||
print(f" ✅ No empty texts")
|
||
|
||
# Check that each numbered text starts with a bold translation
|
||
texts_without_translation = []
|
||
for t in texts:
|
||
if t["paragraphs"]:
|
||
first = t["paragraphs"][0]
|
||
if not first.strip().startswith("<b>"):
|
||
texts_without_translation.append(t["chapter"])
|
||
if texts_without_translation:
|
||
print(
|
||
f" ⚠ Texts whose first paragraph is not a bold translation: "
|
||
f"{texts_without_translation}"
|
||
)
|
||
else:
|
||
print(f" ✅ All texts start with bold verse translation")
|
||
|
||
# Check ScaGoudy decoding — look for common encoded characters
|
||
encoded_chars = set("äåöëòçüéàùè")
|
||
suspect_count = 0
|
||
all_sections = texts + intro_segments
|
||
for section in all_sections:
|
||
for p in section["paragraphs"]:
|
||
plain = re.sub(r"<[^>]+>", "", p)
|
||
for c in encoded_chars:
|
||
if c in plain:
|
||
suspect_count += 1
|
||
break
|
||
if suspect_count == 0:
|
||
print(f" ✅ No suspected undecoded ScaGoudy characters found")
|
||
else:
|
||
print(
|
||
f" ℹ {suspect_count} paragraphs contain characters that may be undecoded ScaGoudy"
|
||
)
|
||
|
||
# Check verse blocks (embedded Sanskrit verses with p5)
|
||
verse_block_count = 0
|
||
for t in texts:
|
||
for p in t["paragraphs"]:
|
||
if '<div style="text-align:center"><i>' in p:
|
||
verse_block_count += 1
|
||
print(f" ℹ {verse_block_count} verse blocks in texts (embedded Sanskrit verses)")
|
||
|
||
# ScaGoudy decoding spot check
|
||
print(f"\n--- ScaGoudy Decoding Spot Check ---")
|
||
if texts:
|
||
t1_text = " ".join(texts[0]["paragraphs"][:10])
|
||
if "Kṛṣṇa" in t1_text or "kṛṣṇa" in t1_text:
|
||
print(f" ✅ 'Kṛṣṇa' correctly decoded in Text 1")
|
||
elif "Kåñëa" in t1_text or "kåñëa" in t1_text:
|
||
print(f" ⚠ 'Kåñëa' still encoded — ScaGoudy decoding may have failed!")
|
||
else:
|
||
print(
|
||
f" ℹ 'Kṛṣṇa' not found in Text 1 first 10 paragraphs (may be normal)"
|
||
)
|
||
|
||
# Check for "Prabhupāda" in intro segments
|
||
all_intro_text = " ".join(
|
||
p for seg in intro_segments for p in seg["paragraphs"][:10]
|
||
)
|
||
if "Prabhupāda" in all_intro_text:
|
||
print(f" ✅ 'Prabhupāda' correctly decoded in intro")
|
||
elif "Prabhupäda" in all_intro_text:
|
||
print(f" ⚠ ScaGoudy decoding incomplete for 'Prabhupäda'")
|
||
|
||
# Check for "Śrīmad" or "Bhāgavatam"
|
||
if "Bhāgavata" in all_intro_text or "Bhāgawata" in all_intro_text:
|
||
print(f" ✅ 'Bhāgavata' correctly decoded in intro")
|
||
|
||
# Sample verse blocks
|
||
if verse_block_count > 0:
|
||
print(f"\n--- Sample Verse Blocks ---")
|
||
shown = 0
|
||
for t in texts:
|
||
for p in t["paragraphs"]:
|
||
if '<div style="text-align:center"><i>' in p:
|
||
preview = re.sub(r"<[^>]+>", "", p)[:120]
|
||
print(f" Text {t['chapter']}: {preview}...")
|
||
shown += 1
|
||
if shown >= 3:
|
||
break
|
||
if shown >= 3:
|
||
break
|
||
|
||
print(f"\nDone! ✨")
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|