scriptconv 0.0.3a9__tar.gz → 0.0.3a11__tar.gz

{scriptconv-0.0.3a9 → scriptconv-0.0.3a11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptconv
-Version: 0.0.3a9
+Version: 0.0.3a11
 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
@@ -210,7 +210,7 @@ below describes the per-converter default.
 
 | Notation | `to_ipa` → `from_ipa` round-trip | `from_ipa` → `to_ipa` round-trip | Unknown-token behaviour |
 |----------|----------------------------------|----------------------------------|-------------------------|
-| **ARPABET** | Exact for base symbols; **stress digits are dropped** and `AH0`↔`AX` (schwa) is not distinguished | **Lossy** — ARPABET is an English-only inventory, so any IPA symbol outside it becomes the *unknown* placeholder | `arpa_to_ipa`: passed through unchanged. `ipa_to_arpa`: diacritics and suprasegmentals (combining marks, length/stress modifiers) are dropped; other out-of-inventory symbols are replaced with `?` by default (`unknown=` param; `unknown=""` drops) |
+| **ARPABET** | **Lossless with `stress=True`** (digits ↔ IPA `ˈ`/`ˌ` before the stressed vowel; residues: extended-ARPABET `AX` normalises to CMUdict's `AH0` spelling, and `AH0 R` fuses to the r-colored `AXR0` — stable from the IPA side). Default `stress=False` drops digits and merges `AH0`↔`AX` | **Lossy** — ARPABET is an English-only inventory, so any IPA symbol outside it becomes the *unknown* placeholder | `arpa_to_ipa`: passed through unchanged. `ipa_to_arpa`: diacritics and suprasegmentals are dropped; other out-of-inventory symbols follow `errors=` (default `"replace"` → `?`) |
 | **X-SAMPA** | Exact for all canonical symbols | Exact except aliases (`f\`→ɸ, `&`→æ) normalise to their canonical spelling | Passed through unchanged |
 | **Buckwalter ↔ Arabic** | Exact (the `^` shadda alias normalises to canonical `~`; precomposed lam-alef ligatures decompose to two chars, visually identical) | Exact | Passed through unchanged |
 | **Lexique ↔ IPA** | Exact except the `°`/`3` schwa pair (both → `ə`; reverse always → `°`) | Exact | Passed through unchanged |

{scriptconv-0.0.3a9 → scriptconv-0.0.3a11}/README.md

@@ -177,7 +177,7 @@ below describes the per-converter default.
 
 | Notation | `to_ipa` → `from_ipa` round-trip | `from_ipa` → `to_ipa` round-trip | Unknown-token behaviour |
 |----------|----------------------------------|----------------------------------|-------------------------|
-| **ARPABET** | Exact for base symbols; **stress digits are dropped** and `AH0`↔`AX` (schwa) is not distinguished | **Lossy** — ARPABET is an English-only inventory, so any IPA symbol outside it becomes the *unknown* placeholder | `arpa_to_ipa`: passed through unchanged. `ipa_to_arpa`: diacritics and suprasegmentals (combining marks, length/stress modifiers) are dropped; other out-of-inventory symbols are replaced with `?` by default (`unknown=` param; `unknown=""` drops) |
+| **ARPABET** | **Lossless with `stress=True`** (digits ↔ IPA `ˈ`/`ˌ` before the stressed vowel; residues: extended-ARPABET `AX` normalises to CMUdict's `AH0` spelling, and `AH0 R` fuses to the r-colored `AXR0` — stable from the IPA side). Default `stress=False` drops digits and merges `AH0`↔`AX` | **Lossy** — ARPABET is an English-only inventory, so any IPA symbol outside it becomes the *unknown* placeholder | `arpa_to_ipa`: passed through unchanged. `ipa_to_arpa`: diacritics and suprasegmentals are dropped; other out-of-inventory symbols follow `errors=` (default `"replace"` → `?`) |
 | **X-SAMPA** | Exact for all canonical symbols | Exact except aliases (`f\`→ɸ, `&`→æ) normalise to their canonical spelling | Passed through unchanged |
 | **Buckwalter ↔ Arabic** | Exact (the `^` shadda alias normalises to canonical `~`; precomposed lam-alef ligatures decompose to two chars, visually identical) | Exact | Passed through unchanged |
 | **Lexique ↔ IPA** | Exact except the `°`/`3` schwa pair (both → `ə`; reverse always → `°`) | Exact | Passed through unchanged |

{scriptconv-0.0.3a9 → scriptconv-0.0.3a11}/scriptconv/notation.py

@@ -157,6 +157,11 @@ _IPA_TO_ARPA.setdefault("g", "G")
 _IPA_ARPA_KEYS_SORTED = sorted(_IPA_TO_ARPA.keys(), key=len, reverse=True)
 _IPA_ARPA_RE = re.compile("|".join(re.escape(s) for s in _IPA_ARPA_KEYS_SORTED))
 
+# ARPABET vowel class — the symbols that carry stress digits.
+_ARPA_VOWELS = {"AO", "AA", "IY", "UW", "EH", "IH", "UH", "AH", "AE", "AX",
+                "EY", "AY", "OW", "AW", "OY", "ER", "AXR"}
+_STRESS_MARKS = {"ˈ": "1", "ˌ": "2"}  # IPA primary/secondary stress
+
 
 
 class UnknownSymbolError(ValueError):
@@ -187,12 +192,18 @@ def _unknown(symbol: str, position: int, notation: str, errors: str,
     raise ValueError(f"errors must be one of {_ERROR_POLICIES}, not {errors!r}")
 
 
-def arpa_to_ipa(arpa_sequence: str, errors: str = "pass") -> str:
+def arpa_to_ipa(arpa_sequence: str, errors: str = "pass",
+                stress: bool = False) -> str:
     """Convert a space-separated ARPABET sequence to an IPA string.
 
-    Stress digits are stripped.  ``errors`` selects the unknown-token policy:
-    ``"pass"`` (default) keeps the token, ``"replace"`` substitutes ``?``,
-    ``"ignore"`` drops it, ``"strict"`` raises :class:`UnknownSymbolError`.
+    With ``stress=True``, ARPABET stress digits are preserved as IPA stress
+    marks placed immediately before the stressed vowel's symbol: ``AH1`` →
+    ``ˈʌ``, ``AH2`` → ``ˌʌ``, ``AH0`` → unmarked (a purely notational,
+    reversible convention — no syllabification is performed).  The default
+    ``stress=False`` keeps the historical behavior of stripping the digits.
+    ``errors`` selects the unknown-token policy: ``"pass"`` (default) keeps
+    the token, ``"replace"`` substitutes ``?``, ``"ignore"`` drops it,
+    ``"strict"`` raises :class:`UnknownSymbolError`.
 
     Examples
     --------
@@ -202,6 +213,9 @@ def arpa_to_ipa(arpa_sequence: str, errors: str = "pass") -> str:
     tokens = arpa_sequence.strip().split()
     result = []
     for i, tok in enumerate(tokens):
+        mark = ""
+        if stress and tok[-1:] in ("1", "2") and tok[:-1] in _ARPA_VOWELS:
+            mark = "ˈ" if tok[-1] == "1" else "ˌ"
         ipa = _ARPA_TO_IPA.get(tok)
         if ipa is None:
             # strip trailing digit and retry
@@ -209,19 +223,24 @@ def arpa_to_ipa(arpa_sequence: str, errors: str = "pass") -> str:
             ipa = _ARPA_TO_IPA.get(stripped)
         if ipa is None:
             ipa = _unknown(tok, i, "arpa", errors)
-        result.append(ipa)
+            mark = ""
+        result.append(mark + ipa)
     return "".join(result)
 
 
 def ipa_to_arpa(ipa_string: str, unknown: str = "?",
-                errors: str = "replace") -> str:
+                errors: str = "replace", stress: bool = False) -> str:
     """Convert an IPA string to a space-separated ARPABET sequence.
 
-    Matches longest IPA symbol first.  ``errors`` selects the unknown-symbol
-    policy (default ``"replace"``, preserving the historical behavior of
-    substituting *unknown*, ``"?"``); ``unknown=""`` still drops silently.
-    Combining marks and modifier letters qualify the preceding phoneme and
-    are always dropped rather than treated as unknowns.
+    Matches longest IPA symbol first.  With ``stress=True``, IPA stress
+    marks (``ˈ``/``ˌ``) preceding a vowel-class symbol are emitted as that
+    vowel's stress digit (``1``/``2``) and unmarked vowels receive ``0`` —
+    the reverse of :func:`arpa_to_ipa`'s ``stress=True`` convention.
+    ``errors`` selects the unknown-symbol policy (default ``"replace"``,
+    preserving the historical behavior of substituting *unknown*, ``"?"``);
+    ``unknown=""`` still drops silently.  Combining marks and modifier
+    letters qualify the preceding phoneme and are always dropped rather
+    than treated as unknowns.
 
     Examples
     --------
@@ -231,11 +250,25 @@ def ipa_to_arpa(ipa_string: str, unknown: str = "?",
     '?'
     """
     tokens = []
+    pending_stress = ""
     pos = 0
     while pos < len(ipa_string):
+        if stress and ipa_string[pos] in _STRESS_MARKS:
+            pending_stress = _STRESS_MARKS[ipa_string[pos]]
+            pos += 1
+            continue
         m = _IPA_ARPA_RE.match(ipa_string, pos)
         if m:
-            tokens.append(_IPA_TO_ARPA[m.group(0)])
+            tok = _IPA_TO_ARPA[m.group(0)]
+            if stress and tok in _ARPA_VOWELS:
+                # CMUdict spells schwa as AH0 (it has no AX), so stress-aware
+                # output uses AH for exact round-trips; extended-ARPABET AX
+                # input still normalizes to AH0 (documented residue).
+                if m.group(0) == "ə":
+                    tok = "AH"
+                tok += pending_stress or "0"
+            pending_stress = ""
+            tokens.append(tok)
             pos = m.end()
         else:
             ch = ipa_string[pos]

{scriptconv-0.0.3a9 → scriptconv-0.0.3a11}/scriptconv/scripts.py

@@ -652,6 +652,34 @@ _LANG_TO_SCRIPT: dict[str, str] = {
     "rw": "Latn",   # Kinyarwanda
     "tk": "Latn",   # Turkmen (Latin since 1993)
     "eo": "Latn",   # Esperanto
+    # Languages with no ISO 639-1 code (keyed by their 639-3 code directly)
+    "kjh": "Cyrl",  # Khakas
+    "xal": "Cyrl",  # Kalmyk (Cyrillic since 1938)
+    "kbd": "Cyrl",  # Kabardian
+    "erz": "Cyrl",  # Erzya
+    "mdf": "Cyrl",  # Moksha
+}
+
+# ISO 639-2/3 (incl. bibliographic variants) -> the 639-1 key used above.
+# Reference: Library of Congress ISO 639-2 code list.
+_ISO639_ALIASES: dict[str, str] = {
+    "rus": "ru", "ukr": "uk", "bel": "be", "bul": "bg", "srp": "sr",
+    "mkd": "mk", "mac": "mk", "kaz": "kk", "kir": "ky", "tgk": "tg",
+    "mon": "mn", "tat": "tt", "bak": "ba", "chv": "cv", "oss": "os",
+    "che": "ce", "hye": "hy", "arm": "hy", "kat": "ka", "geo": "ka",
+    "aze": "az", "uzb": "uz", "tuk": "tk", "eng": "en", "deu": "de",
+    "ger": "de", "fra": "fr", "fre": "fr", "spa": "es", "por": "pt",
+    "ita": "it", "nld": "nl", "dut": "nl", "ell": "el", "gre": "el",
+    "ara": "ar", "heb": "he", "zho": "zh", "chi": "zh", "jpn": "ja",
+    "kor": "ko", "tur": "tr", "fas": "fa", "per": "fa", "urd": "ur",
+    "hin": "hi", "tha": "th", "vie": "vi", "pol": "pl", "ces": "cs",
+    "cze": "cs", "slk": "sk", "slo": "sk", "ron": "ro", "rum": "ro",
+    "hun": "hu", "fin": "fi", "swe": "sv", "nor": "no", "dan": "da",
+    "isl": "is", "ice": "is", "mya": "my", "bur": "my", "khm": "km",
+    "lao": "lo", "amh": "am", "tam": "ta", "tel": "te", "ben": "bn",
+    "guj": "gu", "kan": "kn", "mal": "ml", "mar": "mr", "pan": "pa",
+    "sin": "si", "nep": "ne", "eus": "eu", "baq": "eu", "cat": "ca",
+    "glg": "gl", "cym": "cy", "wel": "cy", "gle": "ga", "epo": "eo",
 }
 
 
@@ -674,14 +702,21 @@ def lang_to_script(lang: str) -> Optional[str]:
     'Latn'
     """
     subtags = lang.replace("_", "-").split("-")
-    # An explicit script subtag (4 letters, e.g. "Latn") overrides the
-    # language's default script.
+    # An explicit script subtag overrides the language's default script:
+    # 4-letter ISO-15924 codes ("sr-Latn"), and the widespread informal
+    # 3-letter forms "cyr"/"lat" ("uzb_cyr", "aze_lat").
     for sub in subtags[1:]:
+        low = sub.lower()
         if len(sub) == 4 and sub.isalpha():
             resolved = normalize_script_tag(sub)
             if resolved is not None:
                 return resolved
-    return _LANG_TO_SCRIPT.get(subtags[0].lower())
+        elif low in ("cyr", "lat"):
+            return "Cyrl" if low == "cyr" else "Latn"
+    key = subtags[0].lower()
+    if key in _LANG_TO_SCRIPT:
+        return _LANG_TO_SCRIPT[key]
+    return _LANG_TO_SCRIPT.get(_ISO639_ALIASES.get(key, ""))
 
 
 # ---------------------------------------------------------------------------

{scriptconv-0.0.3a9 → scriptconv-0.0.3a11}/scriptconv/version.py

@@ -2,7 +2,7 @@
 VERSION_MAJOR = 0
 VERSION_MINOR = 0
 VERSION_BUILD = 3
-VERSION_ALPHA = 9
+VERSION_ALPHA = 11
 # END_VERSION_BLOCK
 
 VERSION_STR = f"{VERSION_MAJOR}.{VERSION_MINOR}.{VERSION_BUILD}"

{scriptconv-0.0.3a9 → scriptconv-0.0.3a11}/scriptconv.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptconv
-Version: 0.0.3a9
+Version: 0.0.3a11
 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
@@ -210,7 +210,7 @@ below describes the per-converter default.
 
 | Notation | `to_ipa` → `from_ipa` round-trip | `from_ipa` → `to_ipa` round-trip | Unknown-token behaviour |
 |----------|----------------------------------|----------------------------------|-------------------------|
-| **ARPABET** | Exact for base symbols; **stress digits are dropped** and `AH0`↔`AX` (schwa) is not distinguished | **Lossy** — ARPABET is an English-only inventory, so any IPA symbol outside it becomes the *unknown* placeholder | `arpa_to_ipa`: passed through unchanged. `ipa_to_arpa`: diacritics and suprasegmentals (combining marks, length/stress modifiers) are dropped; other out-of-inventory symbols are replaced with `?` by default (`unknown=` param; `unknown=""` drops) |
+| **ARPABET** | **Lossless with `stress=True`** (digits ↔ IPA `ˈ`/`ˌ` before the stressed vowel; residues: extended-ARPABET `AX` normalises to CMUdict's `AH0` spelling, and `AH0 R` fuses to the r-colored `AXR0` — stable from the IPA side). Default `stress=False` drops digits and merges `AH0`↔`AX` | **Lossy** — ARPABET is an English-only inventory, so any IPA symbol outside it becomes the *unknown* placeholder | `arpa_to_ipa`: passed through unchanged. `ipa_to_arpa`: diacritics and suprasegmentals are dropped; other out-of-inventory symbols follow `errors=` (default `"replace"` → `?`) |
 | **X-SAMPA** | Exact for all canonical symbols | Exact except aliases (`f\`→ɸ, `&`→æ) normalise to their canonical spelling | Passed through unchanged |
 | **Buckwalter ↔ Arabic** | Exact (the `^` shadda alias normalises to canonical `~`; precomposed lam-alef ligatures decompose to two chars, visually identical) | Exact | Passed through unchanged |
 | **Lexique ↔ IPA** | Exact except the `°`/`3` schwa pair (both → `ə`; reverse always → `°`) | Exact | Passed through unchanged |

{scriptconv-0.0.3a9 → scriptconv-0.0.3a11}/scriptconv.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ scriptconv.egg-info/requires.txt
 scriptconv.egg-info/top_level.txt
 scriptconv/data/__init__.py
 scriptconv/data/cangjie5_tc.tsv.gz
+tests/test_arpa_stress.py
 tests/test_cangjie.py
 tests/test_cli.py
 tests/test_conventions.py
@@ -30,4 +31,5 @@ tests/test_notation.py
 tests/test_readings.py
 tests/test_readings_zh.py
 tests/test_scripts.py
+tests/test_scripts_stressonnx_compat.py
 tests/test_translit.py

scriptconv-0.0.3a11/tests/test_arpa_stress.py

@@ -0,0 +1,88 @@
+"""ARPABET stress preservation (stress=True) — reversible by construction."""
+import random
+import unittest
+
+from scriptconv.notation import _ARPA_BASE, _ARPA_VOWELS, arpa_to_ipa, ipa_to_arpa
+
+
+class TestStressForward(unittest.TestCase):
+    def test_marks_placed_before_stressed_vowel(self):
+        self.assertEqual(arpa_to_ipa("HH AH0 L OW1", stress=True), "həlˈoʊ")
+        self.assertEqual(arpa_to_ipa("K AE1 T", stress=True), "kˈæt")
+        self.assertEqual(arpa_to_ipa("AH2", stress=True), "ˌʌ")
+
+    def test_unstressed_and_consonants_unmarked(self):
+        self.assertEqual(arpa_to_ipa("AH0", stress=True), "ə")
+        self.assertEqual(arpa_to_ipa("K T", stress=True), "kt")
+
+    def test_default_still_strips(self):
+        self.assertEqual(arpa_to_ipa("HH AH0 L OW1"), "həloʊ")
+
+    def test_unknown_token_never_gets_a_mark(self):
+        self.assertEqual(arpa_to_ipa("ZZ1", stress=True), "ZZ1")
+
+
+class TestStressReverse(unittest.TestCase):
+    def test_marks_become_digits_unmarked_vowels_get_zero(self):
+        self.assertEqual(ipa_to_arpa("həlˈoʊ", stress=True), "HH AH0 L OW1")
+        self.assertEqual(ipa_to_arpa("kˈæt", stress=True), "K AE1 T")
+        self.assertEqual(ipa_to_arpa("ˌʌ", stress=True), "AH2")
+
+    def test_schwa_spelled_ah0_like_cmudict(self):
+        self.assertEqual(ipa_to_arpa("ə", stress=True), "AH0")
+
+    def test_default_still_drops_marks(self):
+        self.assertEqual(ipa_to_arpa("həlˈoʊ"), "HH AX L OW")
+
+
+class TestRoundTrip(unittest.TestCase):
+    def test_readme_example_exact(self):
+        x = "HH AH0 L OW1"
+        self.assertEqual(ipa_to_arpa(arpa_to_ipa(x, stress=True), stress=True), x)
+
+    def test_property_cmudict_legal_sequences(self):
+        """Random CMUdict-legal sequences round-trip exactly up to
+        IPA-equivalence: token sequences whose IPA concatenation is identical
+        (r-colored schwa, affricates, diphthong fusion — contiguous IPA has
+        no token boundary) may normalize to the fused spelling, and that
+        spelling must itself be IPA-stable.  The overwhelming majority
+        round-trip byte-exactly."""
+        random.seed(20260721)
+        cons = [c for c in _ARPA_BASE
+                if c not in _ARPA_VOWELS and c not in ("AX", "AXR")]
+        vows = [v for v in _ARPA_VOWELS if v not in ("AX", "AXR")]
+        exact = fused = 0
+        for _ in range(400):
+            seq = []
+            for _ in range(random.randint(1, 7)):
+                if random.random() < 0.5:
+                    seq.append(random.choice(cons))
+                else:
+                    seq.append(random.choice(vows) + random.choice("012"))
+            s = " ".join(seq)
+            ipa = arpa_to_ipa(s, stress=True)
+            rt = ipa_to_arpa(ipa, stress=True)
+            if rt == s:
+                exact += 1
+            else:
+                fused += 1
+                # fusion residue must be IPA-stable
+                self.assertEqual(arpa_to_ipa(rt, stress=True), ipa, s)
+        self.assertGreater(exact, 350)
+        self.assertLess(fused, 50)
+
+    def test_documented_residues(self):
+        # extended-ARPABET AX normalizes to CMUdict's AH0 spelling
+        self.assertEqual(
+            ipa_to_arpa(arpa_to_ipa("AX", stress=True), stress=True), "AH0")
+        # schwa+R fuses to the r-colored vowel; stable from the IPA side
+        fused = ipa_to_arpa(arpa_to_ipa("AH0 R", stress=True), stress=True)
+        self.assertEqual(fused, "AXR0")
+        # affricate fusion exists in default mode too (contiguous IPA)
+        self.assertEqual(ipa_to_arpa(arpa_to_ipa("T SH")), "CH")
+        self.assertEqual(arpa_to_ipa(fused, stress=True),
+                         arpa_to_ipa("AH0 R", stress=True))
+
+
+if __name__ == "__main__":
+    unittest.main()

scriptconv-0.0.3a11/tests/test_scripts_stressonnx_compat.py

@@ -0,0 +1,47 @@
+"""Downstream compat: the script tags scriptconv returns are a wire format.
+
+stressonnx (accentor.py) maps its supported languages to a private script
+taxonomy that mirrors phoonnx's Alphabet enum.  These fixtures pin, key by
+key, that scriptconv resolves every one of those language codes to the
+expected ISO-15924 tag — so stressonnx's migration to scriptconv is a pure
+deletion, and future edits here cannot silently break it.
+"""
+import pytest
+
+from scriptconv import lang_to_script
+
+# stressonnx LANG_SCRIPT, verbatim keys -> the ISO-15924 tag its Script
+# enum value corresponds to (cyrillic->Cyrl, latin->Latn, armenian->Armn,
+# georgian->Geor).
+STRESSONNX_LANGS = {
+    "ru": "Cyrl", "ukr": "Cyrl", "bel": "Cyrl", "bel_simple": "Cyrl",
+    "kaz": "Cyrl", "tat": "Cyrl", "bak": "Cyrl", "chv": "Cyrl",
+    "sah": "Cyrl", "kir": "Cyrl", "kjh": "Cyrl", "tgk": "Cyrl",
+    "udm": "Cyrl", "xal": "Cyrl", "kbd": "Cyrl", "erz": "Cyrl",
+    "mdf": "Cyrl", "uzb_cyr": "Cyrl", "aze_cyr": "Cyrl",
+    "aze_lat": "Latn", "uzb_lat": "Latn",
+    "hye": "Armn",
+    "kat": "Geor",
+}
+
+
+@pytest.mark.parametrize("lang,expected", sorted(STRESSONNX_LANGS.items()))
+def test_stressonnx_language_resolves(lang, expected):
+    assert lang_to_script(lang) == expected
+
+
+def test_iso639_bibliographic_variants():
+    assert lang_to_script("ger") == lang_to_script("deu") == "Latn"
+    assert lang_to_script("gre") == lang_to_script("ell") == "Grek"
+    assert lang_to_script("arm") == lang_to_script("hye") == "Armn"
+
+
+def test_explicit_script_subtag_still_authoritative():
+    assert lang_to_script("uzb-Latn") == "Latn"
+    assert lang_to_script("sr_lat") == "Latn"
+    assert lang_to_script("sr") == "Cyrl"
+
+
+def test_unknown_language_stays_none():
+    assert lang_to_script("zzz") is None
+    assert lang_to_script("qqq_cyr") == "Cyrl"  # variant subtag wins even unknown-lang