Yapton 0.1.2__tar.gz

yapton-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zahi Najmal
+
+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.

yapton-0.1.2/PKG-INFO

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: Yapton
+Version: 0.1.2
+Summary: Yapton is an fun Python library that helps kids learn how to code Python using fun slang-keywords
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Yapton
+
+**Yapton is a small educational programming language that lets learners write Python-style programs with a few slang-inspired keywords.** A Yapton file (`.yap`) is translated to Python in memory and then run with the normal Python runtime. It is intended as a friendly bridge to Python, not as a replacement for it.
+
+## What this project does
+
+Yapton keeps ordinary Python syntax, data types, loops, expressions, and standard-library imports. It adds the following alternative words:
+
+| Yapton | Python meaning |
+| --- | --- |
+| `yap(...)` | `print(...)` |
+| `spill(...)` | `input(...)`, converting number-looking input to `int` or `float` |
+| `vibe name():` | `def name():` |
+| `fanumtax math` | `import math` |
+| `optionC` | `elif` |
+| `otherwise` | `else` |
+| `W` / `L` | `True` / `False` |
+
+For example:
+
+```yap
+fanumtax math
+
+vibe greet(name):
+    yap("Welcome,", name)
+
+name = spill("What is your name? ")
+greet(name)
+```
+
+## Project roles
+
+The codebase has three clear responsibilities:
+
+| Part | Role |
+| --- | --- |
+| `src/yapton/__init__.py` | The **Yapton language engine**. It translates Yapton keywords into Python tokens, provides `spill`, runs `.yap` files, and prints the slang reference. |
+| `src/yapton/cli.py` | The **command-line interface**. It accepts `yap program.yap` and `yap --slang-help`, then calls the language engine. |
+| `pyproject.toml` | The **package configuration**. It declares the Python requirement and installs the `yap` command. |
+| `sample1.yap` to `sample7.yap` | **Example Yapton programs**, ordered from small language demonstrations to larger projects. |
+| `yap.bat` | The **Windows launcher**. It runs `python -m yapton.cli`, so it never depends on a copied, moved, or stale virtual environment. |
+
+## Requirements
+
+- Python 3.10 or newer
+- PowerShell, Command Prompt, or another terminal
+- Git, only if you want to publish the project on GitHub
+
+Check that Python is available:
+
+```powershell
+py --version
+```
+
+If `py` is not found, install Python from [python.org](https://www.python.org/downloads/) and make sure the installer option to add Python to PATH is enabled.
+
+## Run it locally (Windows / PowerShell)
+
+Open PowerShell in this project folder, then create a fresh virtual environment and install Yapton in editable mode:
+
+```powershell
+cd "C:\path\to\Yapton"
+py -m venv .venv
+.\.venv\Scripts\Activate.ps1
+python -m pip install --upgrade pip
+python -m pip install -e .
+```
+
+Run an example:
+
+```powershell
+yap sample2.yap
+```
+
+Or run the larger example:
+
+```powershell
+yap sample5.yap
+```
+
+See the built-in language reference at any time:
+
+```powershell
+yap --slang-help
+```
+
+### If PowerShell blocks activation
+
+Activation is optional. Use the environment's Python directly instead:
+
+```powershell
+.\.venv\Scripts\python.exe -m pip install -e .
+.\.venv\Scripts\yap.exe sample2.yap
+```
+
+### Run a new program
+
+1. Create a file ending in `.yap`, such as `hello.yap`.
+2. Add Yapton/Python code.
+3. Run `yap hello.yap` while the environment is active.
+
+Indentation and colons work exactly like Python. Regular Python can be mixed with the Yapton keywords shown above.
+
+### Sample guide
+
+| File | Demonstrates |
+| --- | --- |
+| `sample1.yap` | Functions, loops, lists, conditions, and Yapton booleans. |
+| `sample2.yap` | Adding two numbers entered by the user. |
+| `sample3.yap` | Subtracting two numbers entered by the user. |
+| `sample4.yap` | Checking whether a number is positive or negative. |
+| `sample5.yap` | A menu-driven student score tracker using Yapton imports. |
+| `sample6.yap` | The same student tracker, showing that regular Python `import` also works. |
+| `sample7.yap` | A first-person 3D maze. Install its extra dependency first with `python -m pip install ursina`. |
+
+### Why `yap` works reliably in this folder
+
+Windows chooses `yap.bat` in the current folder before an installed `yap` command. This project launcher deliberately uses `python -m yapton.cli` instead of a hard-coded path to `venv\\Scripts\\python.exe`. That means it uses the same Python installation that installed Yapton and will not break merely because a virtual-environment folder was moved, deleted, or created on another computer.
+
+## Put it on GitHub
+
+1. Sign in to [GitHub](https://github.com/) and select **New repository**.
+2. Name it `Yapton`, choose Public or Private, and **do not** initialize it with a README, `.gitignore`, or license—the project already has the first two.
+3. In PowerShell, from this project folder, run the following. Replace `YOUR-USERNAME` with your GitHub username:
+
+```powershell
+cd "C:\path\to\Yapton"
+git init
+git add .
+git commit -m "Initial commit: Yapton language"
+git branch -M main
+git remote add origin https://github.com/YOUR-USERNAME/Yapton.git
+git push -u origin main
+```
+
+GitHub may ask you to sign in or create a personal access token when you push over HTTPS. If Git reports that a remote called `origin` already exists, update it instead:
+
+```powershell
+git remote set-url origin https://github.com/YOUR-USERNAME/Yapton.git
+git push -u origin main
+```
+
+The included `.gitignore` prevents virtual environments, cache files, and build outputs from being uploaded. Do not upload `.venv/` or `venv/`; each contributor should create their own using the local setup steps above.
+
+### Privacy check before publishing
+
+The publishable source files contain no personal names, email addresses, passwords, API keys, or local computer paths. The ignored `venv/` folder is machine-specific and must not be uploaded. The `.gitignore` also excludes virtual environments and `.env` files, which are common places for private settings. Before each push, review exactly what will be uploaded with:
+
+```powershell
+git status
+```
+
+## Contributing
+
+When adding a slang keyword, update both `NAME_MAP` and `print_slang_help()` in `src/yapton/__init__.py`, then add or update a `.yap` example that demonstrates it. Before committing, run an example and `yap --slang-help` to confirm the command still works.
+
+## Current status
+
+Yapton is an early educational prototype. Because programs ultimately execute as Python, only run `.yap` files you trust.

yapton-0.1.2/README.md

@@ -0,0 +1,159 @@
+# Yapton
+
+**Yapton is a small educational programming language that lets learners write Python-style programs with a few slang-inspired keywords.** A Yapton file (`.yap`) is translated to Python in memory and then run with the normal Python runtime. It is intended as a friendly bridge to Python, not as a replacement for it.
+
+## What this project does
+
+Yapton keeps ordinary Python syntax, data types, loops, expressions, and standard-library imports. It adds the following alternative words:
+
+| Yapton | Python meaning |
+| --- | --- |
+| `yap(...)` | `print(...)` |
+| `spill(...)` | `input(...)`, converting number-looking input to `int` or `float` |
+| `vibe name():` | `def name():` |
+| `fanumtax math` | `import math` |
+| `optionC` | `elif` |
+| `otherwise` | `else` |
+| `W` / `L` | `True` / `False` |
+
+For example:
+
+```yap
+fanumtax math
+
+vibe greet(name):
+    yap("Welcome,", name)
+
+name = spill("What is your name? ")
+greet(name)
+```
+
+## Project roles
+
+The codebase has three clear responsibilities:
+
+| Part | Role |
+| --- | --- |
+| `src/yapton/__init__.py` | The **Yapton language engine**. It translates Yapton keywords into Python tokens, provides `spill`, runs `.yap` files, and prints the slang reference. |
+| `src/yapton/cli.py` | The **command-line interface**. It accepts `yap program.yap` and `yap --slang-help`, then calls the language engine. |
+| `pyproject.toml` | The **package configuration**. It declares the Python requirement and installs the `yap` command. |
+| `sample1.yap` to `sample7.yap` | **Example Yapton programs**, ordered from small language demonstrations to larger projects. |
+| `yap.bat` | The **Windows launcher**. It runs `python -m yapton.cli`, so it never depends on a copied, moved, or stale virtual environment. |
+
+## Requirements
+
+- Python 3.10 or newer
+- PowerShell, Command Prompt, or another terminal
+- Git, only if you want to publish the project on GitHub
+
+Check that Python is available:
+
+```powershell
+py --version
+```
+
+If `py` is not found, install Python from [python.org](https://www.python.org/downloads/) and make sure the installer option to add Python to PATH is enabled.
+
+## Run it locally (Windows / PowerShell)
+
+Open PowerShell in this project folder, then create a fresh virtual environment and install Yapton in editable mode:
+
+```powershell
+cd "C:\path\to\Yapton"
+py -m venv .venv
+.\.venv\Scripts\Activate.ps1
+python -m pip install --upgrade pip
+python -m pip install -e .
+```
+
+Run an example:
+
+```powershell
+yap sample2.yap
+```
+
+Or run the larger example:
+
+```powershell
+yap sample5.yap
+```
+
+See the built-in language reference at any time:
+
+```powershell
+yap --slang-help
+```
+
+### If PowerShell blocks activation
+
+Activation is optional. Use the environment's Python directly instead:
+
+```powershell
+.\.venv\Scripts\python.exe -m pip install -e .
+.\.venv\Scripts\yap.exe sample2.yap
+```
+
+### Run a new program
+
+1. Create a file ending in `.yap`, such as `hello.yap`.
+2. Add Yapton/Python code.
+3. Run `yap hello.yap` while the environment is active.
+
+Indentation and colons work exactly like Python. Regular Python can be mixed with the Yapton keywords shown above.
+
+### Sample guide
+
+| File | Demonstrates |
+| --- | --- |
+| `sample1.yap` | Functions, loops, lists, conditions, and Yapton booleans. |
+| `sample2.yap` | Adding two numbers entered by the user. |
+| `sample3.yap` | Subtracting two numbers entered by the user. |
+| `sample4.yap` | Checking whether a number is positive or negative. |
+| `sample5.yap` | A menu-driven student score tracker using Yapton imports. |
+| `sample6.yap` | The same student tracker, showing that regular Python `import` also works. |
+| `sample7.yap` | A first-person 3D maze. Install its extra dependency first with `python -m pip install ursina`. |
+
+### Why `yap` works reliably in this folder
+
+Windows chooses `yap.bat` in the current folder before an installed `yap` command. This project launcher deliberately uses `python -m yapton.cli` instead of a hard-coded path to `venv\\Scripts\\python.exe`. That means it uses the same Python installation that installed Yapton and will not break merely because a virtual-environment folder was moved, deleted, or created on another computer.
+
+## Put it on GitHub
+
+1. Sign in to [GitHub](https://github.com/) and select **New repository**.
+2. Name it `Yapton`, choose Public or Private, and **do not** initialize it with a README, `.gitignore`, or license—the project already has the first two.
+3. In PowerShell, from this project folder, run the following. Replace `YOUR-USERNAME` with your GitHub username:
+
+```powershell
+cd "C:\path\to\Yapton"
+git init
+git add .
+git commit -m "Initial commit: Yapton language"
+git branch -M main
+git remote add origin https://github.com/YOUR-USERNAME/Yapton.git
+git push -u origin main
+```
+
+GitHub may ask you to sign in or create a personal access token when you push over HTTPS. If Git reports that a remote called `origin` already exists, update it instead:
+
+```powershell
+git remote set-url origin https://github.com/YOUR-USERNAME/Yapton.git
+git push -u origin main
+```
+
+The included `.gitignore` prevents virtual environments, cache files, and build outputs from being uploaded. Do not upload `.venv/` or `venv/`; each contributor should create their own using the local setup steps above.
+
+### Privacy check before publishing
+
+The publishable source files contain no personal names, email addresses, passwords, API keys, or local computer paths. The ignored `venv/` folder is machine-specific and must not be uploaded. The `.gitignore` also excludes virtual environments and `.env` files, which are common places for private settings. Before each push, review exactly what will be uploaded with:
+
+```powershell
+git status
+```
+
+## Contributing
+
+When adding a slang keyword, update both `NAME_MAP` and `print_slang_help()` in `src/yapton/__init__.py`, then add or update a `.yap` example that demonstrates it. Before committing, run an example and `yap --slang-help` to confirm the command still works.
+
+## Current status
+
+Yapton is an early educational prototype. Because programs ultimately execute as Python, only run `.yap` files you trust.

yapton-0.1.2/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "Yapton"
+version = "0.1.2"
+description = "Yapton is an fun Python library that helps kids learn how to code Python using fun slang-keywords"
+requires-python = ">=3.10"
+readme = "README.md"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[project.scripts]
+yap = "yapton.cli:main"

yapton-0.1.2/setup.cfg

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

yapton-0.1.2/src/Yapton.egg-info/PKG-INFO

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: Yapton
+Version: 0.1.2
+Summary: Yapton is an fun Python library that helps kids learn how to code Python using fun slang-keywords
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Yapton
+
+**Yapton is a small educational programming language that lets learners write Python-style programs with a few slang-inspired keywords.** A Yapton file (`.yap`) is translated to Python in memory and then run with the normal Python runtime. It is intended as a friendly bridge to Python, not as a replacement for it.
+
+## What this project does
+
+Yapton keeps ordinary Python syntax, data types, loops, expressions, and standard-library imports. It adds the following alternative words:
+
+| Yapton | Python meaning |
+| --- | --- |
+| `yap(...)` | `print(...)` |
+| `spill(...)` | `input(...)`, converting number-looking input to `int` or `float` |
+| `vibe name():` | `def name():` |
+| `fanumtax math` | `import math` |
+| `optionC` | `elif` |
+| `otherwise` | `else` |
+| `W` / `L` | `True` / `False` |
+
+For example:
+
+```yap
+fanumtax math
+
+vibe greet(name):
+    yap("Welcome,", name)
+
+name = spill("What is your name? ")
+greet(name)
+```
+
+## Project roles
+
+The codebase has three clear responsibilities:
+
+| Part | Role |
+| --- | --- |
+| `src/yapton/__init__.py` | The **Yapton language engine**. It translates Yapton keywords into Python tokens, provides `spill`, runs `.yap` files, and prints the slang reference. |
+| `src/yapton/cli.py` | The **command-line interface**. It accepts `yap program.yap` and `yap --slang-help`, then calls the language engine. |
+| `pyproject.toml` | The **package configuration**. It declares the Python requirement and installs the `yap` command. |
+| `sample1.yap` to `sample7.yap` | **Example Yapton programs**, ordered from small language demonstrations to larger projects. |
+| `yap.bat` | The **Windows launcher**. It runs `python -m yapton.cli`, so it never depends on a copied, moved, or stale virtual environment. |
+
+## Requirements
+
+- Python 3.10 or newer
+- PowerShell, Command Prompt, or another terminal
+- Git, only if you want to publish the project on GitHub
+
+Check that Python is available:
+
+```powershell
+py --version
+```
+
+If `py` is not found, install Python from [python.org](https://www.python.org/downloads/) and make sure the installer option to add Python to PATH is enabled.
+
+## Run it locally (Windows / PowerShell)
+
+Open PowerShell in this project folder, then create a fresh virtual environment and install Yapton in editable mode:
+
+```powershell
+cd "C:\path\to\Yapton"
+py -m venv .venv
+.\.venv\Scripts\Activate.ps1
+python -m pip install --upgrade pip
+python -m pip install -e .
+```
+
+Run an example:
+
+```powershell
+yap sample2.yap
+```
+
+Or run the larger example:
+
+```powershell
+yap sample5.yap
+```
+
+See the built-in language reference at any time:
+
+```powershell
+yap --slang-help
+```
+
+### If PowerShell blocks activation
+
+Activation is optional. Use the environment's Python directly instead:
+
+```powershell
+.\.venv\Scripts\python.exe -m pip install -e .
+.\.venv\Scripts\yap.exe sample2.yap
+```
+
+### Run a new program
+
+1. Create a file ending in `.yap`, such as `hello.yap`.
+2. Add Yapton/Python code.
+3. Run `yap hello.yap` while the environment is active.
+
+Indentation and colons work exactly like Python. Regular Python can be mixed with the Yapton keywords shown above.
+
+### Sample guide
+
+| File | Demonstrates |
+| --- | --- |
+| `sample1.yap` | Functions, loops, lists, conditions, and Yapton booleans. |
+| `sample2.yap` | Adding two numbers entered by the user. |
+| `sample3.yap` | Subtracting two numbers entered by the user. |
+| `sample4.yap` | Checking whether a number is positive or negative. |
+| `sample5.yap` | A menu-driven student score tracker using Yapton imports. |
+| `sample6.yap` | The same student tracker, showing that regular Python `import` also works. |
+| `sample7.yap` | A first-person 3D maze. Install its extra dependency first with `python -m pip install ursina`. |
+
+### Why `yap` works reliably in this folder
+
+Windows chooses `yap.bat` in the current folder before an installed `yap` command. This project launcher deliberately uses `python -m yapton.cli` instead of a hard-coded path to `venv\\Scripts\\python.exe`. That means it uses the same Python installation that installed Yapton and will not break merely because a virtual-environment folder was moved, deleted, or created on another computer.
+
+## Put it on GitHub
+
+1. Sign in to [GitHub](https://github.com/) and select **New repository**.
+2. Name it `Yapton`, choose Public or Private, and **do not** initialize it with a README, `.gitignore`, or license—the project already has the first two.
+3. In PowerShell, from this project folder, run the following. Replace `YOUR-USERNAME` with your GitHub username:
+
+```powershell
+cd "C:\path\to\Yapton"
+git init
+git add .
+git commit -m "Initial commit: Yapton language"
+git branch -M main
+git remote add origin https://github.com/YOUR-USERNAME/Yapton.git
+git push -u origin main
+```
+
+GitHub may ask you to sign in or create a personal access token when you push over HTTPS. If Git reports that a remote called `origin` already exists, update it instead:
+
+```powershell
+git remote set-url origin https://github.com/YOUR-USERNAME/Yapton.git
+git push -u origin main
+```
+
+The included `.gitignore` prevents virtual environments, cache files, and build outputs from being uploaded. Do not upload `.venv/` or `venv/`; each contributor should create their own using the local setup steps above.
+
+### Privacy check before publishing
+
+The publishable source files contain no personal names, email addresses, passwords, API keys, or local computer paths. The ignored `venv/` folder is machine-specific and must not be uploaded. The `.gitignore` also excludes virtual environments and `.env` files, which are common places for private settings. Before each push, review exactly what will be uploaded with:
+
+```powershell
+git status
+```
+
+## Contributing
+
+When adding a slang keyword, update both `NAME_MAP` and `print_slang_help()` in `src/yapton/__init__.py`, then add or update a `.yap` example that demonstrates it. Before committing, run an example and `yap --slang-help` to confirm the command still works.
+
+## Current status
+
+Yapton is an early educational prototype. Because programs ultimately execute as Python, only run `.yap` files you trust.

yapton-0.1.2/src/Yapton.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+src/Yapton.egg-info/PKG-INFO
+src/Yapton.egg-info/SOURCES.txt
+src/Yapton.egg-info/dependency_links.txt
+src/Yapton.egg-info/entry_points.txt
+src/Yapton.egg-info/top_level.txt
+src/yapton/__init__.py
+src/yapton/cli.py
+src/yapton.egg-info/PKG-INFO
+src/yapton.egg-info/SOURCES.txt
+src/yapton.egg-info/dependency_links.txt
+src/yapton.egg-info/entry_points.txt
+src/yapton.egg-info/top_level.txt

yapton-0.1.2/src/Yapton.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

yapton-0.1.2/src/Yapton.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+yap = yapton.cli:main

yapton-0.1.2/src/Yapton.egg-info/top_level.txt

@@ -0,0 +1 @@
+yapton

yapton-0.1.2/src/yapton/__init__.py

@@ -0,0 +1,111 @@
+import sys
+import io
+import tokenize
+
+# Yapton -> Python keyword / literal mapping
+# We only touch NAME tokens, so strings and comments stay the same.
+NAME_MAP = {
+    # control flow
+    "optionC": "elif",       # optionC -> elif
+    "otherwise": "else",     # otherwise -> else
+
+    # booleans
+    "W": "True",             # W -> True
+    "L": "False",            # L -> False
+
+    # functions / I/O
+    "yap": "print",          # yap(...) -> print(...)
+    # NOTE: spill is implemented as a real Python helper function below,
+    # not just a rename, so it can auto-convert numbers.
+
+    # function definition
+    "vibe": "def",           # vibe foo(): -> def foo():
+
+    # imports
+    "fanumtax": "import",    # fanumtax math -> import math
+}
+
+
+def spill(prompt: str = "") -> object:
+    """Yapton input function.
+
+    Behaves like Python's input(), but tries to convert what the user typed
+    into an int or float. If that fails, it returns the raw string.
+    """
+
+    raw = input(prompt)
+    # Try int first
+    try:
+        return int(raw)
+    except ValueError:
+        pass
+
+    # Then try float
+    try:
+        return float(raw)
+    except ValueError:
+        return raw
+
+
+def transpile(source: str) -> str:
+    """Turn Yapton source into real Python source.
+
+    This uses the tokenize module so we only rewrite identifier tokens,
+    not things inside strings or comments. That way Python's own
+    features (types, lists, slicing, loops, etc.) just work.
+    """
+
+    out_tokens = []
+
+    # tokenize.tokenize works on bytes; we wrap the string in a BytesIO
+    byte_stream = io.BytesIO(source.encode("utf-8"))
+    try:
+        for tok in tokenize.tokenize(byte_stream.readline):
+            tok_type = tok.type
+            tok_string = tok.string
+
+            # Replace only identifier / name tokens that are in our mapping
+            if tok_type == tokenize.NAME and tok_string in NAME_MAP:
+                tok_string = NAME_MAP[tok_string]
+                tok = tokenize.TokenInfo(tok_type, tok_string, tok.start, tok.end, tok.line)
+
+            out_tokens.append(tok)
+    except tokenize.TokenError as exc:
+        raise SyntaxError(f"Yapton could not be tokenized: {exc}")
+
+    # untokenize back to Python code
+    return tokenize.untokenize(out_tokens).decode("utf-8")
+
+
+def run_file(path: str) -> None:
+    with open(path, "r", encoding="utf-8") as f:
+        source = f.read()
+
+    python_code = transpile(source)
+
+    # Execute the transpiled Python. We let Python handle all the real
+    # work: numbers, strings, lists, slicing, loops, functions, imports, etc.
+    # Expose spill() so Yapton code can call it directly.
+    globals_dict = {"__name__": "__main__", "spill": spill}
+    try:
+        exec(python_code, globals_dict)
+    except Exception as exc:  # noqa: BLE001
+        # Wrap any Python error with your custom prefix.
+        print(f"error 67: {exc.__class__.__name__}: {exc}")
+        sys.exit(1)
+
+
+def print_slang_help() -> None:
+    print("Yapton slang dictionary:\n")
+    print("  W         -> True (boolean)")
+    print("  L         -> False (boolean)")
+    print("  if        -> if (same as Python)")
+    print("  optionC   -> elif")
+    print("  otherwise -> else")
+    print("  yap       -> print")
+    print("  spill     -> input (auto-converts to number when possible)")
+    print("  vibe      -> def (define a function)")
+    print("  fanumtax  -> import (bring in Python modules)")
+    print("  #         -> comment (same as Python)")
+    print("  type(...) -> same as Python type() and casts")
+    print("  lists, slicing, for/while loops -> same as Python syntax")

yapton-0.1.2/src/yapton/cli.py

@@ -0,0 +1,25 @@
+import sys
+
+from . import print_slang_help, run_file
+
+
+def main(argv: list[str] | None = None) -> None:
+    if argv is None:
+        argv = sys.argv[1:]
+
+    # Usage:
+    #   yap program.yap
+    #   yap --slang-help
+    if len(argv) == 1 and argv[0] == "--slang-help":
+        print_slang_help()
+        raise SystemExit(0)
+
+    if len(argv) != 1:
+        print("Usage: yap <program.yap> | --slang-help")
+        raise SystemExit(1)
+
+    run_file(argv[0])
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()