paramath3 3.1.3__tar.gz

paramath3-3.1.3/LICENSE

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

paramath3-3.1.3/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: paramath3
+Version: 3.1.3
+Summary: Paramath v3 compiler
+Author: Kaemori Yozzan
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/kaemori/paramath3
+Project-URL: Repository, https://github.com/kaemori/paramath3
+Keywords: dsl,math,compiler,paramath
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: full
+Requires-Dist: tqdm>=4.66; extra == "full"
+Requires-Dist: sympy>=1.12; extra == "full"
+Dynamic: license-file
+
+# The Paramath Programming Language
+
+Paramath is a Domain-Specific Language (DSL) that transforms procedural math code into mathematical expressions. Paramath compiles into math expressions with operations commonly found on standard scientific calculators, allowing evaluation of logical code on mathematical hardware.
+
+All this, powered by Python.
+
+> **Why the name "Paramath"?**  
+> The word "paramath" comes from the portmanteau of "parenthesis" and "mathematics".
+
+## Features
+
+- **Infix + prefix syntax**: Arithmetic and comparators are infix; other operations are function-style prefix calls
+- **Automatic optimization**: Simplification and duplicate subexpression extraction
+- **Loop unrolling**: Compile-time iteration for performance
+- **Flexible output**: Display and/or write compiled expressions to files
+
+## Documentation
+
+- Language reference: [paramath_syntax_guide.md](https://github.com/kaemori/paramath3/blob/main/docs/paramath_syntax_guide.md)
+- Developer docs: [paramath_docs_developers.md](https://github.com/kaemori/paramath3/blob/main/docs/paramath_docs_developers.md)
+
+## Installation
+
+### Method 1 (PyPI)
+
+#### Generic PyPI install (virtual environment)
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install paramath3
+```
+
+Run the compiler:
+
+```bash
+paramath3 --version
+```
+
+#### Recommended on Arch Linux: use pipx
+
+Arch enforces Python's externally managed environment (PEP 668), so global `pip install` may fail. Use `pipx` instead:
+
+```bash
+sudo pacman -S --needed python-pipx
+pipx ensurepath
+```
+
+Restart your shell, then install Paramath:
+
+```bash
+pipx install paramath3
+```
+
+### Method 2 (Direct Git Clone)
+
+Clone the repository:
+
+```bash
+git clone https://github.com/kaemori/paramath3.git
+cd paramath3
+```
+
+Run directly from source:
+
+```bash
+python cli.py --version
+```
+
+Install as a local package (recommended):
+
+```bash
+pip install -e .
+paramath3 --version
+```
+
+Optional dependencies:
+
+```bash
+pip install -e .[full]
+```
+
+## Usage
+
+The compiler can be run with:
+
+```bash
+python cli.py [-h] [-V] [-o FILE] [-d] [-v] [-s] [-S] [-O] [-m] [-t] [-L FILE] [-p] [--no-color] [filepath]
+```
+
+Options:
+
+- `filepath` input Paramath file
+- `-h, --help` show help and exit
+- `-V, --version` print Paramath version and exit
+- `-o, --output FILE` output file (default: `math.txt`)
+- `-d, --debug` enable debug output
+- `-v, --verbose` enable verbose output
+- `-s, --suppress` suppress non-error output
+- `-S, --silent` suppress all output
+- `-O, --print-output` print compiled output
+- `-m, --math-output` format output for calculators (`^`, implicit multiplication, `ANS`)
+- `-t, --trust` allow compile-time Python eval (`:=`)
+- `-L, --logfile FILE` write logs to file
+- `-p, --progress` show parsing/processing progress bars
+- `--no-color` disable colored CLI output
+
+## Testing
+
+Test layout:
+
+- `paramath_test/` contains `.pm3` fixture programs
+- `tests/` contains Python test modules (`.py`)
+
+Run the Paramath v3 suite:
+
+```bash
+python -m unittest tests/pm_test_suite.py -v
+```
+
+The fixture set in `paramath_test/` is a file-for-file (`1:1`) conversion of `_for_ref/paramath/paramath_tests` into Paramath v3 syntax, including `examples/number_test`.
+
+## License
+
+This project is licensed under the [MIT License](https://github.com/kaemori/paramath3/blob/main/LICENSE).

paramath3-3.1.3/README.md

@@ -0,0 +1,125 @@
+# The Paramath Programming Language
+
+Paramath is a Domain-Specific Language (DSL) that transforms procedural math code into mathematical expressions. Paramath compiles into math expressions with operations commonly found on standard scientific calculators, allowing evaluation of logical code on mathematical hardware.
+
+All this, powered by Python.
+
+> **Why the name "Paramath"?**  
+> The word "paramath" comes from the portmanteau of "parenthesis" and "mathematics".
+
+## Features
+
+- **Infix + prefix syntax**: Arithmetic and comparators are infix; other operations are function-style prefix calls
+- **Automatic optimization**: Simplification and duplicate subexpression extraction
+- **Loop unrolling**: Compile-time iteration for performance
+- **Flexible output**: Display and/or write compiled expressions to files
+
+## Documentation
+
+- Language reference: [paramath_syntax_guide.md](https://github.com/kaemori/paramath3/blob/main/docs/paramath_syntax_guide.md)
+- Developer docs: [paramath_docs_developers.md](https://github.com/kaemori/paramath3/blob/main/docs/paramath_docs_developers.md)
+
+## Installation
+
+### Method 1 (PyPI)
+
+#### Generic PyPI install (virtual environment)
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install paramath3
+```
+
+Run the compiler:
+
+```bash
+paramath3 --version
+```
+
+#### Recommended on Arch Linux: use pipx
+
+Arch enforces Python's externally managed environment (PEP 668), so global `pip install` may fail. Use `pipx` instead:
+
+```bash
+sudo pacman -S --needed python-pipx
+pipx ensurepath
+```
+
+Restart your shell, then install Paramath:
+
+```bash
+pipx install paramath3
+```
+
+### Method 2 (Direct Git Clone)
+
+Clone the repository:
+
+```bash
+git clone https://github.com/kaemori/paramath3.git
+cd paramath3
+```
+
+Run directly from source:
+
+```bash
+python cli.py --version
+```
+
+Install as a local package (recommended):
+
+```bash
+pip install -e .
+paramath3 --version
+```
+
+Optional dependencies:
+
+```bash
+pip install -e .[full]
+```
+
+## Usage
+
+The compiler can be run with:
+
+```bash
+python cli.py [-h] [-V] [-o FILE] [-d] [-v] [-s] [-S] [-O] [-m] [-t] [-L FILE] [-p] [--no-color] [filepath]
+```
+
+Options:
+
+- `filepath` input Paramath file
+- `-h, --help` show help and exit
+- `-V, --version` print Paramath version and exit
+- `-o, --output FILE` output file (default: `math.txt`)
+- `-d, --debug` enable debug output
+- `-v, --verbose` enable verbose output
+- `-s, --suppress` suppress non-error output
+- `-S, --silent` suppress all output
+- `-O, --print-output` print compiled output
+- `-m, --math-output` format output for calculators (`^`, implicit multiplication, `ANS`)
+- `-t, --trust` allow compile-time Python eval (`:=`)
+- `-L, --logfile FILE` write logs to file
+- `-p, --progress` show parsing/processing progress bars
+- `--no-color` disable colored CLI output
+
+## Testing
+
+Test layout:
+
+- `paramath_test/` contains `.pm3` fixture programs
+- `tests/` contains Python test modules (`.py`)
+
+Run the Paramath v3 suite:
+
+```bash
+python -m unittest tests/pm_test_suite.py -v
+```
+
+The fixture set in `paramath_test/` is a file-for-file (`1:1`) conversion of `_for_ref/paramath/paramath_tests` into Paramath v3 syntax, including `examples/number_test`.
+
+## License
+
+This project is licensed under the [MIT License](https://github.com/kaemori/paramath3/blob/main/LICENSE).

paramath3-3.1.3/cli.py

@@ -0,0 +1,332 @@
+#!/usr/bin/env python3
+import time
+
+time_start = time.time()
+import os
+
+import_os_time = time.time() - time_start
+last_time = time.time()
+import builtins
+
+import_builtins_time = time.time() - last_time
+last_time = time.time()
+import argparse
+
+import_argparse_time = time.time() - last_time
+last_time = time.time()
+import sys
+
+import_sys_time = time.time() - last_time
+last_time = time.time()
+from colors import colors
+
+import_colors_time = time.time() - last_time
+last_time = time.time()
+from paramath3 import (
+    code_to_lines,
+    parse_pm3_to_ast,
+    process_asts,
+    check_python_eval,
+    print_debug,
+    print_verbose,
+)
+import paramath3
+
+import_paramath_time = time.time() - last_time
+main_time = time.time()
+
+PROGRAM_VERSION = "3.1.3"
+
+
+def _supports_color(stream) -> bool:
+    if os.getenv("NO_COLOR") is not None:
+        return False
+    return hasattr(stream, "isatty") and stream.isatty()
+
+
+def _cli_color_enabled() -> bool:
+    # allow user to force-disable without waiting for argparse
+    if "--no-color" in sys.argv:
+        return False
+    return _supports_color(sys.stdout)
+
+
+COLOR_ENABLED = _cli_color_enabled()
+
+
+def _c(code: str, text: str) -> str:
+    if not COLOR_ENABLED:
+        return text
+    return f"{code}{text}{colors.Reset.reset}"
+
+
+def _title(text: str) -> str:
+    return _c(colors.BoldHighIntensity.cyan, text)
+
+
+def _ok(text: str) -> str:
+    return _c(colors.BoldHighIntensity.green, text)
+
+
+def _warn(text: str) -> str:
+    return _c(colors.BoldHighIntensity.yellow, text)
+
+
+def _err(text: str) -> str:
+    return _c(colors.BoldHighIntensity.red, text)
+
+
+def _dim(text: str) -> str:
+    return _c(colors.HighIntensity.black, text)
+
+
+def _path(text: str) -> str:
+    return _c(colors.HighIntensity.cyan, text)
+
+
+def _clear(text: str) -> str:
+    return _c(colors.Reset.reset, text)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Paramath Compiler",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+examples:
+  paramath3 testfile.pm
+  paramath3 testfile.pm -dv
+  paramath3 testfile.pm -sL output.log
+  paramath3 testfile.pm -dvL debug.log
+  paramath3 testfile.pm -tmo compiled.txt -O
+  paramath3 testfile.pm -mtpo compiled.txt
+        """,
+    )
+
+    parser.add_argument(
+        "filepath",
+        nargs="?",
+        help="Input paramath file",
+    )
+    parser.add_argument(
+        "-V",
+        "--version",
+        action="version",
+        version=f"Paramath {PROGRAM_VERSION}",
+        help="prints the Paramath version number and exits",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        default="math.txt",
+        metavar="FILE",
+        help="output file (default: math.txt)",
+    )
+    parser.add_argument(
+        "-d", "--debug", action="store_true", help="enable debug output"
+    )
+    parser.add_argument(
+        "-v", "--verbose", action="store_true", help="enable verbose output"
+    )
+    parser.add_argument(
+        "-s", "--suppress", action="store_true", help="suppress non-error output"
+    )
+    parser.add_argument(
+        "-S", "--silent", action="store_true", help="suppress ALL output"
+    )
+    parser.add_argument(
+        "-O",
+        "--print-output",
+        action="store_true",
+        help="print out the compiled output",
+    )
+    parser.add_argument(
+        "-m",
+        "--math-output",
+        action="store_true",
+        help="format output for calculators (use ^, implicit multiplication, capital ANS)",
+    )
+    parser.add_argument(
+        "-t",
+        "--trust",
+        action="store_true",
+        help="enable unsafe code execution (default: disabled) (WARNING: may be dangerous! use at your own risk!)",
+    )
+    parser.add_argument(
+        "-L",
+        "--logfile",
+        required=False,
+        metavar="FILE",
+        help="write logs from verbose or debug to FILE",
+    )
+    parser.add_argument(
+        "-p",
+        "--progress",
+        action="store_true",
+        help="show parsing progress using tqdm (WARNING: may slow down parsing)",
+    )
+    parser.add_argument(
+        "--no-color",
+        action="store_true",
+        help="disable colored CLI output",
+    )
+
+    # nts: verbose means human readable logs
+    # debug means less-human-readable, debugging-focused logs
+    args = parser.parse_args()
+    verbose = args.verbose
+    debug = args.debug
+    logfile = args.logfile
+    trust = args.trust
+    progress = args.progress
+    math_output = args.math_output
+    output_file = args.output
+    print_output = args.print_output
+    input_file = args.filepath
+
+    old_print = None
+    if args.suppress or args.silent:
+        # just monkeypatch print to do nothing
+        old_print = builtins.print
+        if args.silent:
+            old_print = lambda *a, **k: None
+        builtins.print = lambda *a, **k: None
+
+    print(_title(f"Paramath v{PROGRAM_VERSION}") + "\n")
+
+    global COLOR_ENABLED
+    if args.no_color:
+        COLOR_ENABLED = False
+
+    if args.filepath is None:
+        parser.print_help()
+        return
+
+    if progress and (debug or verbose):
+        raise ValueError("Progress bar cannot be used with verbose or debug modes")
+
+    if verbose:
+        paramath3.VERBOSE = True
+        print_verbose("verbose logging enabled")
+
+    if debug:
+        paramath3.DEBUG = True
+        print_debug("debug logging enabled")
+
+    if logfile:
+        paramath3.LOGFILE = logfile
+        print_verbose(f'Logging to file: "{logfile}"')
+        with open(logfile, "w") as f:
+            f.write(
+                f"Paramath v{PROGRAM_VERSION} Logfile (at {time.strftime('%Y-%m-%d %H:%M:%S')})\n\n"
+            )
+        print_debug(f'Logfile "{logfile}" initialized.')
+
+    print_debug(
+        "argv/options: "
+        + str(
+            {
+                "input": input_file,
+                "output": output_file,
+                "progress": progress,
+                "trust": trust,
+                "math_output": math_output,
+                "print_output": print_output,
+                "verbose": verbose,
+                "debug": debug,
+                "logfile": logfile,
+            }
+        )
+    )
+
+    print_debug(f"Import os time: {import_os_time*1000:.6f}ms")
+    print_debug(f"Import builtins time: {import_builtins_time*1000:.6f}ms")
+    print_debug(f"Import argparse time: {import_argparse_time*1000:.6f}ms")
+    print_debug(f"Import sys time: {import_sys_time*1000:.6f}ms")
+    print_debug(f"Import colors time: {import_colors_time*1000:.6f}ms")
+    print_debug(f"Import paramath3 time: {import_paramath_time*1000:.6f}ms")
+    print_debug(f"Init finished: {(time.time() - time_start)*1000:.6f}ms")
+
+    try:
+        with open(input_file) as f:
+            code = code_to_lines(f.readlines())
+        print_verbose(f"loaded script: {len(code)} non-empty lines from '{input_file}'")
+        print_debug(f"script content: {code}")
+
+        if not trust:
+            print(
+                _warn("Running as untrusted.") + " " + _dim("No code will be executed.")
+            )
+            python_eval = check_python_eval(code)
+            if python_eval:
+                if old_print is not None:
+                    builtins.print = old_print
+
+                print(_err("The following Python code was found in the script:"))
+                for line_no, line in python_eval:
+                    print(_err(f"Line {line_no}:") + f' "{line}"')
+                print(
+                    _err("Aborting due to untrusted code execution.")
+                    + " "
+                    + _dim("Review the code, THEN run with -t to trust.")
+                )
+                sys.exit(1)
+
+            print("")
+
+        asts = parse_pm3_to_ast(code, progress=progress)
+        print_verbose(f"parsed to ASTs: {len(asts)} outputs")
+        outputs = process_asts(asts, progress=progress)
+        print_verbose(f"compiled outputs: {len(outputs)} expressions")
+
+        with open(output_file, "w", encoding="utf-8") as f:
+            for output, expr in outputs:
+                if math_output:
+                    output = (
+                        output.replace("**", "^")
+                        .replace("*", "")
+                        .replace("ans", "ANS")
+                        .replace("pi", "π")
+                        .replace("e", "ℯ")
+                    )
+
+                f.write(f"to {output}:\n")
+                f.write(expr + "\n")
+                if print_output:
+                    print(f"to {output}:")
+                    print(expr)
+
+        print(_ok("=== Compilation successful! ==="))
+        print(_dim("Compiled in") + _ok(f" {(time.time() - main_time):.6f}s!"))
+        print(_dim("Generated ") + _clear(f"{len(outputs)} outputs"))
+        print(_dim("Output written to ") + _path(f'"{output_file}"'))
+
+    except FileNotFoundError:
+        if old_print is not None:
+            builtins.print = old_print
+        print(_err("=== Compilation failed! ==="))
+        print(
+            _err("Error:")
+            + " "
+            + _dim("Input file ")
+            + _path(f'"{input_file}"')
+            + _dim(" not found!")
+        )
+
+    except Exception as e:
+        import traceback
+
+        if old_print is not None:
+            builtins.print = old_print
+        print(_err("=== Compilation failed! ==="))
+        print(_err("Error:") + " " + str(e))
+        if debug:
+            print(
+                _dim(
+                    f"If this is an error in the compiler,\n{"".join(traceback.format_exception(e)[1:])}."
+                )
+            )
+
+
+if __name__ == "__main__":
+    main()

paramath3-3.1.3/colors.py

@@ -0,0 +1,76 @@
+class Colors:
+    class Regular:
+        black = "\033[0;30m"
+        red = "\033[0;31m"
+        green = "\033[0;32m"
+        yellow = "\033[0;33m"
+        blue = "\033[0;34m"
+        purple = "\033[0;35m"
+        cyan = "\033[0;36m"
+        white = "\033[0;37m"
+
+    class Bold:
+        black = "\033[1;30m"
+        red = "\033[1;31m"
+        green = "\033[1;32m"
+        yellow = "\033[1;33m"
+        blue = "\033[1;34m"
+        purple = "\033[1;35m"
+        cyan = "\033[1;36m"
+        white = "\033[1;37m"
+
+    class Underline:
+        black = "\033[4;30m"
+        red = "\033[4;31m"
+        green = "\033[4;32m"
+        yellow = "\033[4;33m"
+        blue = "\033[4;34m"
+        purple = "\033[4;35m"
+        cyan = "\033[4;36m"
+        white = "\033[4;37m"
+
+    class Background:
+        black = "\033[40m"
+        red = "\033[41m"
+        green = "\033[42m"
+        yellow = "\033[43m"
+        blue = "\033[44m"
+        purple = "\033[45m"
+        cyan = "\033[46m"
+        white = "\033[47m"
+
+    class HighIntensity:
+        black = "\033[0;90m"
+        red = "\033[0;91m"
+        green = "\033[0;92m"
+        yellow = "\033[0;93m"
+        blue = "\033[0;94m"
+        purple = "\033[0;95m"
+        cyan = "\033[0;96m"
+        white = "\033[0;97m"
+
+    class BoldHighIntensity:
+        black = "\033[1;90m"
+        red = "\033[1;91m"
+        green = "\033[1;92m"
+        yellow = "\033[1;93m"
+        blue = "\033[1;94m"
+        purple = "\033[1;95m"
+        cyan = "\033[1;96m"
+        white = "\033[1;97m"
+
+    class HighIntensityBackground:
+        black = "\033[0;100m"
+        red = "\033[0;101m"
+        green = "\033[0;102m"
+        yellow = "\033[0;103m"
+        blue = "\033[0;104m"
+        purple = "\033[0;105m"
+        cyan = "\033[0;106m"
+        white = "\033[0;107m"
+
+    class Reset:
+        reset = "\033[0m"
+
+
+colors = Colors()