scriptconv 0.0.3a6__tar.gz → 0.0.3a8__tar.gz

{scriptconv-0.0.3a6 → scriptconv-0.0.3a8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptconv
-Version: 0.0.3a6
+Version: 0.0.3a8
 Summary: Zero-dependency script & phoneme-notation core — ISO-15924 detection & metadata, IPA↔ARPABET/X-SAMPA/Lexique/Kirshenbaum/Cotovía/RFE, Buckwalter↔Arabic, Hangul→jamo, kana
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/TigreGotico/scriptconv

{scriptconv-0.0.3a6 → scriptconv-0.0.3a8}/scriptconv/__init__.py

@@ -22,6 +22,14 @@ readings:
     extra; Chinese hanzi → pinyin/bopomofo via the ``zh`` extra).
 cangjie:
     Hanzi → Cangjie5 input codes (shape decomposition, vendored table).
+graph:
+    Conversion-graph engine: representations (notations and orthographies)
+    as nodes, registered transforms as edges, lossless-preferring routing.
+    External packages extend graph instances explicitly.
+conventions:
+    Orthographic conventions — script-scoped decorations orthogonal to
+    identity (tashkeel, niqqud, wakachigaki, pinyin tone spelling…).
+    Scripts are nodes; conventions are parameters, never nodes.
 
 Zero required runtime dependencies (stdlib only); the readings module
 needs the optional ``ja``/``zh`` extras.
@@ -75,6 +83,23 @@ from scriptconv.readings import (
     to_pinyin,
     to_bopomofo,
 )
+from scriptconv.conventions import (
+    Convention,
+    Transition,
+    CONVENTION_REGISTRY,
+    conventions_for,
+    restyle,
+    strip,
+    apply,
+    detect as detect_convention,
+)
+from scriptconv.graph import (
+    Representation,
+    Edge,
+    ConversionGraph,
+    DEFAULT_GRAPH,
+    REPRESENTATIONS,
+)
 from scriptconv.cangjie import (
     cangjie_code,
     to_cangjie,
@@ -123,6 +148,21 @@ __all__ = [
     "tokens",
     "to_hiragana",
     "to_katakana",
+    # conventions (orthographic decorations, orthogonal to script identity)
+    "Convention",
+    "Transition",
+    "CONVENTION_REGISTRY",
+    "conventions_for",
+    "restyle",
+    "strip",
+    "apply",
+    "detect_convention",
+    # graph (conversion routing engine over representations)
+    "Representation",
+    "Edge",
+    "ConversionGraph",
+    "DEFAULT_GRAPH",
+    "REPRESENTATIONS",
     # cangjie (vendored Cangjie5 table)
     "cangjie_code",
     "to_cangjie",

{scriptconv-0.0.3a6 → scriptconv-0.0.3a8}/scriptconv/__main__.py

@@ -8,6 +8,10 @@ Usage
     python -m scriptconv direction <text>
     python -m scriptconv decompose <text>
     python -m scriptconv lang <code>
+    python -m scriptconv strip <convention> <text>
+    python -m scriptconv restyle <convention> <style> <text>
+    python -m scriptconv conventions [--script CODE]
+    python -m scriptconv route <src> <dst>
 
 Examples
 --------
@@ -48,6 +52,23 @@ def main(argv: list[str] | None = None) -> int:
     lang = sub.add_parser("lang", help="Map language code to script")
     lang.add_argument("code", help="BCP-47 or ISO 639 language code")
 
+    st = sub.add_parser("strip", help="Remove an orthographic convention's decoration")
+    st.add_argument("convention", help="Convention id (see `conventions`)")
+    st.add_argument("text", help="Text to strip")
+
+    rs = sub.add_parser("restyle", help="Rewrite text between a convention's styles")
+    rs.add_argument("convention", help="Convention id (see `conventions`)")
+    rs.add_argument("to", help="Target style")
+    rs.add_argument("text", help="Text to restyle")
+    rs.add_argument("--from", dest="frm", default=None, help="Source style")
+
+    cv = sub.add_parser("conventions", help="List orthographic conventions")
+    cv.add_argument("--script", default=None, help="Filter by ISO-15924 script code")
+
+    rt = sub.add_parser("route", help="Show the conversion path between representations")
+    rt.add_argument("src", help="Source representation id")
+    rt.add_argument("dst", help="Target representation id")
+
     args = p.parse_args(argv)
 
     if args.command is None:
@@ -61,6 +82,10 @@ def main(argv: list[str] | None = None) -> int:
         "direction": lambda: _do_direction(args),
         "decompose": lambda: _do_decompose(args),
         "lang": lambda: _do_lang(args),
+        "strip": lambda: _do_strip(args),
+        "restyle": lambda: _do_restyle(args),
+        "conventions": lambda: _do_conventions(args),
+        "route": lambda: _do_route(args),
     }
     dispatch[args.command]()
     return 0
@@ -70,9 +95,31 @@ def _do_convert(args: argparse.Namespace) -> None:
     from scriptconv.notation import Notation, convert
     try:
         print(convert(args.text, args.src, args.dst))
+        return
+    except ValueError:
+        pass
+    # not a notation pair — try any representation pair on the default graph
+    from scriptconv.graph import DEFAULT_GRAPH
+    try:
+        print(DEFAULT_GRAPH.convert(args.text, args.src, args.dst))
     except ValueError as e:
         valid = ", ".join(n.value for n in Notation)
-        raise SystemExit(f"error: {e} (valid notations: {valid})")
+        raise SystemExit(f"error: {e} (valid notations: {valid}; "
+                         f"graph nodes: {', '.join(DEFAULT_GRAPH.nodes)})")
+
+
+def _do_route(args: argparse.Namespace) -> None:
+    from scriptconv.graph import DEFAULT_GRAPH
+    try:
+        path = DEFAULT_GRAPH.route(args.src, args.dst)
+    except ValueError as e:
+        raise SystemExit(f"error: {e}")
+    if not path:
+        print("(identity)")
+    for e in path:
+        flags = "lossless" if e.lossless else "lossy"
+        extra = f", needs scriptconv[{e.requires}]" if e.requires else ""
+        print(f"  {e.src} -> {e.dst}  ({flags}, cost {e.cost:g}{extra})")
 
 
 def _do_detect(args: argparse.Namespace) -> None:
@@ -100,6 +147,34 @@ def _do_decompose(args: argparse.Namespace) -> None:
     print(decompose_hangul(args.text))
 
 
+def _do_strip(args: argparse.Namespace) -> None:
+    from scriptconv.conventions import strip
+    try:
+        print(strip(args.text, args.convention))
+    except ValueError as e:
+        raise SystemExit(f"error: {e}")
+
+
+def _do_restyle(args: argparse.Namespace) -> None:
+    from scriptconv.conventions import restyle
+    try:
+        print(restyle(args.text, args.convention, args.to, frm=args.frm))
+    except ValueError as e:
+        raise SystemExit(f"error: {e}")
+
+
+def _do_conventions(args: argparse.Namespace) -> None:
+    from scriptconv.conventions import CONVENTION_REGISTRY, conventions_for
+    convs = (conventions_for(args.script) if args.script
+             else list(CONVENTION_REGISTRY.values()))
+    if not convs:
+        print("(no conventions registered for that script)")
+    for c in convs:
+        system = f" [{c.system}]" if c.system else ""
+        print(f"  {c.id}{system}  scripts={','.join(c.scripts)}  "
+              f"styles={','.join(c.styles)}  — {c.name}")
+
+
 def _do_lang(args: argparse.Namespace) -> None:
     from scriptconv.scripts import lang_to_script
     print(lang_to_script(args.code) or "(unknown)")