quran-processing-toolkit 0.4.0__py3-none-any.whl

quran_processing_toolkit/__init__.py

@@ -0,0 +1,96 @@
+"""Natural, 1-based access to Quranic text and morphology."""
+
+from .chapter_names import chapter_name
+from .collections import IndexedCollection, OneBasedCollection, QuerySet
+from .corpus import (
+    CorpusAlignmentError,
+    CorpusError,
+    QuranCorpus,
+    clear_memory_cache,
+    default_data_directory,
+    load_quran,
+)
+from .models import (
+    VERB_FORM_NAMES,
+    Chapter,
+    Juz,
+    Token,
+    TokenAddress,
+    Verse,
+    VerseAddress,
+    Word,
+    WordAddress,
+)
+from .similarity import VerseMatch, compare_verses
+from .source_data import (
+    DataError,
+    DataIntegrityError,
+    DataPackageNotInstalledError,
+)
+from .text import (
+    BUCKWALTER_DIACRITICS,
+    QURANIC_PAUSE_MARKS,
+    TranslationNotAvailableError,
+    canonical_representation,
+    infer_representation,
+    normalize_arabic,
+    normalize_buckwalter,
+    split_surface_words,
+)
+from .translations import (
+    Translation,
+    TranslationCoverage,
+    TranslationDownloadError,
+    TranslationIntegrityError,
+    TranslationLicenseWarning,
+    TranslationSource,
+    download_translation,
+    load_translation,
+    translation_sources,
+)
+
+__all__ = [
+    "Chapter",
+    "BUCKWALTER_DIACRITICS",
+    "CorpusAlignmentError",
+    "CorpusError",
+    "DataError",
+    "DataIntegrityError",
+    "DataPackageNotInstalledError",
+    "IndexedCollection",
+    "Juz",
+    "OneBasedCollection",
+    "QuranCorpus",
+    "QURANIC_PAUSE_MARKS",
+    "QuerySet",
+    "Token",
+    "TokenAddress",
+    "TranslationNotAvailableError",
+    "Verse",
+    "VerseAddress",
+    "VERB_FORM_NAMES",
+    "Word",
+    "WordAddress",
+    "clear_memory_cache",
+    "default_data_directory",
+    "canonical_representation",
+    "infer_representation",
+    "load_quran",
+    "normalize_arabic",
+    "normalize_buckwalter",
+    "chapter_name",
+    "split_surface_words",
+    "VerseMatch",
+    "compare_verses",
+    "Translation",
+    "TranslationCoverage",
+    "TranslationDownloadError",
+    "TranslationIntegrityError",
+    "TranslationLicenseWarning",
+    "TranslationSource",
+    "download_translation",
+    "load_translation",
+    "translation_sources",
+]
+
+__version__ = "0.4.0"

quran_processing_toolkit/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

quran_processing_toolkit/build.py

@@ -0,0 +1,263 @@
+"""Parse verbatim QAC data and deterministically derive the toolkit representation."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import tempfile
+from contextlib import suppress
+from pathlib import Path
+from typing import Any
+
+TRANSFORMATION_VERSION = 2
+SUPPORTED_DERIVED_DIGESTS = {
+    "a1d12923815341face765083805d2148ed2d9f5cc3f7d6665219d887675d8c46": (
+        "01505a13b870567b38bc510cf7ab185072f4f70c473f68b02088c9602826ca79"
+    )
+}
+
+CONJUGATION = {
+    "3MS": 1,
+    "3MD": 2,
+    "3MP": 3,
+    "3FS": 4,
+    "3FD": 5,
+    "3FP": 6,
+    "2MS": 7,
+    "2MD": 8,
+    "2MP": 9,
+    "2FS": 10,
+    "2FD": 11,
+    "2FP": 12,
+    "1S": 13,
+    "1P": 14,
+    "2D": 8,
+}
+GENDER = {
+    "M": "MASC",
+    "MP": "MASC",
+    "MS": "MASC",
+    "MD": "MASC",
+    "F": "FEM",
+    "FP": "FEM",
+    "FS": "FEM",
+    "FD": "FEM",
+}
+COUNT = {
+    "MP": "PLURAL",
+    "MD": "DUAL",
+    "MS": "SINGULAR",
+    "FP": "PLURAL",
+    "FD": "DUAL",
+    "FS": "SINGULAR",
+}
+TOKEN_ROLE = {"PREFIX": "PREFIX", "SUFFIX": "SUFFIX", "STEM": "STEM"}
+ASPECT = {"PERF": "PERFECT", "IMPF": "IMPERFECT", "IMPV": "IMPERATIVE"}
+TENSE = {"PERF": "PAST", "IMPF": "PRESENT", "IMPV": "IMPERATIVE"}
+
+# Historical coordinate-specific interpretations of the source's ambiguous 2D label.
+# These are an explicit toolkit overlay; the untouched source feature remains available.
+CONJUGATION_OVERRIDES = {
+    (4, 171, 4, 1): 9,
+    (5, 77, 5, 1): 9,
+    (28, 23, 15, 1): 5,
+    (35, 41, 7, 1): 5,
+    (66, 4, 2, 1): 11,
+}
+
+
+class SourceFormatError(ValueError):
+    """Raised when a supposedly verbatim QAC source file is malformed."""
+
+
+def parse_source_record(line: str, line_number: int) -> dict[str, Any]:
+    """Parse one tab-separated QAC v0.4 record without changing its source values."""
+    try:
+        location, form, tag, feature_text = line.split("\t")
+        chapter, verse, word, part = map(int, location.strip("()").split(":"))
+    except ValueError as error:
+        raise SourceFormatError(f"Malformed morphology record on line {line_number}") from error
+
+    record: dict[str, Any] = {
+        "CHAPTER": chapter,
+        "VERSE": verse,
+        "WORD": word,
+        "WORD_PART": part,
+        "TAG": tag,
+        "FORM": form,
+        "FEATURES": feature_text,
+    }
+    features: list[str] = []
+    for feature in feature_text.split("|"):
+        if ":" in feature:
+            key, value = feature.split(":", 1)
+            record[key] = value
+        else:
+            features.append(feature)
+    record["SOURCE_FEATURES"] = features
+    return record
+
+
+def load_source_records(path: Path) -> list[dict[str, Any]]:
+    """Load every annotation record from a verbatim QAC v0.4 text file."""
+    records: list[dict[str, Any]] = []
+    with path.open(encoding="utf-8", newline="") as handle:
+        for line_number, raw_line in enumerate(handle, 1):
+            line = raw_line.rstrip("\r\n")
+            if line.startswith("("):
+                records.append(parse_source_record(line, line_number))
+    if not records:
+        raise SourceFormatError(f"No morphology records found in {path}")
+    return records
+
+
+def normalize_record(record: dict[str, Any]) -> dict[str, Any]:
+    """Construct one derived record while retaining the original annotation fields."""
+    result = {key: value for key, value in record.items() if key != "SOURCE_FEATURES"}
+    features: list[str] = record["SOURCE_FEATURES"]
+    address = (record["CHAPTER"], record["VERSE"], record["WORD"], record["WORD_PART"])
+
+    verb_form = next(
+        (
+            feature[1:-1]
+            for feature in features
+            if feature.startswith("(") and feature.endswith(")")
+        ),
+        None,
+    )
+    if verb_form is None and record.get("POS") == "V":
+        verb_form = "I"
+    if verb_form is not None:
+        if len(record.get("ROOT", "")) == 4:
+            verb_form = "r" + verb_form
+        result["VERB_FORM"] = verb_form
+
+    for feature in features:
+        if feature in CONJUGATION:
+            result["CONJUGATE"] = CONJUGATION[feature]
+            break
+    if address in CONJUGATION_OVERRIDES:
+        result["CONJUGATE"] = CONJUGATION_OVERRIDES[address]
+
+    for case in ("GEN", "NOM", "ACC"):
+        if case in features:
+            result["CASE"] = case
+            break
+    if record.get("MOOD") == "SUBJ":
+        result["CASE"] = "ACC"
+    elif record.get("MOOD") == "JUS":
+        result["CASE"] = "JUS"
+    elif "IMPF" in features and "CASE" not in result:
+        result["CASE"] = "NOM"
+    elif "IMPV" in features:
+        result["CASE"] = "MABNI"
+
+    for feature in features:
+        if feature in TOKEN_ROLE:
+            result["TOKEN_ROLE"] = TOKEN_ROLE[feature]
+            break
+    if "3D" in features:
+        result["PRON"] = "3D"
+
+    for source_value, aspect in ASPECT.items():
+        if source_value in features:
+            result["ASPECT"] = aspect
+            result["TENSE"] = TENSE[source_value]
+            break
+
+    if record.get("POS") == "V":
+        result["VOICE"] = "PASSIVE" if "PASS" in features else "ACTIVE"
+
+    for feature in features:
+        if feature in GENDER:
+            result["GENDER"] = GENDER[feature]
+            break
+    for feature in features:
+        if feature in COUNT:
+            result["COUNT"] = COUNT[feature]
+            break
+    if "PCPL" in features:
+        if "ACT" in features:
+            result["DERIVED_NOUN"] = "VERB_SUBJECT"
+        elif "PASS" in features:
+            result["DERIVED_NOUN"] = "VERB_OBJECT"
+    if "VN" in features:
+        result["DERIVED_NOUN"] = "VERBAL_NOUN"
+    if "INDEF" in features:
+        result["DEFINITENESS"] = "INDEFINITE"
+    if "P" in features:
+        result["COUNT"] = "PLURAL"
+        result["UNUSUAL_PLURAL_ORIGINALLY_P_FEATURE"] = True
+    return result
+
+
+def rebuild_records(source_records: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Derive convenience fields for every parsed source record in order."""
+    return [normalize_record(record) for record in source_records]
+
+
+def canonical_records_bytes(records: list[dict[str, Any]]) -> bytes:
+    """Return the stable byte representation used for cache and reproducibility checks."""
+    return json.dumps(records, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
+
+
+def records_digest(records: list[dict[str, Any]]) -> str:
+    """Return the SHA-256 of the canonical complete derived representation."""
+    return hashlib.sha256(canonical_records_bytes(records)).hexdigest()
+
+
+def write_records(records: list[dict[str, Any]], output: Path) -> None:
+    """Atomically write derived records without touching the source data."""
+    output.parent.mkdir(parents=True, exist_ok=True)
+    descriptor, temporary_name = tempfile.mkstemp(
+        prefix=output.name + ".", suffix=".tmp", dir=output.parent
+    )
+    try:
+        with os.fdopen(descriptor, "wb") as handle:
+            handle.write(canonical_records_bytes(records))
+        os.replace(temporary_name, output)
+    except BaseException:
+        with suppress(FileNotFoundError):
+            os.unlink(temporary_name)
+        raise
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Run deterministic verification and/or write an explicit derived artifact."""
+    from .source_data import default_data_directory, verify_data_directory
+
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--data-dir", type=Path)
+    parser.add_argument("--output", type=Path, help="Write derived JSON to this explicit path")
+    parser.add_argument("--check", action="store_true", help="Verify source and derived records")
+    arguments = parser.parse_args(argv)
+    if not arguments.check and not arguments.output:
+        parser.error("choose --check and/or --output")
+
+    data_dir = arguments.data_dir or default_data_directory()
+    manifest = verify_data_directory(data_dir)
+    source = manifest["sources"]["morphology"]
+    records = rebuild_records(load_source_records(data_dir / source["filename"]))
+    if len(records) != source["records"]:
+        print(f"Derived record count differs: {len(records):,} != {source['records']:,}")
+        return 1
+    digest = records_digest(records)
+    if arguments.check:
+        expected = SUPPORTED_DERIVED_DIGESTS.get(source["sha256"])
+        if expected is None or digest != expected:
+            print(f"Derived digest mismatch: {digest} != {expected or 'unsupported source'}")
+            return 1
+        print(
+            f"Verified source {source['sha256']} and deterministically derived "
+            f"{len(records):,} records ({digest})"
+        )
+    if arguments.output:
+        write_records(records, arguments.output)
+        print(f"Wrote {len(records):,} locally derived records to {arguments.output}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

quran_processing_toolkit/chapter_names.py

@@ -0,0 +1,142 @@
+"""Conventional chapter labels; source attribution is in THIRD_PARTY_NOTICES.md.
+
+Arabic/English labels and verse counts: Tanzil metadata v1.0, (C) 2008-2009
+Tanzil.info, upstream license identifier cc-by (version unspecified).
+ASCII transliterations are this project's conventional labels.
+Source: https://tanzil.net/res/text/metadata/quran-data.xml
+Source SHA-256: 8867c1d88191472adec9db694b3cd9f135b1a2ef580574d32cf888dcb22c5c7a
+"""
+
+from __future__ import annotations
+
+# (ASCII transliteration, Arabic name, English meaning, verse count)
+CHAPTERS: tuple[tuple[str, str, str, int], ...] = (
+    ("al-Fatihah", "الفاتحة", "The Opening", 7),
+    ("al-Baqarah", "البقرة", "The Cow", 286),
+    ("Al Imran", "آل عمران", "The Family of Imraan", 200),
+    ("an-Nisa", "النساء", "The Women", 176),
+    ("al-Maidah", "المائدة", "The Table", 120),
+    ("al-Anam", "الأنعام", "The Cattle", 165),
+    ("al-Araf", "الأعراف", "The Heights", 206),
+    ("al-Anfal", "الأنفال", "The Spoils of War", 75),
+    ("at-Tawbah", "التوبة", "The Repentance", 129),
+    ("Yunus", "يونس", "Jonas", 109),
+    ("Hud", "هود", "Hud", 123),
+    ("Yusuf", "يوسف", "Joseph", 111),
+    ("ar-Rad", "الرعد", "The Thunder", 43),
+    ("Ibrahim", "ابراهيم", "Abraham", 52),
+    ("al-Hijr", "الحجر", "The Rock", 99),
+    ("an-Nahl", "النحل", "The Bee", 128),
+    ("al-Isra", "الإسراء", "The Night Journey", 111),
+    ("al-Kahf", "الكهف", "The Cave", 110),
+    ("Maryam", "مريم", "Mary", 98),
+    ("Ta-Ha", "طه", "Taa-Haa", 135),
+    ("al-Anbiya", "الأنبياء", "The Prophets", 112),
+    ("al-Hajj", "الحج", "The Pilgrimage", 78),
+    ("al-Muminun", "المؤمنون", "The Believers", 118),
+    ("an-Nur", "النور", "The Light", 64),
+    ("al-Furqan", "الفرقان", "The Criterion", 77),
+    ("ash-Shuara", "الشعراء", "The Poets", 227),
+    ("an-Naml", "النمل", "The Ant", 93),
+    ("al-Qasas", "القصص", "The Stories", 88),
+    ("al-Ankabut", "العنكبوت", "The Spider", 69),
+    ("ar-Rum", "الروم", "The Romans", 60),
+    ("Luqman", "لقمان", "Luqman", 34),
+    ("as-Sajdah", "السجدة", "The Prostration", 30),
+    ("al-Ahzab", "الأحزاب", "The Clans", 73),
+    ("Saba", "سبإ", "Sheba", 54),
+    ("Fatir", "فاطر", "The Originator", 45),
+    ("Ya-Sin", "يس", "Yaseen", 83),
+    ("as-Saffat", "الصافات", "Those drawn up in Ranks", 182),
+    ("Sad", "ص", "The letter Saad", 88),
+    ("az-Zumar", "الزمر", "The Groups", 75),
+    ("Ghafir", "غافر", "The Forgiver", 85),
+    ("Fussilat", "فصلت", "Explained in detail", 54),
+    ("ash-Shura", "الشورى", "Consultation", 53),
+    ("az-Zukhruf", "الزخرف", "Ornaments of gold", 89),
+    ("ad-Dukhan", "الدخان", "The Smoke", 59),
+    ("al-Jathiyah", "الجاثية", "Crouching", 37),
+    ("al-Ahqaf", "الأحقاف", "The Dunes", 35),
+    ("Muhammad", "محمد", "Muhammad", 38),
+    ("al-Fath", "الفتح", "The Victory", 29),
+    ("al-Hujurat", "الحجرات", "The Inner Apartments", 18),
+    ("Qaf", "ق", "The letter Qaaf", 45),
+    ("adh-Dhariyat", "الذاريات", "The Winnowing Winds", 60),
+    ("at-Tur", "الطور", "The Mount", 49),
+    ("an-Najm", "النجم", "The Star", 62),
+    ("al-Qamar", "القمر", "The Moon", 55),
+    ("ar-Rahman", "الرحمن", "The Beneficent", 78),
+    ("al-Waqiah", "الواقعة", "The Inevitable", 96),
+    ("al-Hadid", "الحديد", "The Iron", 29),
+    ("al-Mujadilah", "المجادلة", "The Pleading Woman", 22),
+    ("al-Hashr", "الحشر", "The Exile", 24),
+    ("al-Mumtahanah", "الممتحنة", "She that is to be examined", 13),
+    ("as-Saff", "الصف", "The Ranks", 14),
+    ("al-Jumuah", "الجمعة", "Friday", 11),
+    ("al-Munafiqun", "المنافقون", "The Hypocrites", 11),
+    ("at-Taghabun", "التغابن", "Mutual Disillusion", 18),
+    ("at-Talaq", "الطلاق", "Divorce", 12),
+    ("at-Tahrim", "التحريم", "The Prohibition", 12),
+    ("al-Mulk", "الملك", "The Sovereignty", 30),
+    ("al-Qalam", "القلم", "The Pen", 52),
+    ("al-Haqqah", "الحاقة", "The Reality", 52),
+    ("al-Maarij", "المعارج", "The Ascending Stairways", 44),
+    ("Nuh", "نوح", "Noah", 28),
+    ("al-Jinn", "الجن", "The Jinn", 28),
+    ("al-Muzzammil", "المزمل", "The Enshrouded One", 20),
+    ("al-Muddaththir", "المدثر", "The Cloaked One", 56),
+    ("al-Qiyamah", "القيامة", "The Resurrection", 40),
+    ("al-Insan", "الانسان", "Man", 31),
+    ("al-Mursalat", "المرسلات", "The Emissaries", 50),
+    ("an-Naba", "النبإ", "The Announcement", 40),
+    ("an-Naziat", "النازعات", "Those who drag forth", 46),
+    ("Abasa", "عبس", "He frowned", 42),
+    ("at-Takwir", "التكوير", "The Overthrowing", 29),
+    ("al-Infitar", "الإنفطار", "The Cleaving", 19),
+    ("al-Mutaffifin", "المطففين", "Defrauding", 36),
+    ("al-Inshiqaq", "الإنشقاق", "The Splitting Open", 25),
+    ("al-Buruj", "البروج", "The Constellations", 22),
+    ("at-Tariq", "الطارق", "The Morning Star", 17),
+    ("al-Ala", "الأعلى", "The Most High", 19),
+    ("al-Ghashiyah", "الغاشية", "The Overwhelming", 26),
+    ("al-Fajr", "الفجر", "The Dawn", 30),
+    ("al-Balad", "البلد", "The City", 20),
+    ("ash-Shams", "الشمس", "The Sun", 15),
+    ("al-Layl", "الليل", "The Night", 21),
+    ("ad-Duha", "الضحى", "The Morning Hours", 11),
+    ("ash-Sharh", "الشرح", "The Consolation", 8),
+    ("at-Tin", "التين", "The Fig", 8),
+    ("al-Alaq", "العلق", "The Clot", 19),
+    ("al-Qadr", "القدر", "The Power, Fate", 5),
+    ("al-Bayyinah", "البينة", "The Evidence", 8),
+    ("az-Zalzalah", "الزلزلة", "The Earthquake", 8),
+    ("al-Adiyat", "العاديات", "The Chargers", 11),
+    ("al-Qariah", "القارعة", "The Calamity", 11),
+    ("at-Takathur", "التكاثر", "Competition", 8),
+    ("al-Asr", "العصر", "The Declining Day, Epoch", 3),
+    ("al-Humazah", "الهمزة", "The Traducer", 9),
+    ("al-Fil", "الفيل", "The Elephant", 5),
+    ("Quraysh", "قريش", "Quraysh", 4),
+    ("al-Maun", "الماعون", "Almsgiving", 7),
+    ("al-Kawthar", "الكوثر", "Abundance", 3),
+    ("al-Kafirun", "الكافرون", "The Disbelievers", 6),
+    ("an-Nasr", "النصر", "Divine Support", 3),
+    ("al-Masad", "المسد", "The Palm Fibre", 5),
+    ("al-Ikhlas", "الإخلاص", "Sincerity", 4),
+    ("al-Falaq", "الفلق", "The Dawn", 5),
+    ("an-Nas", "الناس", "Mankind", 6),
+)
+
+
+def chapter_name(number: int, representation: str = "transliteration") -> str:
+    """Return a chapter name in transliteration, Arabic, or English."""
+    if isinstance(number, bool) or not isinstance(number, int) or not 1 <= number <= 114:
+        raise ValueError("chapter number must be an integer from 1 through 114")
+    aliases = {"transliteration": 0, "ascii": 0, "arabic": 1, "english": 2, "translation": 2}
+    try:
+        index = aliases[representation.lower()]
+    except KeyError as error:
+        raise ValueError(
+            "name representation must be transliteration, arabic, or english"
+        ) from error
+    return str(CHAPTERS[number - 1][index])

quran_processing_toolkit/cli.py

@@ -0,0 +1,95 @@
+"""Command-line inspection, text search, provenance, and validation utilities."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from .corpus import QuranCorpus
+from .validation import validate_corpus
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Run the ``quran-toolkit`` command and return a process exit status."""
+    parser = argparse.ArgumentParser(prog="quran-toolkit")
+    parser.add_argument("--data-dir", type=Path)
+    parser.add_argument("--translation", type=Path, help="User-supplied numbered translation")
+    commands = parser.add_subparsers(dest="command", required=True)
+    commands.add_parser("stats", help="Show corpus object counts")
+    commands.add_parser("sources", help="Show source provenance and licenses")
+    commands.add_parser("validate", help="Validate structure and reproducibility")
+    word_parser = commands.add_parser("word", help="Inspect a word at chapter:verse:word")
+    word_parser.add_argument("address")
+    search_parser = commands.add_parser("search", help="Search Arabic or Buckwalter text")
+    search_parser.add_argument("text")
+    search_parser.add_argument("--level", choices=("verse", "word"), default="verse")
+    search_parser.add_argument(
+        "--representation",
+        choices=("auto", "arabic", "buckwalter", "transliteration", "translation", "english"),
+        default="auto",
+    )
+    search_parser.add_argument("--strip-diacritics", action="store_true")
+    search_parser.add_argument("--strip-quranic-marks", action="store_true")
+    search_parser.add_argument("--normalize-alif", action="store_true")
+    search_parser.add_argument("--normalize-ya", action="store_true")
+    search_parser.add_argument("--remove-spaces", action="store_true")
+    search_parser.add_argument("--limit", type=int, default=20)
+    arguments = parser.parse_args(argv)
+
+    if arguments.command == "validate":
+        issues = validate_corpus(arguments.data_dir)
+        if not issues:
+            print("Corpus validation passed")
+            return 0
+        for issue in issues:
+            print(f"{issue.severity.upper()} [{issue.code}] {issue.message}")
+        return int(any(issue.severity == "error" for issue in issues))
+
+    corpus = QuranCorpus.load(arguments.data_dir, translation=arguments.translation)
+    if arguments.command == "stats":
+        for label, count in corpus.stats().items():
+            print(f"{label}: {count:,}")
+        return 0
+    if arguments.command == "search":
+        if arguments.limit < 0:
+            parser.error("--limit cannot be negative")
+        results = corpus.search(
+            arguments.text,
+            level=arguments.level,
+            representation=arguments.representation,
+            strip_diacritics=arguments.strip_diacritics,
+            strip_quranic_marks=arguments.strip_quranic_marks,
+            normalize_alif=arguments.normalize_alif,
+            normalize_ya=arguments.normalize_ya,
+            remove_spaces=arguments.remove_spaces,
+        )
+        results.show(
+            arguments.representation if arguments.representation != "auto" else "arabic",
+            limit=arguments.limit,
+        )
+        print(f"matches: {len(results):,}")
+        return 0
+    if arguments.command == "sources":
+        for source in corpus.provenance()["sources"].values():
+            print(f"{source['title']} {source.get('version', '')}".rstrip())
+            print(f"  SHA-256: {source['sha256']}")
+            print(f"  license: {source['license']}")
+            if source.get("official_url"):
+                print(f"  source: {source['official_url']}")
+        return 0
+    try:
+        chapter, verse, word = map(int, arguments.address.strip("()").split(":"))
+    except ValueError:
+        parser.error("word address must have the form chapter:verse:word")
+    item = corpus.word(chapter, verse, word)
+    print(f"address: {item.address}")
+    print(f"arabic: {item.arabic_text}")
+    print(f"transliteration: {item.transliteration}")
+    print(f"parts of speech: {item.parts_of_speech}")
+    print(f"roots: {item.roots}")
+    print(f"lemmas: {item.lemmas}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())