the-pyro-lang 0.1.4__tar.gz

the_pyro_lang-0.1.4/LICENSE

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

the_pyro_lang-0.1.4/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+recursive-include examples *.pyro

the_pyro_lang-0.1.4/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: the-pyro-lang
+Version: 0.1.4
+Summary: A friendlier Python that compiles to Python
+Home-page: https://github.com/pyro-lang/pyro
+Author: Pyro Contributors
+License: MIT
+Project-URL: Homepage, https://github.com/pyro-lang/pyro
+Project-URL: Bug Reports, https://github.com/pyro-lang/pyro/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Pyro – A friendlier Python
+
+Pyro is a programming language that feels like Python but removes the rough edges: no indentation errors, no `self`, no mandatory `print()` parentheses, and blocks end with `end`.
+
+It **compiles to standard Python** – so you can use any Python library (NumPy, Django, TensorFlow) without change.
+
+## Why Pyro?
+
+| Feature | Python | Pyro |
+|---------|--------|------|
+| Blocks | Indentation sensitive | `if ... end` (no indentation errors) |
+| Function definition | `def` | `func` |
+| Method first argument | `self` | `this` (shorter) |
+| `print` | `print("hello")` | `print "hello"` (or with parens) |
+| Colons after headers | Required | Optional |
+| Variable assignment | `x = 1` | `make x = 1` or `x = 1` |
+| Ranges | `range(1,6)` | `1..5` (inclusive) |
+
+## Example
+
+```pyro
+print "Hello from Pyro!"
+
+make x = 10
+y = 20
+print "Sum: " + str(x + y)
+
+if x > 5
+    print "x is large"
+else
+    print "x is small"
+end
+
+func greet(name)
+    print "Hello, " + name
+end
+
+greet("world")
+
+for i in 1..5
+    print i
+end
+
+class Person
+    constructor(name)
+        this.name = name
+    end
+    func say_hello()
+        print "My name is " + this.name
+    end
+end
+
+p = Person("Pyro")
+p.say_hello()
+```
+## Installation
+```
+pip install pyro-lang
+```
+## Usage
+
+Compile a .pyro file to Python:
+
+```
+pyro compile input.pyro -o output.py
+```
+
+Run directly:
+
+```
+pyro run input.pyro
+```
+
+Or use as a Python module:
+
+```
+from pyro import compile_pyro
+py_code = compile_pyro(source)
+exec(py_code)
+```
+
+## Roadmap
+
+    MVP (variables, arithmetic, if/else, loops, functions, classes)
+
+    Compile to Python source
+
+    Import system
+
+    Exception handling (try/catch)
+
+    List/dict comprehensions
+
+    Standalone bytecode compiler (direct .pyc output)
+
+    Self‑hosting (compiler written in Pyro itself)
+
+## Contributing
+
+See CONTRIBUTING.md (to be added). For now, open issues or PRs on GitHub.
+License
+
+MIT – use it anywhere, even in commercial projects.
+
+
+
+---
+

the_pyro_lang-0.1.4/README.md

@@ -0,0 +1,108 @@
+# Pyro – A friendlier Python
+
+Pyro is a programming language that feels like Python but removes the rough edges: no indentation errors, no `self`, no mandatory `print()` parentheses, and blocks end with `end`.
+
+It **compiles to standard Python** – so you can use any Python library (NumPy, Django, TensorFlow) without change.
+
+## Why Pyro?
+
+| Feature | Python | Pyro |
+|---------|--------|------|
+| Blocks | Indentation sensitive | `if ... end` (no indentation errors) |
+| Function definition | `def` | `func` |
+| Method first argument | `self` | `this` (shorter) |
+| `print` | `print("hello")` | `print "hello"` (or with parens) |
+| Colons after headers | Required | Optional |
+| Variable assignment | `x = 1` | `make x = 1` or `x = 1` |
+| Ranges | `range(1,6)` | `1..5` (inclusive) |
+
+## Example
+
+```pyro
+print "Hello from Pyro!"
+
+make x = 10
+y = 20
+print "Sum: " + str(x + y)
+
+if x > 5
+    print "x is large"
+else
+    print "x is small"
+end
+
+func greet(name)
+    print "Hello, " + name
+end
+
+greet("world")
+
+for i in 1..5
+    print i
+end
+
+class Person
+    constructor(name)
+        this.name = name
+    end
+    func say_hello()
+        print "My name is " + this.name
+    end
+end
+
+p = Person("Pyro")
+p.say_hello()
+```
+## Installation
+```
+pip install pyro-lang
+```
+## Usage
+
+Compile a .pyro file to Python:
+
+```
+pyro compile input.pyro -o output.py
+```
+
+Run directly:
+
+```
+pyro run input.pyro
+```
+
+Or use as a Python module:
+
+```
+from pyro import compile_pyro
+py_code = compile_pyro(source)
+exec(py_code)
+```
+
+## Roadmap
+
+    MVP (variables, arithmetic, if/else, loops, functions, classes)
+
+    Compile to Python source
+
+    Import system
+
+    Exception handling (try/catch)
+
+    List/dict comprehensions
+
+    Standalone bytecode compiler (direct .pyc output)
+
+    Self‑hosting (compiler written in Pyro itself)
+
+## Contributing
+
+See CONTRIBUTING.md (to be added). For now, open issues or PRs on GitHub.
+License
+
+MIT – use it anywhere, even in commercial projects.
+
+
+
+---
+

the_pyro_lang-0.1.4/examples/class.pyro

@@ -0,0 +1,12 @@
+class Person
+    constructor(name, age)
+        this.name = name
+        this.age = age
+    end
+    func introduce()
+        print "I'm " + this.name + ", age " + str(this.age)
+    end
+end
+
+p = Person("Pyro", 1)
+p.introduce()

the_pyro_lang-0.1.4/examples/fibonacci.pyro

@@ -0,0 +1,12 @@
+func fib(n)
+    if n <= 1
+        return n
+    else
+        return fib(n-1) + fib(n-2)
+    end
+end
+
+print "Fibonacci sequence:"
+for i in 0..10
+    print fib(i)
+end

the_pyro_lang-0.1.4/examples/hello.pyro

@@ -0,0 +1,17 @@
+print "Welcome to Pyro!"
+
+make name = "world"
+print "Hello, " + name
+
+x = 10
+if x > 5
+    print "x is greater than 5"
+else
+    print "x is small"
+end
+
+func greet(person)
+    print "Greetings, " + person
+end
+
+greet("Pyro user")

the_pyro_lang-0.1.4/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "the-pyro-lang"
+version = "0.1.4"
+description = "A friendlier Python that compiles to Python"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [{name = "Pyro Contributors"}]
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = []
+
+[project.scripts]
+pyro = "pyro.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/pyro-lang/pyro"
+"Bug Reports" = "https://github.com/pyro-lang/pyro/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["pyro*"]

the_pyro_lang-0.1.4/pyro/__init__.py

@@ -0,0 +1,8 @@
+import sys
+from .compiler import compile_pyro, compile_file
+from .cli import main
+
+if sys.version_info < (3, 10):
+    raise ImportError("Pyro requires Python 3.10 or higher")
+__version__ = "0.1.3"
+__all__ = ["compile_pyro", "compile_file", "main"]

the_pyro_lang-0.1.4/pyro/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

the_pyro_lang-0.1.4/pyro/ast_nodes.py

@@ -0,0 +1,94 @@
+class ASTNode:
+    pass
+
+class Program(ASTNode):
+    def __init__(self, statements):
+        self.statements = statements
+
+class FuncDef(ASTNode):
+    def __init__(self, name, params, body):
+        self.name = name
+        self.params = params
+        self.body = body
+
+class ClassDef(ASTNode):
+    def __init__(self, name, body):
+        self.name = name
+        self.body = body
+
+class Constructor(ASTNode):
+    def __init__(self, params, body):
+        self.params = params
+        self.body = body
+
+class IfStmt(ASTNode):
+    def __init__(self, cond, then_body, else_body=None):
+        self.cond = cond
+        self.then_body = then_body
+        self.else_body = else_body
+
+class ForStmt(ASTNode):
+    def __init__(self, var, iterable, body):
+        self.var = var
+        self.iterable = iterable
+        self.body = body
+
+class WhileStmt(ASTNode):
+    def __init__(self, cond, body):
+        self.cond = cond
+        self.body = body
+
+class Assign(ASTNode):
+    def __init__(self, target, value):
+        self.target = target
+        self.value = value
+
+class MemberAssign(ASTNode):
+    def __init__(self, obj, attr, value):
+        self.obj = obj
+        self.attr = attr
+        self.value = value
+
+class MemberAccess(ASTNode):
+    def __init__(self, obj, attr):
+        self.obj = obj
+        self.attr = attr
+
+class ExprStmt(ASTNode):
+    def __init__(self, expr):
+        self.expr = expr
+
+class Return(ASTNode):
+    def __init__(self, value):
+        self.value = value
+
+class BinOp(ASTNode):
+    def __init__(self, op, left, right):
+        self.op = op
+        self.left = left
+        self.right = right
+
+class Number(ASTNode):
+    def __init__(self, value):
+        self.value = value
+
+class String(ASTNode):
+    def __init__(self, value):
+        self.value = value
+
+class Var(ASTNode):
+    def __init__(self, name):
+        self.name = name
+
+class This(ASTNode):
+    pass
+
+class Range(ASTNode):
+    def __init__(self, start, end):
+        self.start = start
+        self.end = end
+
+class Call(ASTNode):
+    def __init__(self, func, args):
+        self.func = func
+        self.args = args

the_pyro_lang-0.1.4/pyro/cli.py

@@ -0,0 +1,48 @@
+import argparse
+import sys
+import subprocess
+from pathlib import Path
+from .compiler import compile_file
+
+def main():
+    parser = argparse.ArgumentParser(description="Pyro compiler")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    compile_parser = subparsers.add_parser("compile", help="Compile .pyro to .py")
+    compile_parser.add_argument("input", help=".pyro source file")
+    compile_parser.add_argument("-o", "--output", help="output .py file")
+
+    run_parser = subparsers.add_parser("run", help="Compile and run")
+    run_parser.add_argument("input", help=".pyro source file")
+
+    args = parser.parse_args()
+
+    if args.command == "compile":
+        input_path = Path(args.input)
+        if not input_path.exists():
+            print(f"Error: file {input_path} not found", file=sys.stderr)
+            sys.exit(1)
+        output_path = args.output if args.output else input_path.with_suffix(".py")
+        try:
+            compile_file(input_path, output_path)
+            print(f"Compiled {input_path} -> {output_path}")
+        except SyntaxError as e:
+            print(f"SyntaxError: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    elif args.command == "run":
+        input_path = Path(args.input)
+        if not input_path.exists():
+            print(f"Error: file {input_path} not found", file=sys.stderr)
+            sys.exit(1)
+        try:
+            py_code = compile_file(input_path, None)
+            # Execute with a shared namespace so recursive functions work
+            exec_globals = {"__builtins__": __builtins__}
+            exec(py_code, exec_globals)
+        except SyntaxError as e:
+            print(f"SyntaxError: {e}", file=sys.stderr)
+            sys.exit(1)
+
+if __name__ == "__main__":
+    main()

the_pyro_lang-0.1.4/pyro/compiler.py

@@ -0,0 +1,27 @@
+from .lexer import tokenize
+from .parser import Parser, ParserError
+from .transformer import PyTransformer
+
+def compile_pyro(source):
+    try:
+        tokens = tokenize(source)
+        parser = Parser(tokens)
+        ast = parser.parse()
+        transformer = PyTransformer()
+        py_code = transformer.transform(ast)
+        return py_code
+    except ParserError as e:
+        # Already has suggestions embedded
+        raise e
+    except Exception as e:
+        # Wrap unexpected errors
+        raise SyntaxError(f"Compilation error: {str(e)}") from e
+
+def compile_file(input_path, output_path=None):
+    with open(input_path, 'r', encoding='utf-8') as f:
+        source = f.read()
+    py_code = compile_pyro(source)
+    if output_path:
+        with open(output_path, 'w', encoding='utf-8') as f:
+            f.write(py_code)
+    return py_code

the_pyro_lang-0.1.4/pyro/error_utils.py

@@ -0,0 +1,21 @@
+def suggest_fixes(error_msg, source_line=None):
+    """Suggest probable fixes based on error message and source line."""
+    suggestions = []
+    if "end" in error_msg.lower() and "expected" in error_msg.lower():
+        suggestions.append("Missing 'end' keyword – add 'end' after the block.")
+    if "indent" in error_msg.lower():
+        suggestions.append("Indentation error: Use spaces, not tabs. Each level = 4 spaces.")
+    if "unexpected token" in error_msg.lower() and source_line:
+        if "end" in source_line:
+            suggestions.append("Redundant 'end' – remove the extra 'end'.")
+        if "else" in source_line:
+            suggestions.append("'else' must be at the same indentation level as 'if'.")
+    if "NameError" in error_msg or "not defined" in error_msg:
+        suggestions.append("Variable/function used before definition. Check spelling and order.")
+    if "constructor" in error_msg.lower():
+        suggestions.append("'constructor' can only be used inside a 'class' block.")
+    if source_line and ".." in source_line:
+        suggestions.append("Range '..' works only with numbers: e.g., '1..5'.")
+    if not suggestions:
+        suggestions.append("Check parentheses, quotes, and block termination ('end').")
+    return suggestions

the_pyro_lang-0.1.4/pyro/lexer.py

@@ -0,0 +1,75 @@
+import re
+
+KEYWORDS = {
+    'func', 'class', 'if', 'else', 'elif', 'for', 'while', 'return',
+    'constructor', 'and', 'or', 'not', 'True', 'False',
+    'None', 'import', 'from', 'as', 'try', 'except', 'finally',
+    'raise', 'with', 'yield', 'end', 'make', 'print', 'in'
+}
+
+# Multi-char operators must come before single-char to avoid greedy mismatches
+TOKEN_REGEX = re.compile(
+    r'#[^\n]*|'                           # comments
+    r'"[^"\\]*(\\.[^"\\]*)*"|'            # double-quoted strings
+    r"'[^'\\]*(\\.[^'\\]*)*'|"            # single-quoted strings
+    r'\d+\.\d+|'                          # float literals
+    r'\d+|'                               # integer literals
+    r'\.\.|'                              # range operator
+    r'[a-zA-Z_][a-zA-Z0-9_]*|'           # identifiers/keywords
+    r'==|!=|<=|>=|\*\*|//|'               # multi-char operators (must be before single-char)
+    r'[+\-*/%=<>]|'                       # single-char operators
+    r'[(){}[\],;.:]|'                     # punctuation
+    r'\n|'                                # newlines
+    r'\S'                                 # catch-all
+)
+
+
+def tokenize(source):
+    tokens = []
+    line = 1
+    col = 1
+    for match in TOKEN_REGEX.finditer(source):
+        tok = match.group()
+        start_line = line
+        start_col = col
+        # Update line/col for newlines
+        if tok == '\n':
+            line += 1
+            col = 1
+            continue
+        # Skip comments
+        if tok.startswith('#'):
+            col += len(tok)
+            continue
+        # Classify token
+        if tok == 'this':
+            typ = 'THIS'
+        elif tok in ('and', 'or', 'not'):
+            typ = 'OPERATOR'
+        elif tok in ('True', 'False', 'None'):
+            typ = 'KEYWORD'
+        elif tok in KEYWORDS:
+            typ = 'KEYWORD'
+        elif re.fullmatch(r'\d+\.\d+', tok):
+            typ = 'FLOAT'
+            tok = float(tok)
+        elif tok.isdigit() or re.fullmatch(r'\d+', tok):
+            typ = 'NUMBER'
+            tok = int(tok)
+        elif tok == '..':
+            typ = 'RANGE'
+        elif tok in ('+', '-', '*', '/', '%', '=', '==', '!=', '<', '>', '<=', '>=',
+                     '//', '**', '@'):
+            typ = 'OPERATOR'
+        elif tok in '(){}[],;.:':
+            typ = 'PUNCT'
+        elif tok.isidentifier():
+            typ = 'IDENT'
+        elif tok.startswith('"') or tok.startswith("'"):
+            typ = 'STRING'
+            tok = eval(tok)  # safe for simple string literals
+        else:
+            typ = 'UNKNOWN'
+        tokens.append((typ, tok, start_line, start_col))
+        col += len(match.group())
+    return tokens