Yapton 0.1.2__py3-none-any.whl

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/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()

yapton-0.1.2.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,8 @@
+yapton/__init__.py,sha256=WVqklB4ELcwy8IxTED0Z4TTRCvkDGKhUykLjFnrmE80,3728
+yapton/cli.py,sha256=m7R2gAImAYsr7uyB4sZkjO3SVwOTcHKi3tocKCxsOYQ,541
+yapton-0.1.2.dist-info/licenses/LICENSE,sha256=k6AAdrqOHkz-lKfQCbjReP0sxkLgIVvBWWRLTdLCMZ0,1089
+yapton-0.1.2.dist-info/METADATA,sha256=VEDPN26hBYDjPLr4fUpT95psoa_iBVncDHt_YNeryO8,6566
+yapton-0.1.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+yapton-0.1.2.dist-info/entry_points.txt,sha256=cCjLYS2eslC0PcRIOW7RiM0S_3mtkpMNLZN-EvFzqEs,40
+yapton-0.1.2.dist-info/top_level.txt,sha256=c5_o2DCHM4QMfWssXIEPfXADr3-uyvXenaj5HOZmknc,7
+yapton-0.1.2.dist-info/RECORD,,

yapton-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

yapton-0.1.2.dist-info/entry_points.txt

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

yapton-0.1.2.dist-info/licenses/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.dist-info/top_level.txt

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