polyglot-python 0.2.0__tar.gz

polyglot_python-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Furox-Art
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

polyglot_python-0.2.0/PKG-INFO

@@ -0,0 +1,177 @@
+Metadata-Version: 2.4
+Name: polyglot-python
+Version: 0.2.0
+Summary: Deterministic multilingual Python keyword transpiler: write Python in your own language.
+Author: Furox-Art
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Furox-Art/polyglot-python
+Project-URL: Issues, https://github.com/Furox-Art/polyglot-python/issues
+Project-URL: Changelog, https://github.com/Furox-Art/polyglot-python/blob/main/CHANGELOG.md
+Keywords: python,transpiler,localization,multilingual,deterministic
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-cov>=5; extra == "dev"
+Dynamic: license-file
+
+# polyglot-python
+
+Write Python in your own language, deterministically.
+
+polyglot-python is a keyword transpiler for Python. You keep Python's grammar and write
+programs with localized keywords; polyglot-python maps those keywords to the real Python
+keywords and hands the result to CPython. No AI, no network, no randomness:
+the same source, locale and version always produce byte-identical Python.
+
+It is not a prose-to-code translator and it does not guess intent. It is Python
+syntax with your words.
+
+## Install
+
+```bash
+pip install polyglot-python   # after the first release
+pip install -e .              # from source
+```
+
+The first release is prepared but not yet on PyPI; install from source until it
+is published. Requires Python 3.12+. Python 3.10/3.11 are not supported because
+their tokenizer splits Indic combining marks, so several Hindi keywords would
+not translate. No runtime dependencies.
+
+## Quick start
+
+`examples/classify.tr`:
+
+```python
+fonksiyon classify(n):
+    eğer n % 15 == 0:
+        döndür "FizzBuzz"
+    değilse_eğer n % 3 == 0:
+        döndür "Fizz"
+    değilse_eğer n % 5 == 0:
+        döndür "Buzz"
+    değilse:
+        döndür str(n)
+
+için n içinde range(1, 16):
+    print(classify(n))
+```
+
+```bash
+polyglot-python run examples/classify.tr
+polyglot-python check examples/classify.tr
+polyglot-python translate examples/classify.tr
+polyglot-python translate examples/classify.tr -o classify.py
+```
+
+The same FizzBuzz program is included for every locale under `examples/`.
+
+## Locales
+
+| Code | Language   | `if`     | `def`       | `return`  |
+|------|------------|----------|-------------|-----------|
+| tr   | Türkçe     | `eğer`   | `fonksiyon` | `döndür`  |
+| es   | Español    | `si`     | `función`   | `devolver`|
+| pt   | Português  | `se`     | `função`    | `retornar`|
+| de   | Deutsch    | `wenn`   | `funktion`  | `zurückgeben` |
+| fr   | Français   | `si`     | `fonction`  | `retourner` |
+| zh   | 中文        | `如果`   | `函数`      | `返回`    |
+| hi   | हिन्दी      | `अगर`    | `फलन`       | `लौटाओ`   |
+| ar   | العربية    | `إذا`    | `دالة`      | `إرجاع`   |
+| ru   | Русский    | `если`   | `определить`| `вернуть` |
+
+`polyglot-python locales` prints the full list. Every locale defines exactly the 35
+Python hard keywords (`keyword.kwlist`); soft keywords such as `match`, `case`
+and `type` stay English.
+
+Locale selection order:
+
+1. `--lang CODE`
+2. first line directive: `# polyglot-python: tr`
+3. file suffix: `.tr`, `.es`, `.pt`, `.de`, `.fr`, `.zh`, `.hi`, `.ar`, `.ru`
+
+## CLI
+
+```text
+polyglot-python run FILE [--lang CODE] [args...]
+polyglot-python check FILE [--lang CODE]
+polyglot-python translate FILE [--lang CODE] [-o OUT]
+polyglot-python locales
+polyglot-python --version
+```
+
+For `run`, place options before `FILE`; everything after `FILE` is passed to the
+program as `sys.argv[1:]`.
+
+## Guarantees
+
+- Only exact `NAME` tokens that match a locale keyword are rewritten. Strings,
+  comments, f-strings, numbers, identifiers and attribute names are untouched.
+- Line numbers are preserved one-to-one; a per-line column map translates
+  reported error positions back to the localized source.
+- `translate -o` and stdout output are UTF-8 with LF line endings on every
+  platform, so exports are byte-identical and re-verifiable.
+- `check` translates and compiles without executing the program, so localized
+  sources can be validated safely.
+- A localized keyword after a dot is treated as an attribute name and never
+  rewritten.
+- Localized keywords are reserved words in their locale.
+- Missing files, invalid UTF-8, unknown locales and untokenizable input fail
+  with a clear message; nothing is guessed or silently skipped.
+- Error headers are localized; CPython's detail text (for example
+  `ZeroDivisionError`) remains English for now.
+- Exit codes from the executed program are propagated.
+
+## Limits
+
+- Phase 1 localizes keywords only: no localization of builtins (`print`,
+  `range`, ...), the standard library, or English exception text.
+- This is not a natural-language compiler. It does not understand Spanish or
+  Turkish prose; it understands Python syntax written with localized keywords.
+- The local prototype ships 9 locales. Other languages can be added by editing
+  `src/polyglot_python/locales.json`; malformed tables are rejected at load time.
+- Tested on CPython 3.12 on Windows; CI covers 3.12-3.14 on Linux and 3.12
+  on Windows and macOS. The code targets 3.12+.
+
+## Development
+
+```bash
+python -m venv .venv
+.venv/Scripts/pip install -e ".[dev]"
+.venv/Scripts/python -m pytest -q --cov=polyglot_python --cov-fail-under=100
+```
+
+The suite contains 119 tests with 100% statement coverage, including every
+keyword in both directions for all 9 locales, end-to-end CLI runs of every
+example, version consistency with the changelog, and byte-level determinism
+checks. CI runs Ubuntu 3.12-3.14 plus Windows and macOS at 3.12, enforces the
+100% coverage gate on Linux 3.12, translates every example twice on all three
+operating systems to compare bytes and line counts, and builds the wheel,
+installs it into a clean environment, and smoke-tests it. Dependabot keeps
+GitHub Actions and development dependencies current. A separate release
+workflow publishes tagged GitHub Releases to PyPI through Trusted Publishing.
+
+## Releasing
+
+Publishing uses [PyPI Trusted Publishing](https://docs.pypi.org/trusted-publishers/)
+and stores no API token.
+
+1. On PyPI, add a pending publisher for project `polyglot-python`: owner
+   `Furox-Art`, repository `polyglot-python`, workflow `release.yml`,
+   environment `pypi`.
+2. Change `version` in `pyproject.toml` and
+   `src/polyglot_python/__init__.py` together; the test suite rejects drift.
+3. Publish a GitHub Release with tag `v<version>`. The release workflow verifies
+   the tag, builds the sdist and wheel, and uploads them to PyPI.
+
+## License
+
+MIT

polyglot_python-0.2.0/README.md

@@ -0,0 +1,153 @@
+# polyglot-python
+
+Write Python in your own language, deterministically.
+
+polyglot-python is a keyword transpiler for Python. You keep Python's grammar and write
+programs with localized keywords; polyglot-python maps those keywords to the real Python
+keywords and hands the result to CPython. No AI, no network, no randomness:
+the same source, locale and version always produce byte-identical Python.
+
+It is not a prose-to-code translator and it does not guess intent. It is Python
+syntax with your words.
+
+## Install
+
+```bash
+pip install polyglot-python   # after the first release
+pip install -e .              # from source
+```
+
+The first release is prepared but not yet on PyPI; install from source until it
+is published. Requires Python 3.12+. Python 3.10/3.11 are not supported because
+their tokenizer splits Indic combining marks, so several Hindi keywords would
+not translate. No runtime dependencies.
+
+## Quick start
+
+`examples/classify.tr`:
+
+```python
+fonksiyon classify(n):
+    eğer n % 15 == 0:
+        döndür "FizzBuzz"
+    değilse_eğer n % 3 == 0:
+        döndür "Fizz"
+    değilse_eğer n % 5 == 0:
+        döndür "Buzz"
+    değilse:
+        döndür str(n)
+
+için n içinde range(1, 16):
+    print(classify(n))
+```
+
+```bash
+polyglot-python run examples/classify.tr
+polyglot-python check examples/classify.tr
+polyglot-python translate examples/classify.tr
+polyglot-python translate examples/classify.tr -o classify.py
+```
+
+The same FizzBuzz program is included for every locale under `examples/`.
+
+## Locales
+
+| Code | Language   | `if`     | `def`       | `return`  |
+|------|------------|----------|-------------|-----------|
+| tr   | Türkçe     | `eğer`   | `fonksiyon` | `döndür`  |
+| es   | Español    | `si`     | `función`   | `devolver`|
+| pt   | Português  | `se`     | `função`    | `retornar`|
+| de   | Deutsch    | `wenn`   | `funktion`  | `zurückgeben` |
+| fr   | Français   | `si`     | `fonction`  | `retourner` |
+| zh   | 中文        | `如果`   | `函数`      | `返回`    |
+| hi   | हिन्दी      | `अगर`    | `फलन`       | `लौटाओ`   |
+| ar   | العربية    | `إذا`    | `دالة`      | `إرجاع`   |
+| ru   | Русский    | `если`   | `определить`| `вернуть` |
+
+`polyglot-python locales` prints the full list. Every locale defines exactly the 35
+Python hard keywords (`keyword.kwlist`); soft keywords such as `match`, `case`
+and `type` stay English.
+
+Locale selection order:
+
+1. `--lang CODE`
+2. first line directive: `# polyglot-python: tr`
+3. file suffix: `.tr`, `.es`, `.pt`, `.de`, `.fr`, `.zh`, `.hi`, `.ar`, `.ru`
+
+## CLI
+
+```text
+polyglot-python run FILE [--lang CODE] [args...]
+polyglot-python check FILE [--lang CODE]
+polyglot-python translate FILE [--lang CODE] [-o OUT]
+polyglot-python locales
+polyglot-python --version
+```
+
+For `run`, place options before `FILE`; everything after `FILE` is passed to the
+program as `sys.argv[1:]`.
+
+## Guarantees
+
+- Only exact `NAME` tokens that match a locale keyword are rewritten. Strings,
+  comments, f-strings, numbers, identifiers and attribute names are untouched.
+- Line numbers are preserved one-to-one; a per-line column map translates
+  reported error positions back to the localized source.
+- `translate -o` and stdout output are UTF-8 with LF line endings on every
+  platform, so exports are byte-identical and re-verifiable.
+- `check` translates and compiles without executing the program, so localized
+  sources can be validated safely.
+- A localized keyword after a dot is treated as an attribute name and never
+  rewritten.
+- Localized keywords are reserved words in their locale.
+- Missing files, invalid UTF-8, unknown locales and untokenizable input fail
+  with a clear message; nothing is guessed or silently skipped.
+- Error headers are localized; CPython's detail text (for example
+  `ZeroDivisionError`) remains English for now.
+- Exit codes from the executed program are propagated.
+
+## Limits
+
+- Phase 1 localizes keywords only: no localization of builtins (`print`,
+  `range`, ...), the standard library, or English exception text.
+- This is not a natural-language compiler. It does not understand Spanish or
+  Turkish prose; it understands Python syntax written with localized keywords.
+- The local prototype ships 9 locales. Other languages can be added by editing
+  `src/polyglot_python/locales.json`; malformed tables are rejected at load time.
+- Tested on CPython 3.12 on Windows; CI covers 3.12-3.14 on Linux and 3.12
+  on Windows and macOS. The code targets 3.12+.
+
+## Development
+
+```bash
+python -m venv .venv
+.venv/Scripts/pip install -e ".[dev]"
+.venv/Scripts/python -m pytest -q --cov=polyglot_python --cov-fail-under=100
+```
+
+The suite contains 119 tests with 100% statement coverage, including every
+keyword in both directions for all 9 locales, end-to-end CLI runs of every
+example, version consistency with the changelog, and byte-level determinism
+checks. CI runs Ubuntu 3.12-3.14 plus Windows and macOS at 3.12, enforces the
+100% coverage gate on Linux 3.12, translates every example twice on all three
+operating systems to compare bytes and line counts, and builds the wheel,
+installs it into a clean environment, and smoke-tests it. Dependabot keeps
+GitHub Actions and development dependencies current. A separate release
+workflow publishes tagged GitHub Releases to PyPI through Trusted Publishing.
+
+## Releasing
+
+Publishing uses [PyPI Trusted Publishing](https://docs.pypi.org/trusted-publishers/)
+and stores no API token.
+
+1. On PyPI, add a pending publisher for project `polyglot-python`: owner
+   `Furox-Art`, repository `polyglot-python`, workflow `release.yml`,
+   environment `pypi`.
+2. Change `version` in `pyproject.toml` and
+   `src/polyglot_python/__init__.py` together; the test suite rejects drift.
+3. Publish a GitHub Release with tag `v<version>`. The release workflow verifies
+   the tag, builds the sdist and wheel, and uploads them to PyPI.
+
+## License
+
+MIT

polyglot_python-0.2.0/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "polyglot-python"
+version = "0.2.0"
+description = "Deterministic multilingual Python keyword transpiler: write Python in your own language."
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Furox-Art" }]
+keywords = ["python", "transpiler", "localization", "multilingual", "deterministic"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Compilers",
+]
+
+[project.scripts]
+polyglot-python = "polyglot_python.cli:main"
+
+[project.optional-dependencies]
+dev = ["pytest>=8", "pytest-cov>=5"]
+
+[project.urls]
+Homepage = "https://github.com/Furox-Art/polyglot-python"
+Issues = "https://github.com/Furox-Art/polyglot-python/issues"
+Changelog = "https://github.com/Furox-Art/polyglot-python/blob/main/CHANGELOG.md"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+polyglot_python = ["locales.json"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]

polyglot_python-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

polyglot_python-0.2.0/src/polyglot_python/__init__.py

@@ -0,0 +1,24 @@
+"""polyglot-python: deterministic multilingual Python keyword transpiler."""
+
+from .translator import (
+    Locale,
+    LocaleError,
+    TokenizeFailure,
+    Translation,
+    load_locales,
+    resolve_locale,
+    translate,
+)
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "Locale",
+    "LocaleError",
+    "TokenizeFailure",
+    "Translation",
+    "__version__",
+    "load_locales",
+    "resolve_locale",
+    "translate",
+]

polyglot_python-0.2.0/src/polyglot_python/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

polyglot_python-0.2.0/src/polyglot_python/cli.py

@@ -0,0 +1,225 @@
+"""Command line interface for polyglot-python."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+import traceback
+from types import CodeType
+from typing import Sequence
+
+from . import __version__
+from .translator import (
+    Locale,
+    TokenizeFailure,
+    Translation,
+    load_locales,
+    resolve_locale,
+    translate,
+)
+
+
+class _Failure(Exception):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+        self.message = message
+
+
+def _configure_console() -> None:
+    for stream in (sys.stdout, sys.stderr):
+        reconfigure = getattr(stream, "reconfigure", None)
+        if reconfigure is None:
+            continue
+        try:
+            reconfigure(encoding="utf-8", newline="\n")
+        except (ValueError, OSError):
+            pass
+
+
+def _message(locale: Locale | None, key: str, fallback: str) -> str:
+    if locale is None:
+        return fallback
+    return locale.messages.get(key, fallback)
+
+
+def _read_source(path: str) -> str:
+    try:
+        with open(path, "r", encoding="utf-8-sig", newline="") as handle:
+            return handle.read()
+    except UnicodeDecodeError as exc:
+        raise _Failure(
+            f"cannot decode {path} as UTF-8: {exc.reason} at byte {exc.start}"
+        ) from exc
+    except OSError as exc:
+        reason = exc.strerror or str(exc)
+        raise _Failure(f"cannot read {path}: {reason}") from exc
+
+
+def _prepare(path: str, lang: str | None) -> tuple[Locale | None, Translation]:
+    text = _read_source(path)
+    code = resolve_locale(lang, text, path)
+    locale: Locale | None = None
+    if code is not None:
+        locales = load_locales()
+        locale = locales.get(code)
+        if locale is None:
+            available = ", ".join(sorted(locales))
+            raise _Failure(f"unknown locale {code!r}; available: {available}")
+    try:
+        translation = translate(text, locale)
+    except TokenizeFailure as exc:
+        prefix = _message(locale, "token_error", "Tokenization error")
+        raise _Failure(
+            f"{prefix}: {path}:{exc.line}:{exc.column}: {exc.detail}"
+        ) from exc
+    return locale, translation
+
+
+def _compile(
+    path: str, locale: Locale | None, translation: Translation
+) -> CodeType | None:
+    try:
+        return compile(translation.python, path, "exec")
+    except SyntaxError as exc:
+        lineno = exc.lineno or 1
+        column = translation.original_column(lineno, exc.offset or 1)
+        prefix = _message(locale, "syntax_error", "Syntax error")
+        print(
+            f"{prefix}: {path}:{lineno}:{column}: {exc.msg}",
+            file=sys.stderr,
+        )
+        return None
+
+
+def _run(namespace: argparse.Namespace) -> int:
+    try:
+        locale, translation = _prepare(namespace.file, namespace.lang)
+    except _Failure as exc:
+        print(f"polyglot-python: {exc.message}", file=sys.stderr)
+        return 1
+
+    code = _compile(namespace.file, locale, translation)
+    if code is None:
+        return 1
+
+    scope = {
+        "__name__": "__main__",
+        "__file__": os.path.abspath(namespace.file),
+    }
+    saved_argv = sys.argv
+    sys.argv = [namespace.file, *namespace.args]
+    try:
+        exec(code, scope)
+    except SystemExit as exc:
+        if exc.code is None:
+            return 0
+        if isinstance(exc.code, int):
+            return exc.code
+        print(exc.code, file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        raise
+    except Exception:
+        prefix = _message(locale, "runtime_error", "Runtime error")
+        print(f"{prefix}: {namespace.file}", file=sys.stderr)
+        traceback.print_exc()
+        return 1
+    finally:
+        sys.argv = saved_argv
+    return 0
+
+
+def _check(namespace: argparse.Namespace) -> int:
+    try:
+        locale, translation = _prepare(namespace.file, namespace.lang)
+    except _Failure as exc:
+        print(f"polyglot-python: {exc.message}", file=sys.stderr)
+        return 1
+    return 0 if _compile(namespace.file, locale, translation) is not None else 1
+
+
+def _translate(namespace: argparse.Namespace) -> int:
+    try:
+        _, translation = _prepare(namespace.file, namespace.lang)
+    except _Failure as exc:
+        print(f"polyglot-python: {exc.message}", file=sys.stderr)
+        return 1
+
+    if namespace.output:
+        try:
+            with open(namespace.output, "w", encoding="utf-8", newline="") as handle:
+                handle.write(translation.python)
+        except OSError as exc:
+            reason = exc.strerror or str(exc)
+            print(
+                f"polyglot-python: cannot write {namespace.output}: {reason}",
+                file=sys.stderr,
+            )
+            return 1
+    else:
+        sys.stdout.write(translation.python)
+    return 0
+
+
+def _locales(_namespace: argparse.Namespace) -> int:
+    locales = load_locales()
+    print(f"{'code':<6}{'name':<16}keywords")
+    for code in sorted(locales):
+        locale = locales[code]
+        print(f"{code:<6}{locale.name:<16}{len(locale.keywords)}")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="polyglot-python",
+        description="Write Python in your own language: deterministic keyword translation.",
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"polyglot-python {__version__}"
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    run = subparsers.add_parser("run", help="translate and execute a program")
+    run.add_argument("file", help="localized source file")
+    run.add_argument("--lang", metavar="CODE", help="locale code, e.g. tr")
+    run.add_argument(
+        "args",
+        nargs=argparse.REMAINDER,
+        help="arguments passed to the program",
+    )
+    run.set_defaults(handler=_run)
+
+    transform = subparsers.add_parser(
+        "translate", help="print the Python translation"
+    )
+    transform.add_argument("file", help="localized source file")
+    transform.add_argument("--lang", metavar="CODE", help="locale code, e.g. tr")
+    transform.add_argument(
+        "-o", "--output", metavar="PATH", help="write the translation to PATH"
+    )
+    transform.set_defaults(handler=_translate)
+
+    check = subparsers.add_parser(
+        "check", help="translate and compile a program without running it"
+    )
+    check.add_argument("file", help="localized source file")
+    check.add_argument("--lang", metavar="CODE", help="locale code, e.g. tr")
+    check.set_defaults(handler=_check)
+
+    listing = subparsers.add_parser("locales", help="list bundled locales")
+    listing.set_defaults(handler=_locales)
+
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    _configure_console()
+    parser = build_parser()
+    namespace = parser.parse_args(argv)
+    return namespace.handler(namespace)
+
+
+if __name__ == "__main__":
+    sys.exit(main())