CMT-SALanguages 1.0.0__py3-none-any.whl

CMT_SALanguages/__init__.py

@@ -0,0 +1,51 @@
+"""
+CMT-SALanguages — Programming in South Africa's Official Languages
+Developed by Mzwandile
+
+Usage:
+    from CMT_SALanguages import isizulu as CAL
+    from CMT_SALanguages import isixhosa as CAL
+    from CMT_SALanguages import afrikaans as CAL
+    from CMT_SALanguages import sesotho as CAL
+    from CMT_SALanguages import setswana as CAL
+    from CMT_SALanguages import sepedi as CAL
+    from CMT_SALanguages import siswati as CAL
+    from CMT_SALanguages import isindebele as CAL
+    from CMT_SALanguages import tshivenda as CAL
+    from CMT_SALanguages import xitsonga as CAL
+    from CMT_SALanguages import english as CAL
+
+    CAL.sebenza('phrinta("Sawubona Mzansi!")')
+"""
+
+from . import isizulu
+from . import isixhosa
+from . import afrikaans
+from . import sesotho
+from . import setswana
+from . import sepedi
+from . import siswati
+from . import isindebele
+from . import tshivenda
+from . import xitsonga
+from . import english
+
+__version__ = "1.0.0"
+__author__ = "Mzwandile Zulu"
+
+LANGUAGES = [
+    "isizulu", "isixhosa", "afrikaans", "sesotho", "setswana",
+    "sepedi", "siswati", "isindebele", "tshivenda", "xitsonga", "english",
+]
+
+__all__ = LANGUAGES + ["LANGUAGES"]
+
+
+def list_languages():
+    """Print all 11 supported South African languages."""
+    print("\nCMT-SALanguages — 11 Official South African Languages")
+    print("─" * 50)
+    for lang in LANGUAGES:
+        module = globals()[lang]
+        print(f"  {lang:<15} → {module.LANGUAGE_NAME}")
+    print()

CMT_SALanguages/_engine.py

@@ -0,0 +1,220 @@
+"""
+CMT-SALanguages — shared transpiler engine.
+
+Each language module (isizulu, isixhosa, afrikaans, etc.) provides its own
+KEYWORDS / CALLABLE_KEYWORDS / METHOD_KEYWORDS / MODULE_AND_EXCEPTION_KEYWORDS
+dictionaries and calls into this engine to do the actual transpilation.
+"""
+
+import re
+import os
+import sys
+import subprocess
+import tempfile
+
+
+def transpile(source: str, keywords: dict, callable_keywords: dict,
+               method_keywords: dict, module_exception_keywords: dict) -> str:
+    """
+    Transpile source code written with the given language's keyword maps
+    into valid Python code.
+    """
+    lines = source.splitlines()
+    output_lines = []
+
+    for line in lines:
+        converted = _convert_line(
+            line, keywords, callable_keywords, method_keywords, module_exception_keywords
+        )
+        output_lines.append(converted)
+
+    return "\n".join(output_lines)
+
+
+def _convert_line(line, keywords, callable_keywords, method_keywords, module_exception_keywords):
+    stripped = line.lstrip()
+    indent = line[: len(line) - len(stripped)]
+
+    if not stripped:
+        return line
+
+    if stripped.startswith("#"):
+        return line
+
+    converted = _replace_keywords(
+        stripped, keywords, callable_keywords, method_keywords, module_exception_keywords
+    )
+    return indent + converted
+
+
+def _replace_keywords(text, keywords, callable_keywords, method_keywords, module_exception_keywords):
+    segments = _split_strings(text)
+    result = []
+
+    for is_string, segment in segments:
+        if is_string:
+            result.append(segment)
+            continue
+
+        converted = segment
+
+        # 1. Always-reserved keywords
+        for word, python in sorted(keywords.items(), key=lambda x: -len(x[0])):
+            converted = re.sub(r"\b" + re.escape(word) + r"\b", python, converted)
+
+        # 2. Method keywords — only after a dot
+        for word, python in sorted(method_keywords.items(), key=lambda x: -len(x[0])):
+            converted = re.sub(
+                r"\.\s*" + re.escape(word) + r"\b",
+                "." + python,
+                converted,
+            )
+
+        # 3. Callable keywords — only when followed by "(" (function call).
+        #    NOT on "." — that would wrongly convert variable names that
+        #    happen to match a type/builtin name (e.g. "uhlelo" meaning both
+        #    "list" the type and a natural variable name "list/plan").
+        for word, python in sorted(callable_keywords.items(), key=lambda x: -len(x[0])):
+            converted = re.sub(
+                r"\b" + re.escape(word) + r"\b(?=\s*\()",
+                python,
+                converted,
+            )
+
+        # 4. Module & exception keywords — unless followed by "=" (assignment)
+        for word, python in sorted(module_exception_keywords.items(), key=lambda x: -len(x[0])):
+            converted = re.sub(
+                r"\b" + re.escape(word) + r"\b(?!\s*=(?!=))",
+                python,
+                converted,
+            )
+
+        result.append(converted)
+
+    return "".join(result)
+
+
+def _split_strings(text: str):
+    pattern = re.compile(r'(\"(?:[^\"\\]|\\.)*\"|\'(?:[^\'\\]|\\.)*\')')
+    parts = pattern.split(text)
+    result = []
+    for i, part in enumerate(parts):
+        result.append((i % 2 == 1, part))
+    return result
+
+
+def run_code(source: str, keywords, callable_keywords, method_keywords, module_exception_keywords):
+    """Transpile and execute a string of code, printing its output."""
+    python_code = transpile(source, keywords, callable_keywords, method_keywords, module_exception_keywords)
+
+    with tempfile.NamedTemporaryFile(suffix=".py", mode="w", delete=False, encoding="utf-8") as tmp:
+        tmp.write(python_code)
+        tmp_path = tmp.name
+
+    try:
+        subprocess.run([sys.executable, tmp_path])
+    finally:
+        os.unlink(tmp_path)
+
+
+def run_file(filepath: str, keywords, callable_keywords, method_keywords, module_exception_keywords):
+    """Transpile and execute a source file."""
+    if not os.path.exists(filepath):
+        print(f"CMT-SALanguages Error: File not found — {filepath}")
+        return
+
+    with open(filepath, encoding="utf-8") as f:
+        source = f.read()
+
+    run_code(source, keywords, callable_keywords, method_keywords, module_exception_keywords)
+
+
+def get_output(source: str, keywords, callable_keywords, method_keywords, module_exception_keywords) -> str:
+    """Transpile and execute, returning captured stdout as a string."""
+    python_code = transpile(source, keywords, callable_keywords, method_keywords, module_exception_keywords)
+
+    with tempfile.NamedTemporaryFile(suffix=".py", mode="w", delete=False, encoding="utf-8") as tmp:
+        tmp.write(python_code)
+        tmp_path = tmp.name
+
+    try:
+        result = subprocess.run([sys.executable, tmp_path], capture_output=True, text=True)
+        return result.stdout
+    finally:
+        os.unlink(tmp_path)
+
+
+def print_keywords(keywords, callable_keywords, method_keywords, module_exception_keywords, language_name):
+    """Print all keywords for a language."""
+    all_kw = {**keywords, **callable_keywords, **method_keywords, **module_exception_keywords}
+    print(f"\n{language_name:<25} {'Python'}")
+    print("─" * 40)
+    for word, python in sorted(all_kw.items()):
+        print(f"{word:<25} {python}")
+    print()
+
+
+def live_editor(keywords, callable_keywords, method_keywords, module_exception_keywords, language_name, prefix="sebenza"):
+    """
+    Generic live editor. `prefix` is unused now — kept for API compatibility.
+    Uses universal commands: 'run', 'clear', 'quit' work in every language,
+    plus each language can define its own native words for these.
+    """
+    _clear_screen()
+    _print_live_header(language_name)
+
+    lines = []
+
+    while True:
+        try:
+            line = input(">>> ")
+        except (EOFError, KeyboardInterrupt):
+            print("\nGoodbye!")
+            break
+
+        stripped = line.strip().lower()
+
+        if stripped in ("quit", "exit", "phuma"):
+            print("Goodbye!")
+            break
+
+        elif stripped in ("clear", "sula"):
+            lines = []
+            _clear_screen()
+            _print_live_header(language_name)
+
+        elif stripped in ("run", "sebenza"):
+            if not lines:
+                print("  (no code to run — type your code first!)\n")
+                continue
+            source = "\n".join(lines)
+            print()
+            print("─" * 52)
+            run_code(source, keywords, callable_keywords, method_keywords, module_exception_keywords)
+            print("─" * 52)
+            print()
+
+        elif stripped == "":
+            continue
+
+        else:
+            lines.append(line)
+            print(f"  [line {len(lines)} saved]")
+
+
+def _print_live_header(language_name):
+    print("=" * 52)
+    print(f"  CMT-SALanguages — {language_name} Live Editor")
+    print("  Developed by Mzwandile")
+    print("=" * 52)
+    print("  Type your code line by line.")
+    print()
+    print("  run / sebenza  -> run your code")
+    print("  clear / sula   -> clear and start fresh")
+    print("  quit / phuma   -> quit")
+    print("=" * 52)
+    print()
+
+
+def _clear_screen():
+    os.system("cls" if os.name == "nt" else "clear")

CMT_SALanguages/afrikaans.py

@@ -0,0 +1,102 @@
+"""
+CMT-SALanguages — Afrikaans
+
+Usage:
+    from CMT_SALanguages import afrikaans as CAL
+    CAL.sebenza('druk("Hallo!")')
+"""
+
+from . import _engine as _e
+
+LANGUAGE_NAME = "Afrikaans"
+
+KEYWORDS = {
+    "as": "if", "anders_as": "elif", "anders": "else", "terwyl": "while",
+    "vir": "for", "in": "in", "breek": "break", "gaan_voort": "continue",
+    "verbygaan": "pass", "funksie": "def", "klas": "class", "gee_terug": "return",
+    "self": "self", "_begin_": "__init__", "_klas_": "__class__", "_naam_": "__name__",
+    "voer_in": "import", "vanaf": "from", "waar": "True", "onwaar": "False",
+    "geen": "None", "en": "and", "of": "or", "nie": "not",
+    "probeer": "try", "behalwe": "except", "uiteindelik": "finally", "gooi": "raise",
+    "vir_funksie": "lambda", "globaal": "global", "nieplaaslik": "nonlocal", "met": "with",
+    "as_": "as", "lewer": "yield", "verseker": "assert", "verwyder": "del",
+    "asinkroon": "async", "wag": "await", "pasmaak": "match", "geval": "case",
+}
+
+CALLABLE_KEYWORDS = {
+    "string": "str", "heelgetal": "int", "wisselgetal": "float", "lys": "list",
+    "woordeboek": "dict", "versameling": "set", "boole": "bool", "grepe": "bytes",
+    "tupel": "tuple", "druk": "print", "lengte": "len", "reeks": "range", "tipe": "type",
+    "invoer": "input", "is_tipe": "isinstance", "maak_oop": "open", "sorteer": "sorted",
+    "omgekeerd": "reversed", "saamvoeg": "zip", "verbeeld": "map", "filtreer": "filter",
+    "som": "sum", "maksimum": "max", "minimum": "min", "almal": "all",
+    "enige": "any", "tel_op": "enumerate", "super": "super", "absoluut": "abs",
+    "rond_af": "round", "hulp": "help", "gids": "dir", "id_van": "id", "binêr": "bin",
+    "heksadesimaal": "hex", "oktaal": "oct", "mag": "pow",
+    "herhaal": "iter", "volgende": "next", "eiendom": "property",
+    "klasmetode": "classmethod", "statiesemetode": "staticmethod",
+}
+
+METHOD_KEYWORDS = {
+    "maak_toe": "close", "skryf": "write", "lees": "read", "lees_lyne": "readlines",
+    "skryf_lyne": "writelines", "formateer": "format", "verdeel": "split",
+    "saamvoeg_woorde": "join", "stroop": "strip", "vervang": "replace",
+    "hoofletters": "upper", "kleinletters": "lower", "begin_met": "startswith", "eindig_met": "endswith",
+    "vind": "find", "tel": "count", "voeg_by": "append", "voeg_alles_by": "extend",
+    "voeg_in": "insert", "haal_uit": "pop", "verwyder_item": "remove", "maak_skoon": "clear",
+    "kopieer": "copy", "sleutels": "keys", "waardes": "values", "items": "items",
+    "kry": "get", "bywerk": "update",
+}
+
+MODULE_AND_EXCEPTION_KEYWORDS = {
+    "fout": "Exception", "waardefout": "ValueError", "tipefout": "TypeError",
+    "indeksfout": "IndexError", "sleutelfout": "KeyError",
+    "lêerfout": "FileNotFoundError", "delingfout": "ZeroDivisionError",
+    "eienskapfout": "AttributeError", "invoerfout": "ImportError",
+    "looptydfout": "RuntimeError", "stopiterasie": "StopIteration",
+    "wiskunde": "math", "lukraak": "random", "datumtyd": "datetime",
+    "bedryfstelsel": "os", "stelsel": "sys", "lêerpad": "pathlib",
+    "grafiekgereedskap": "matplotlib", "dataanalise": "pandas",
+    "numeriesereekse": "numpy", "drade": "threading",
+    "veelvoudigeprosesse": "multiprocessing", "patroonsoektog": "re", "versoeke": "requests",
+    "databasis": "sqlite3", "webwerf": "flask", "teller": "Counter",
+    "tweekantrak": "deque", "verstekwoordeboek": "defaultdict",
+    "genoemdetupel": "namedtuple", "kettingkaart": "ChainMap",
+    "geordendewoordeboek": "OrderedDict",
+}
+
+ALL_KEYWORDS = {**KEYWORDS, **CALLABLE_KEYWORDS, **METHOD_KEYWORDS, **MODULE_AND_EXCEPTION_KEYWORDS}
+
+
+def transpile(kode: str) -> str:
+    return _e.transpile(kode, KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS)
+
+
+def hardloop(kode: str):
+    _e.run_code(kode, KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS)
+
+
+def lêer(pad: str):
+    _e.run_file(pad, KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS)
+
+
+def uitset(kode: str) -> str:
+    return _e.get_output(kode, KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS)
+
+
+def woorde():
+    _e.print_keywords(KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS, LANGUAGE_NAME)
+
+
+def regstreeks():
+    _e.live_editor(KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS, LANGUAGE_NAME)
+
+
+run = hardloop
+run_code = hardloop
+sebenza = hardloop
+guqula = transpile
+live = regstreeks
+fayela = lêer
+phendula = uitset
+amagama = woorde

CMT_SALanguages/english.py

@@ -0,0 +1,64 @@
+"""
+CMT-SALanguages — English (South African)
+
+English is already Python's native language, so this module is mostly a
+pass-through. It exists so the 11th official SA language has an entry in
+this collection, and adds a few South African English colloquialisms as
+optional extra keywords (e.g. "howzit" as a greeting print shortcut).
+
+Usage:
+    from CMT_SALanguages import english as CAL
+    CAL.sebenza('print("Howzit South Africa!")')
+"""
+
+from . import _engine as _e
+
+LANGUAGE_NAME = "English (South Africa)"
+
+# English IS Python — no reserved-word translation needed.
+KEYWORDS = {}
+
+# A few South African English colloquial aliases for built-ins
+CALLABLE_KEYWORDS = {
+    "howzit": "print",   # SA greeting slang -> print
+    "lekker": "print",   # "nice" -> also maps to print for fun
+    "shout": "print",
+    "ask": "input",
+    "size": "len",
+}
+
+METHOD_KEYWORDS = {}
+
+MODULE_AND_EXCEPTION_KEYWORDS = {}
+
+ALL_KEYWORDS = {**KEYWORDS, **CALLABLE_KEYWORDS, **METHOD_KEYWORDS, **MODULE_AND_EXCEPTION_KEYWORDS}
+
+
+def transpile(code: str) -> str:
+    return _e.transpile(code, KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS)
+
+
+def sebenza(code: str):
+    _e.run_code(code, KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS)
+
+
+def fayela(path: str):
+    _e.run_file(path, KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS)
+
+
+def phendula(code: str) -> str:
+    return _e.get_output(code, KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS)
+
+
+def amagama():
+    _e.print_keywords(KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS, LANGUAGE_NAME)
+
+
+def shwela():
+    _e.live_editor(KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS, LANGUAGE_NAME)
+
+
+run = sebenza
+run_code = sebenza
+guqula = transpile
+live = shwela

CMT_SALanguages/isindebele.py

@@ -0,0 +1,101 @@
+"""
+CMT-SALanguages — isiNdebele
+
+Usage:
+    from CMT_SALanguages import isindebele as CAL
+    CAL.sebenza('print_ndebele("Lotjhani!")')
+"""
+
+from . import _engine as _e
+
+LANGUAGE_NAME = "isiNdebele"
+
+KEYWORDS = {
+    "uma": "if", "kobe": "elif", "kodwana": "else", "lokha": "while",
+    "ngakho": "for", "ku": "in", "yima": "break", "qhubeka": "continue",
+    "yeyisa": "pass", "sebenza": "def", "isigaba": "class", "buyisela": "return",
+    "lo": "self", "_thoma_": "__init__", "_isigaba_": "__class__", "_ibizo_": "__name__",
+    "ngenisa": "import", "kusukela": "from", "iqiniso": "True", "amanga": "False",
+    "ize": "None", "begodu": "and", "namkha": "or", "nange": "not",
+    "zama": "try", "thintela": "except", "ekugcineni": "finally", "phakamisa": "raise",
+    "ngebanga": "lambda", "global": "global", "nonlocal": "nonlocal", "nge": "with",
+    "njenge": "as", "khipha": "yield", "qinisekisa": "assert", "susa": "del",
+    "ngokurhabako": "async", "linda": "await", "thelekisa": "match", "isimo": "case",
+}
+
+CALLABLE_KEYWORDS = {
+    "ibizo": "str", "inomba": "int", "inomba_ekhulu": "float", "irhelo": "list",
+    "isihlathululo": "dict", "isethi": "set", "iqiniso_amanga": "bool", "ibhayithi": "bytes",
+    "ithupula": "tuple", "print_ndebele": "print", "ubude": "len", "irenji": "range", "uhlobo": "type",
+    "faka": "input", "qala_uhlobo": "isinstance", "vula": "open", "hlela": "sorted",
+    "buyisela_emuva": "reversed", "hlanganisa": "zip", "yenza_kuyo_yoke": "map", "hlungela": "filter",
+    "ihlanganisela": "sum", "okukhulu": "max", "okuncani": "min", "kokukhe": "all",
+    "loyihlobo": "any", "bala_nenomba": "enumerate", "umkhulu": "super", "isilinganiso": "abs",
+    "buyisela_kude": "round", "usizo": "help", "tjengisa": "dir", "isazisi": "id", "okubili": "bin",
+    "okulitjhumi_nesithandathu": "hex", "okusiyazi_8": "oct", "amandla": "pow",
+    "phinda": "iter", "okulandelako": "next", "umfaneko": "property",
+    "indlela_yesigaba": "classmethod", "indlela_engatjhugulukiko": "staticmethod",
+}
+
+METHOD_KEYWORDS = {
+    "vala": "close", "tlola": "write", "funda": "read", "funda_imigca": "readlines",
+    "tlola_imigca": "writelines", "hlela_isimo": "format", "ahlukanisa": "split",
+    "hlanganisa_amagama": "join", "susa_isikhala": "strip", "tjhugulula": "replace",
+    "okukhulwana": "upper", "okuncanyana": "lower", "thoma_nge": "startswith", "phela_nge": "endswith",
+    "thola": "find", "bala_izinto": "count", "hlomelela": "append", "hlomelela_koke": "extend",
+    "faka_endaweni": "insert", "khipha_engenhla": "pop", "susa_into": "remove", "hlwengisa": "clear",
+    "kobisa": "copy", "amakhiya": "keys", "amanani": "values", "izinto": "items",
+    "thola_ngekhiya": "get", "thuthukisa": "update",
+}
+
+MODULE_AND_EXCEPTION_KEYWORDS = {
+    "isiphazamiso": "Exception", "isiphazamiso_senani": "ValueError", "isiphazamiso_sehlobo": "TypeError",
+    "isiphazamiso_senomba": "IndexError", "isiphazamiso_sekhiya": "KeyError",
+    "isiphazamiso_sefayela": "FileNotFoundError", "isiphazamiso_sokuhlukanisa": "ZeroDivisionError",
+    "isiphazamiso_somfaneko": "AttributeError", "isiphazamiso_sokungenisa": "ImportError",
+    "isiphazamiso_sokusebenza": "RuntimeError", "ukuphela_kokulandelelana": "StopIteration",
+    "izibalo": "math", "ngokungahlelekileko": "random", "isikhathi": "datetime",
+    "uhlelo_lwefayela": "os", "uhlelo_lwesistimu": "sys", "indlela_yefayela": "pathlib",
+    "amathuluzi_omfanekiso": "matplotlib", "ukuhlathululwa_kwedatha": "pandas",
+    "amanomba_ahlelekileko": "numpy", "ukucindezelwa": "threading",
+    "iinqubo_ezinengi": "multiprocessing", "indlela_yamagama": "re", "izicelo": "requests",
+    "isisekelo_sedatha": "sqlite3", "iwebhu": "flask", "ibalo": "Counter",
+    "umqobo": "deque", "isihlathululo_esizenzakalelako": "defaultdict",
+    "ithupula_eqanjwe": "namedtuple", "uchungechunge_lwesihlathululo": "ChainMap",
+    "isihlathululo_esilandelako": "OrderedDict",
+}
+
+ALL_KEYWORDS = {**KEYWORDS, **CALLABLE_KEYWORDS, **METHOD_KEYWORDS, **MODULE_AND_EXCEPTION_KEYWORDS}
+
+
+def transpile(ikhowudu: str) -> str:
+    return _e.transpile(ikhowudu, KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS)
+
+
+def sebenza_kwakhona(ikhowudu: str):
+    _e.run_code(ikhowudu, KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS)
+
+
+def ifayela(indlela: str):
+    _e.run_file(indlela, KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS)
+
+
+def imphendulo(ikhowudu: str) -> str:
+    return _e.get_output(ikhowudu, KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS)
+
+
+def amagama():
+    _e.print_keywords(KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS, LANGUAGE_NAME)
+
+
+def ukuphila():
+    _e.live_editor(KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS, LANGUAGE_NAME)
+
+
+run = sebenza_kwakhona
+run_code = sebenza_kwakhona
+sebenza = sebenza_kwakhona
+guqula = transpile
+live = ukuphila
+fayela = ifayela
+phendula = imphendulo

CMT_SALanguages/isixhosa.py

@@ -0,0 +1,101 @@
+"""
+CMT-SALanguages — isiXhosa
+
+Usage:
+    from CMT_SALanguages import isixhosa as CAL
+    CAL.sebenza('shicilela("Molo!")')
+"""
+
+from . import _engine as _e
+
+LANGUAGE_NAME = "isiXhosa"
+
+KEYWORDS = {
+    "ukuba": "if", "okanye": "elif", "ngokunye": "else", "ngelixa": "while",
+    "ngalo": "for", "ku": "in", "yeka": "break", "qhubeka": "continue",
+    "yedlulisa": "pass", "yenza": "def", "udidi": "class", "buyisela": "return",
+    "lo": "self", "_qala_": "__init__", "_udidi_": "__class__", "_igama_": "__name__",
+    "ngenisa": "import", "ukususela": "from", "yinyaniso": "True", "ubuxoki": "False",
+    "akukho": "None", "kunye": "and", "okanyenye": "or", "akuyiyo": "not",
+    "zama": "try", "phantse": "except", "ekugqibeleni": "finally", "phakamisa": "raise",
+    "ngenxa": "lambda", "global": "global", "nonlocal": "nonlocal", "nge": "with",
+    "ngoku": "as", "velisa": "yield", "qinisekisa": "assert", "cima": "del",
+    "ngokukhawuleza": "async", "linda": "await", "thelekisa": "match", "imeko": "case",
+}
+
+CALLABLE_KEYWORDS = {
+    "igama": "str", "inombolo": "int", "inombolo_enkulu": "float", "uluhlu": "list",
+    "isichazi": "dict", "iseti": "set", "yinyaniso_ubuxoki": "bool", "izinto_zekhowudi": "bytes",
+    "iqela": "tuple", "shicilela": "print", "ubude": "len", "uluhlu_lwamanani": "range", "uhlobo": "type",
+    "faka": "input", "jonga_uhlobo": "isinstance", "vula": "open", "hlela": "sorted",
+    "buyisela_emva": "reversed", "manyanisa": "zip", "senza": "map", "cola": "filter",
+    "hlanganisa": "sum", "okukhulu": "max", "okuncinci": "min", "konke": "all",
+    "nakuphi": "any", "balula": "enumerate", "ndlovu": "super", "elilodwa": "abs",
+    "qengqeleza": "round", "nceda": "help", "khombisa": "dir", "isazisi": "id", "okubini": "bin",
+    "ishumi_elinesithandathu": "hex", "okusibhozo": "oct", "amandla": "pow",
+    "phinda": "iter", "okulandelayo": "next", "umhlobiso": "property",
+    "kudidi": "classmethod", "kwemiyo": "staticmethod",
+}
+
+METHOD_KEYWORDS = {
+    "vala": "close", "bhala": "write", "funda": "read", "funda_imigca": "readlines",
+    "bhala_imigca": "writelines", "lungelelanisa": "format", "qhekeza": "split",
+    "manyanisa_amagama": "join", "susa_izithuba": "strip", "faka_endaweni": "replace",
+    "phezulu": "upper", "ezantsi": "lower", "qala_nge": "startswith", "phela_nge": "endswith",
+    "fumana": "find", "bala": "count", "ongeza": "append", "ongeza_konke": "extend",
+    "faka_kwindawo": "insert", "khupha": "pop", "susa_into": "remove", "cima_konke": "clear",
+    "kopa": "copy", "izitshixo": "keys", "amaxabiso": "values", "izinto": "items",
+    "fumana_isitshixo": "get", "hlaziya": "update",
+}
+
+MODULE_AND_EXCEPTION_KEYWORDS = {
+    "impazamo": "Exception", "impazamo_yexabiso": "ValueError", "impazamo_yohlobo": "TypeError",
+    "impazamo_yenombolo": "IndexError", "impazamo_yesitshixo": "KeyError",
+    "impazamo_yefayile": "FileNotFoundError", "impazamo_yokwahlula": "ZeroDivisionError",
+    "impazamo_yepropati": "AttributeError", "impazamo_yokungenisa": "ImportError",
+    "impazamo_yokusebenza": "RuntimeError", "impazamo_yokuphela": "StopIteration",
+    "izibalo": "math", "ngokungahleliwe": "random", "ixesha": "datetime",
+    "inkqubo_yefayile": "os", "inkqubo_yesistim": "sys", "indlela_yefayile": "pathlib",
+    "izixhobo_zomzobo": "matplotlib", "uhlalutyo": "pandas",
+    "amanani_alungelelaniswe": "numpy", "ukucinezela": "threading",
+    "iinkqubo": "multiprocessing", "umgaqo_wamagama": "re", "izicelo": "requests",
+    "isiseko_sedatha": "sqlite3", "iwebhu": "flask", "isibalo": "Counter",
+    "ikhwelo": "deque", "isichazi_esizenzekelayo": "defaultdict",
+    "iqela_elibhalwe": "namedtuple", "uchungechunge_lwezichazi": "ChainMap",
+    "isichazi_esilandelayo": "OrderedDict",
+}
+
+ALL_KEYWORDS = {**KEYWORDS, **CALLABLE_KEYWORDS, **METHOD_KEYWORDS, **MODULE_AND_EXCEPTION_KEYWORDS}
+
+
+def transpile(ikhowudi: str) -> str:
+    return _e.transpile(ikhowudi, KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS)
+
+
+def yenza_lo(ikhowudi: str):
+    _e.run_code(ikhowudi, KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS)
+
+
+def ifayile(indlela: str):
+    _e.run_file(indlela, KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS)
+
+
+def impendulo(ikhowudi: str) -> str:
+    return _e.get_output(ikhowudi, KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS)
+
+
+def amagama():
+    _e.print_keywords(KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS, LANGUAGE_NAME)
+
+
+def shwela():
+    _e.live_editor(KEYWORDS, CALLABLE_KEYWORDS, METHOD_KEYWORDS, MODULE_AND_EXCEPTION_KEYWORDS, LANGUAGE_NAME)
+
+
+run = yenza_lo
+run_code = yenza_lo
+sebenza = yenza_lo  # cross-language alias for familiarity
+guqula = transpile
+live = shwela
+fayela = ifayile
+phendula = impendulo