epy-lang 1.0.0__tar.gz

epy_lang-1.0.0/LICENSE

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

epy_lang-1.0.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: epy-lang
+Version: 1.0.0
+Summary: The English-to-AST Python Language Compiler
+Author: skwasimin
+License: MIT License
+        
+        Copyright (c) 2026 Sk Wasim
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/skwasimin/epy
+Project-URL: Repository, https://github.com/skwasimin/epy
+Project-URL: Issues, https://github.com/skwasimin/epy/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# EPY: The English-to-AST Python Language
+
+[![CI](https://github.com/skwasimin/epy/actions/workflows/run.yml/badge.svg)](https://github.com/skwasimin/epy/actions/workflows/run.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python: 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+
+EPY is an enterprise-ready, plain-English programming syntax that compiles directly into Python's native Abstract Syntax Tree (AST). 
+
+It removes whitespace-sensitive indent traps and esoteric operator boilerplate, delivering 100% compliant, readable Python code with zero runtime overhead.
+
+```epy
+define class MicroServer:
+    define method init with port:
+        set self's port to port
+    end method
+
+    define async function start:
+        show "Server bound to port " + convert self's port to text
+        while true:
+            await handle_traffic()
+        end while
+    end function
+end class
+```
+
+## Quickstart
+
+**Local Installation:**
+```bash
+git clone https://github.com/skwasimin/epy.git
+cd epy
+pip install -e .
+```
+
+Compile an `.epy` file into a `.py` file:
+```bash
+epy app.epy
+```
+
+Compile and run immediately:
+```bash
+epy app.epy --run
+```
+
+## Language Reference
+See [SYNTAX.md](SYNTAX.md) for full grammatical rules and examples.
+
+## Contributing
+See [CONTRIBUTING.md](CONTRIBUTING.md) and [ARCHITECTURE.md](ARCHITECTURE.md) for code submission guidelines.
+
+## License
+MIT License.

epy_lang-1.0.0/README.md

@@ -0,0 +1,52 @@
+# EPY: The English-to-AST Python Language
+
+[![CI](https://github.com/skwasimin/epy/actions/workflows/run.yml/badge.svg)](https://github.com/skwasimin/epy/actions/workflows/run.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python: 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+
+EPY is an enterprise-ready, plain-English programming syntax that compiles directly into Python's native Abstract Syntax Tree (AST). 
+
+It removes whitespace-sensitive indent traps and esoteric operator boilerplate, delivering 100% compliant, readable Python code with zero runtime overhead.
+
+```epy
+define class MicroServer:
+    define method init with port:
+        set self's port to port
+    end method
+
+    define async function start:
+        show "Server bound to port " + convert self's port to text
+        while true:
+            await handle_traffic()
+        end while
+    end function
+end class
+```
+
+## Quickstart
+
+**Local Installation:**
+```bash
+git clone https://github.com/skwasimin/epy.git
+cd epy
+pip install -e .
+```
+
+Compile an `.epy` file into a `.py` file:
+```bash
+epy app.epy
+```
+
+Compile and run immediately:
+```bash
+epy app.epy --run
+```
+
+## Language Reference
+See [SYNTAX.md](SYNTAX.md) for full grammatical rules and examples.
+
+## Contributing
+See [CONTRIBUTING.md](CONTRIBUTING.md) and [ARCHITECTURE.md](ARCHITECTURE.md) for code submission guidelines.
+
+## License
+MIT License.

epy_lang-1.0.0/epy_lang.egg-info/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: epy-lang
+Version: 1.0.0
+Summary: The English-to-AST Python Language Compiler
+Author: skwasimin
+License: MIT License
+        
+        Copyright (c) 2026 Sk Wasim
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/skwasimin/epy
+Project-URL: Repository, https://github.com/skwasimin/epy
+Project-URL: Issues, https://github.com/skwasimin/epy/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# EPY: The English-to-AST Python Language
+
+[![CI](https://github.com/skwasimin/epy/actions/workflows/run.yml/badge.svg)](https://github.com/skwasimin/epy/actions/workflows/run.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python: 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+
+EPY is an enterprise-ready, plain-English programming syntax that compiles directly into Python's native Abstract Syntax Tree (AST). 
+
+It removes whitespace-sensitive indent traps and esoteric operator boilerplate, delivering 100% compliant, readable Python code with zero runtime overhead.
+
+```epy
+define class MicroServer:
+    define method init with port:
+        set self's port to port
+    end method
+
+    define async function start:
+        show "Server bound to port " + convert self's port to text
+        while true:
+            await handle_traffic()
+        end while
+    end function
+end class
+```
+
+## Quickstart
+
+**Local Installation:**
+```bash
+git clone https://github.com/skwasimin/epy.git
+cd epy
+pip install -e .
+```
+
+Compile an `.epy` file into a `.py` file:
+```bash
+epy app.epy
+```
+
+Compile and run immediately:
+```bash
+epy app.epy --run
+```
+
+## Language Reference
+See [SYNTAX.md](SYNTAX.md) for full grammatical rules and examples.
+
+## Contributing
+See [CONTRIBUTING.md](CONTRIBUTING.md) and [ARCHITECTURE.md](ARCHITECTURE.md) for code submission guidelines.
+
+## License
+MIT License.

epy_lang-1.0.0/epy_lang.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+transpiler.py
+epy_lang.egg-info/PKG-INFO
+epy_lang.egg-info/SOURCES.txt
+epy_lang.egg-info/dependency_links.txt
+epy_lang.egg-info/entry_points.txt
+epy_lang.egg-info/top_level.txt

epy_lang-1.0.0/epy_lang.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

epy_lang-1.0.0/epy_lang.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+epy = transpiler:main

epy_lang-1.0.0/epy_lang.egg-info/top_level.txt

@@ -0,0 +1 @@
+transpiler

epy_lang-1.0.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "epy-lang"
+version = "1.0.0"
+description = "The English-to-AST Python Language Compiler"
+readme = "README.md"
+authors = [{ name = "skwasimin" }]
+license = { file = "LICENSE" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Compilers"
+]
+requires-python = ">=3.9"
+
+[project.scripts]
+epy = "transpiler:main"
+
+[project.urls]
+Homepage = "https://github.com/skwasimin/epy"
+Repository = "https://github.com/skwasimin/epy"
+Issues = "https://github.com/skwasimin/epy/issues"
+
+[tool.setuptools]
+py-modules = ["transpiler"]
+

epy_lang-1.0.0/setup.cfg

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

epy_lang-1.0.0/transpiler.py

@@ -0,0 +1,330 @@
+#!/usr/bin/env python3
+import ast
+import re
+import sys
+import subprocess
+from pathlib import Path
+
+class EpySyntaxError(Exception): pass
+
+QUOTE_RE = re.compile(r'("[^"]*"|\'[^\']*\')')
+
+def mask_quotes(line: str):
+    quotes = []
+    def _stash(m):
+        quotes.append(m.group(0))
+        return f"__Q{len(quotes) - 1}__"
+    return QUOTE_RE.sub(_stash, line), quotes
+
+def unmask_quotes(line: str, quotes: list):
+    for i, q in enumerate(quotes):
+        line = line.replace(f"__Q{i}__", q)
+    return line
+
+PHRASE_REPLACEMENTS = [
+    (r"\blength of (\w+)\b", r"len(\1)"),
+    (r"\buppercase of (\w+)\b", r"\1.upper()"),
+    (r"\blowercase of (\w+)\b", r"\1.lower()"),
+    (r"\bitem at index (\w+) in (\w+)\b", r"\2[\1]"),
+    (r"\bvalue of (\w+) in (\w+)\b", r'\2["\1"]'),
+    (r"\bconvert (\w+) to text\b", r"str(\1)"),
+    (r"\bconvert (\w+) to a number\b", r"float(\1)"),
+    (r"\bthe error\b", "e"),
+    (r"\bthe remainder of (.+?) divided by (.+?)\b", r"(\1 % \2)"),
+    (r"\b(.+?) to the power of (.+?)\b", r"(\1 ** \2)"),
+    (r"\b(.+?) divided by (.+?) rounding down\b", r"(\1 // \2)"),
+    (r"\b(.+?) divided by (.+?)\b", r"(\1 / \2)"),
+    (r"\bthe sum of (\w+)\b", r"sum(\1)"),
+    (r"\bthe maximum of (\w+)\b", r"max(\1)"),
+    (r"\bthe minimum of (\w+)\b", r"min(\1)"),
+    (r"\bthe average of (\w+)\b", r"(sum(\1) / len(\1))"),
+    (r"\bthe type of (\w+)\b", r"type(\1)"),
+    (r"\bround (\w+) to (\w+) decimal places\b", r"round(\1, \2)"),
+    (r"\bround (\w+)\b", r"round(\1)"),
+    (r"\bis not equal to\b", "!="),
+    (r"\bis equal to\b", "=="),
+    (r"\bis greater than or equal to\b", ">="),
+    (r"\bis less than or equal to\b", "<="),
+    (r"\bis at least\b", ">="),
+    (r"\bis at most\b", "<="),
+    (r"\bis greater than\b", ">"),
+    (r"\bis less than\b", "<"),
+    (r"\bis not in\b", "not in"),
+    (r"\bis in\b", "in"),
+    (r"\btrue\b", "True"),
+    (r"\bfalse\b", "False"),
+    (r"\bnothing\b", "None"),
+    (r"(\w+)'s (\w+)", r"\1.\2")
+]
+
+def translate_expr(expr: str) -> str:
+    masked, quotes = mask_quotes(expr)
+    for pattern, repl in PHRASE_REPLACEMENTS:
+        masked = re.sub(pattern, repl, masked, flags=re.IGNORECASE)
+    return unmask_quotes(masked, quotes)
+
+def make_expr_node(expr: str) -> ast.expr:
+    try: return ast.parse(translate_expr(expr.strip()), mode='eval').body
+    except SyntaxError as e: raise EpySyntaxError(f"Cannot parse expression '{expr}': {e}")
+
+def make_stmt_node(stmt: str) -> ast.stmt:
+    try:
+        parsed = ast.parse(translate_expr(stmt.strip()), mode='exec')
+        return parsed.body[0] if parsed.body else ast.Pass()
+    except SyntaxError as e: raise EpySyntaxError(f"Cannot parse statement '{stmt}': {e}")
+
+def parse_dict_pairs(text: str) -> tuple:
+    keys, values = [], []
+    for p in [x.strip() for x in text.split(",") if x.strip()]:
+        m = re.match(r"(\w+) as (.+)", p, re.IGNORECASE)
+        if m:
+            keys.append(ast.Constant(value=m.group(1)))
+            values.append(make_expr_node(m.group(2)))
+        else: raise EpySyntaxError(f"Invalid dict element '{p}'")
+    return keys, values
+
+def build_ast(source_text: str) -> ast.Module:
+    root = ast.Module(body=[], type_ignores=[])
+    stack, block_types, try_stack, if_stack, pending_dec = [root.body], ["module"], [], [], []
+
+    for line_no, raw_line in enumerate(source_text.splitlines(), start=1):
+        line = raw_line.strip()
+        if not line or line.startswith("#"): continue
+
+        try:
+            m_deco = re.match(r"^apply decorator (.+)$", line, re.IGNORECASE)
+            if m_deco: pending_dec.append(make_expr_node(m_deco.group(1))); continue
+
+            m_imp = re.match(r"^use library ([\w\.]+)(?: as (\w+))?$", line, re.IGNORECASE)
+            if m_imp: stack[-1].append(ast.Import(names=[ast.alias(name=m_imp.group(1), asname=m_imp.group(2))])); continue
+
+            m_from = re.match(r"^from library ([\w\.]+) use (.+)$", line, re.IGNORECASE)
+            if m_from:
+                aliases = [ast.alias(name=n.strip(), asname=None) for n in m_from.group(2).split(",") if n.strip()]
+                stack[-1].append(ast.ImportFrom(module=m_from.group(1), names=aliases, level=0))
+                continue
+
+            m_cls = re.match(r"^define class (\w+)(?: based on (\w+))?:$", line, re.IGNORECASE)
+            if m_cls:
+                bases = [ast.Name(id=m_cls.group(2), ctx=ast.Load())] if m_cls.group(2) else []
+                node = ast.ClassDef(name=m_cls.group(1), bases=bases, keywords=[], body=[], decorator_list=pending_dec, type_params=[])
+                pending_dec = []; stack[-1].append(node); stack.append(node.body); block_types.append("class"); continue
+
+            m_func = re.match(r"^define (async function|function|method) (\w+)(?: with (.+))?:$", line, re.IGNORECASE)
+            if m_func:
+                kind, f_name, f_args = m_func.group(1).lower(), m_func.group(2), m_func.group(3) or ""
+                if f_name.lower() == "init": f_name = "__init__"
+                arg_names = [a.strip() for a in f_args.split(",") if a.strip()]
+                if kind == "method": arg_names.insert(0, "self")
+                args_node = ast.arguments(posonlyargs=[], args=[ast.arg(arg=a) for a in arg_names], kwonlyargs=[], kw_defaults=[], defaults=[])
+                node_cls = ast.AsyncFunctionDef if "async" in kind else ast.FunctionDef
+                node = node_cls(name=f_name, args=args_node, body=[], decorator_list=pending_dec, returns=None, type_params=[])
+                pending_dec = []; stack[-1].append(node); stack.append(node.body); block_types.append(kind); continue
+
+            m_if = re.match(r"^if (.+):$", line, re.IGNORECASE)
+            if m_if:
+                node = ast.If(test=make_expr_node(m_if.group(1)), body=[], orelse=[])
+                stack[-1].append(node); stack.append(node.body); block_types.append("if"); if_stack.append(node); continue
+
+            m_elif = re.match(r"^otherwise if (.+):$", line, re.IGNORECASE)
+            if m_elif:
+                node = ast.If(test=make_expr_node(m_elif.group(1)), body=[], orelse=[])
+                if_stack[-1].orelse.append(node); stack.pop(); stack.append(node.body); if_stack[-1] = node; continue
+
+            m_else = re.match(r"^else:$", line, re.IGNORECASE)
+            if m_else: stack.pop(); stack.append(if_stack[-1].orelse); continue
+
+            m_rep = re.match(r"^repeat (.+) times:$", line, re.IGNORECASE)
+            if m_rep:
+                range_call = ast.Call(func=ast.Name(id="range", ctx=ast.Load()), args=[make_expr_node(m_rep.group(1))], keywords=[])
+                node = ast.For(target=ast.Name(id="_", ctx=ast.Store()), iter=range_call, body=[], orelse=[])
+                stack[-1].append(node); stack.append(node.body); block_types.append("repeat"); continue
+
+            m_while = re.match(r"^while (.+):$", line, re.IGNORECASE)
+            if m_while:
+                node = ast.While(test=make_expr_node(m_while.group(1)), body=[], orelse=[])
+                stack[-1].append(node); stack.append(node.body); block_types.append("while"); continue
+
+            m_for = re.match(r"^for each (\w+) in (.+):$", line, re.IGNORECASE)
+            if m_for:
+                node = ast.For(target=ast.Name(id=m_for.group(1), ctx=ast.Store()), iter=make_expr_node(m_for.group(2)), body=[], orelse=[])
+                stack[-1].append(node); stack.append(node.body); block_types.append("for"); continue
+
+            m_file = re.match(r"^open file (.+) for (reading|writing|appending) as (\w+):$", line, re.IGNORECASE)
+            if m_file:
+                mode_map = {"reading": "r", "writing": "w", "appending": "a"}
+                open_call = ast.Call(func=ast.Name(id="open", ctx=ast.Load()), args=[make_expr_node(m_file.group(1)), ast.Constant(value=mode_map[m_file.group(2).lower()])], keywords=[])
+                node = ast.With(items=[ast.withitem(context_expr=open_call, optional_vars=ast.Name(id=m_file.group(3), ctx=ast.Store()))], body=[])
+                stack[-1].append(node); stack.append(node.body); block_types.append("file"); continue
+
+            if re.match(r"^try:$", line, re.IGNORECASE):
+                node = ast.Try(body=[], handlers=[], orelse=[], finalbody=[])
+                stack[-1].append(node); stack.append(node.body); block_types.append("try"); try_stack.append(node); continue
+
+            m_except = re.match(r"^if that fails(?: with (\w+))?:$", line, re.IGNORECASE)
+            if m_except:
+                exc_type = ast.Name(id=m_except.group(1), ctx=ast.Load()) if m_except.group(1) else None
+                handler = ast.ExceptHandler(type=exc_type, name="e", body=[])
+                try_stack[-1].handlers.append(handler); stack.pop(); stack.append(handler.body); block_types[-1] = "except"; continue
+
+            if re.match(r"^finally:$", line, re.IGNORECASE):
+                stack.pop(); stack.append(try_stack[-1].finalbody); block_types[-1] = "finally"; continue
+
+            m_end = re.match(r"^end (if|while|repeat|for|function|async function|method|class|try|file)$", line, re.IGNORECASE)
+            if m_end:
+                expected = m_end.group(1).lower()
+                stack.pop(); current = block_types.pop()
+                if expected == "try" and current in ["except", "finally"]: try_stack.pop()
+                if expected == "if": if_stack.pop()
+                continue
+
+            m_await_store = re.match(r"^await (.+) and store in (\w+)$", line, re.IGNORECASE)
+            if m_await_store:
+                node = ast.Assign(targets=[ast.Name(id=m_await_store.group(2), ctx=ast.Store())], value=ast.Await(value=make_expr_node(m_await_store.group(1))))
+                stack[-1].append(node); continue
+
+            m_await_call = re.match(r"^await (.+)$", line, re.IGNORECASE)
+            if m_await_call:
+                stack[-1].append(ast.Expr(value=ast.Await(value=make_expr_node(m_await_call.group(1))))); continue
+
+            m_yield = re.match(r"^yield (.+)$", line, re.IGNORECASE)
+            if m_yield: stack[-1].append(ast.Expr(value=ast.Yield(value=make_expr_node(m_yield.group(1))))); continue
+
+            m_ret = re.match(r"^return (.+)$", line, re.IGNORECASE)
+            if m_ret: stack[-1].append(ast.Return(value=make_expr_node(m_ret.group(1)))); continue
+
+            if re.match(r"^return$", line, re.IGNORECASE): stack[-1].append(ast.Return(value=None)); continue
+            
+            # --- Modifications & Attributes (RESTORED FIX) ---
+            m_inc = re.match(r"^increase (.+) by (.+)$", line, re.IGNORECASE)
+            if m_inc:
+                node = ast.AugAssign(target=make_expr_node(m_inc.group(1)), op=ast.Add(), value=make_expr_node(m_inc.group(2)))
+                stack[-1].append(node); continue
+
+            m_dec = re.match(r"^decrease (.+) by (.+)$", line, re.IGNORECASE)
+            if m_dec:
+                node = ast.AugAssign(target=make_expr_node(m_dec.group(1)), op=ast.Sub(), value=make_expr_node(m_dec.group(2)))
+                stack[-1].append(node); continue
+
+            m_set_val = re.match(r"^set value of (\w+) in (\w+) to (.+)$", line, re.IGNORECASE)
+            if m_set_val:
+                node = ast.Assign(
+                    targets=[ast.Subscript(value=ast.Name(id=m_set_val.group(2), ctx=ast.Load()), slice=ast.Constant(value=m_set_val.group(1)), ctx=ast.Store())],
+                    value=make_expr_node(m_set_val.group(3))
+                )
+                stack[-1].append(node); continue
+
+            m_set_attr = re.match(r"^set (\w+)'s (\w+) to (.+)$", line, re.IGNORECASE)
+            if m_set_attr:
+                node = ast.Assign(
+                    targets=[ast.Attribute(value=ast.Name(id=m_set_attr.group(1), ctx=ast.Load()), attr=m_set_attr.group(2), ctx=ast.Store())],
+                    value=make_expr_node(m_set_attr.group(3))
+                )
+                stack[-1].append(node); continue
+
+            # --- Collections (RESTORED FIX) ---
+            m_list = re.match(r"^create list (\w+) with (.+)$", line, re.IGNORECASE)
+            if m_list:
+                elts = [make_expr_node(e.strip()) for e in m_list.group(2).split(",") if e.strip()]
+                node = ast.Assign(targets=[ast.Name(id=m_list.group(1), ctx=ast.Store())], value=ast.List(elts=elts, ctx=ast.Load()))
+                stack[-1].append(node); continue
+
+            m_list_empty = re.match(r"^create empty list (\w+)$", line, re.IGNORECASE)
+            if m_list_empty:
+                node = ast.Assign(targets=[ast.Name(id=m_list_empty.group(1), ctx=ast.Store())], value=ast.List(elts=[], ctx=ast.Load()))
+                stack[-1].append(node); continue
+
+            m_dict = re.match(r"^create dictionary (\w+) with (.+)$", line, re.IGNORECASE)
+            if m_dict:
+                keys, vals = parse_dict_pairs(m_dict.group(2))
+                node = ast.Assign(targets=[ast.Name(id=m_dict.group(1), ctx=ast.Store())], value=ast.Dict(keys=keys, values=vals))
+                stack[-1].append(node); continue
+                
+            m_add = re.match(r"^add (.+) to (\w+)$", line, re.IGNORECASE)
+            if m_add:
+                node = ast.Expr(value=ast.Call(func=ast.Attribute(value=ast.Name(id=m_add.group(2), ctx=ast.Load()), attr="append", ctx=ast.Load()), args=[make_expr_node(m_add.group(1))], keywords=[]))
+                stack[-1].append(node); continue
+                
+            m_rem = re.match(r"^remove (.+) from (\w+)$", line, re.IGNORECASE)
+            if m_rem:
+                node = ast.Expr(value=ast.Call(func=ast.Attribute(value=ast.Name(id=m_rem.group(2), ctx=ast.Load()), attr="remove", ctx=ast.Load()), args=[make_expr_node(m_rem.group(1))], keywords=[]))
+                stack[-1].append(node); continue
+                
+            m_sort = re.match(r"^sort (\w+)$", line, re.IGNORECASE)
+            if m_sort:
+                node = ast.Expr(value=ast.Call(func=ast.Attribute(value=ast.Name(id=m_sort.group(1), ctx=ast.Load()), attr="sort", ctx=ast.Load()), args=[], keywords=[]))
+                stack[-1].append(node); continue
+
+            # --- Standard Operations ---
+            m_store_multi = re.match(r"^store (.+) in ((?:\w+\s*,\s*)+\w+)$", line, re.IGNORECASE)
+            if m_store_multi:
+                targets = [ast.Name(id=t.strip(), ctx=ast.Store()) for t in m_store_multi.group(2).split(",")]
+                stack[-1].append(ast.Assign(targets=[ast.Tuple(elts=targets, ctx=ast.Store())], value=make_expr_node(m_store_multi.group(1)))); continue
+
+            m_store = re.match(r"^store (.+) in (\w+)$", line, re.IGNORECASE)
+            if m_store: stack[-1].append(ast.Assign(targets=[ast.Name(id=m_store.group(2), ctx=ast.Store())], value=make_expr_node(m_store.group(1)))); continue
+
+            m_let = re.match(r"^let (\w+) be (.+)$", line, re.IGNORECASE)
+            if m_let: stack[-1].append(ast.Assign(targets=[ast.Name(id=m_let.group(1), ctx=ast.Store())], value=make_expr_node(m_let.group(2)))); continue
+
+            m_new = re.match(r"^create (\w+) as new (\w+)(?: with (.+))?$", line, re.IGNORECASE)
+            if m_new:
+                args = [make_expr_node(a.strip()) for a in m_new.group(3).split(",") if a.strip()] if m_new.group(3) else []
+                node = ast.Assign(targets=[ast.Name(id=m_new.group(1), ctx=ast.Store())], value=ast.Call(func=ast.Name(id=m_new.group(2), ctx=ast.Load()), args=args, keywords=[]))
+                stack[-1].append(node); continue
+
+            m_show = re.match(r"^show (.+)$", line, re.IGNORECASE)
+            if m_show:
+                stack[-1].append(ast.Expr(value=ast.Call(func=ast.Name(id="print", ctx=ast.Load()), args=[make_expr_node(m_show.group(1))], keywords=[]))); continue
+
+            m_meth_store = re.match(r"^call (\w+)'s (\w+)(?: with (.+))? and store in (\w+)$", line, re.IGNORECASE)
+            if m_meth_store:
+                args = [make_expr_node(a.strip()) for a in m_meth_store.group(3).split(",") if a.strip()] if m_meth_store.group(3) else []
+                call = ast.Call(func=ast.Attribute(value=ast.Name(id=m_meth_store.group(1), ctx=ast.Load()), attr=m_meth_store.group(2), ctx=ast.Load()), args=args, keywords=[])
+                stack[-1].append(ast.Assign(targets=[ast.Name(id=m_meth_store.group(4), ctx=ast.Store())], value=call)); continue
+
+            m_meth = re.match(r"^call (\w+)'s (\w+)(?: with (.+))?$", line, re.IGNORECASE)
+            if m_meth:
+                args = [make_expr_node(a.strip()) for a in m_meth.group(3).split(",") if a.strip()] if m_meth.group(3) else []
+                call = ast.Call(func=ast.Attribute(value=ast.Name(id=m_meth.group(1), ctx=ast.Load()), attr=m_meth.group(2), ctx=ast.Load()), args=args, keywords=[])
+                stack[-1].append(ast.Expr(value=call)); continue
+
+            m_fn_store = re.match(r"^call ([\w\.]+)(?: with (.+))? and store in (\w+)$", line, re.IGNORECASE)
+            if m_fn_store:
+                args_code = translate_expr(m_fn_store.group(2) or "")
+                stack[-1].append(ast.Assign(targets=[ast.Name(id=m_fn_store.group(3), ctx=ast.Store())], value=make_expr_node(f"{m_fn_store.group(1)}({args_code})"))); continue
+
+            m_fn = re.match(r"^call ([\w\.]+)(?: with (.+))?$", line, re.IGNORECASE)
+            if m_fn:
+                args_code = translate_expr(m_fn.group(2) or "")
+                stack[-1].append(ast.Expr(value=make_expr_node(f"{m_fn.group(1)}({args_code})"))); continue
+
+            stack[-1].append(make_stmt_node(line))
+
+        except Exception as e: raise EpySyntaxError(f"Error on line {line_no} ('{line}'): {str(e)}")
+
+    if len(stack) > 1: raise EpySyntaxError(f"Unclosed block detected: Missing 'end {block_types[-1]}'.")
+    ast.fix_missing_locations(root)
+    return root
+
+def compile_source(source_text: str) -> str:
+    return ast.unparse(build_ast(source_text))
+
+def main():
+    if len(sys.argv) < 2:
+        print("EPY Compiler v1.0.0\nUsage: epy <file.epy> [--run]")
+        sys.exit(1)
+
+    src_path = Path(sys.argv[1])
+    py_path = src_path.with_suffix(".py")
+    try: py_code = compile_source(src_path.read_text(encoding="utf-8"))
+    except EpySyntaxError as e: print(f"Syntax Error: {e}"); sys.exit(1)
+
+    py_path.write_text(py_code, encoding="utf-8")
+    print(f"Compiled successfully: {src_path} -> {py_path}")
+
+    if "--run" in sys.argv:
+        subprocess.run([sys.executable, str(py_path)])
+
+if __name__ == "__main__": main()
+