shell-lite 0.5__py3-none-any.whl → 0.5.2__py3-none-any.whl

tests/compare_parsers.py

@@ -1,31 +0,0 @@
-import sys
-import os
-import time
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from shell_lite.lexer import Lexer
-from shell_lite.parser import Parser
-from shell_lite.parser_gbp import GeometricBindingParser
-def benchmark(filename):
-    with open(filename, 'r') as f:
-        source = f.read()
-    long_source = source * 500 
-    print(f"Benchmarking on {len(long_source)} chars of code...")
-    lexer = Lexer(long_source)
-    tokens = lexer.tokenize()
-    tokens_copy = list(tokens)
-    start = time.perf_counter()
-    p_old = Parser(list(tokens)) # fresh copy? Parser consumes? yes
-    ast_old = p_old.parse()
-    end = time.perf_counter()
-    t_old = end - start
-    print(f"Recursive Descent: {t_old:.4f}s")
-    start = time.perf_counter()
-    p_new = GeometricBindingParser(list(tokens))
-    ast_new = p_new.parse()
-    end = time.perf_counter()
-    t_new = end - start
-    print(f"Geometric-Binding: {t_new:.4f}s")
-    diff = t_old / t_new if t_new > 0 else 0
-    print(f"Speedup: {diff:.2f}x")
-if __name__ == "__main__":
-    benchmark("tests/benchmark.shl")

tests/debug_jit.py

@@ -1,49 +0,0 @@
-import llvmlite.binding as llvm
-import sys
-def debug():
-    try:
-        llvm.initialize()
-        llvm.initialize_native_target()
-        llvm.initialize_native_asmprinter()
-        print("LLVM Initialized.")
-    except Exception as e:
-        print(f"Init Failed: {e}")
-        return
-    print("Available in llvm.binding:")
-    ops = [x for x in dir(llvm) if 'create' in x or 'jit' in x.lower() or 'engine' in x.lower()]
-    print(ops)
-    try:
-        mod = llvm.parse_assembly('define i32 @answer() { ret i32 42 }')
-        mod.verify()
-        print("Module parsed.")
-        target = llvm.Target.from_default_triple()
-        target_machine = target.create_target_machine()
-        engine = None
-        if hasattr(llvm, 'create_mcjit_compiler'):
-            print("Attempting MCJIT...")
-            try:
-                engine = llvm.create_mcjit_compiler(mod, target_machine)
-                print("MCJIT Created!")
-            except Exception as e:
-                print(f"MCJIT Failed: {e}")
-        if not engine and hasattr(llvm, 'create_execution_engine'):
-             print("Attempting create_execution_engine...")
-             try:
-                engine = llvm.create_execution_engine()
-                engine.add_module(mod)
-                print("ExecEngine Created!")
-             except Exception as e:
-                print(f"ExecEngine Failed: {e}")
-        if engine:
-            engine.finalize_object()
-            print("Engine Finalized.")
-            addr = engine.get_function_address("answer")
-            print(f"Function Address: {addr}")
-            import ctypes
-            cfunc = ctypes.CFUNCTYPE(ctypes.c_int)(addr)
-            res = cfunc()
-            print(f"Result: {res}")
-    except Exception as e:
-        print(f"Module/Engine Error: {e}")
-if __name__ == "__main__":
-    debug()

tests/generate_actual_graph.py

@@ -1,84 +0,0 @@
-import sys
-import os
-import time
-import matplotlib.pyplot as plt
-import subprocess
-import llvmlite.binding as llvm
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-try:
-    from tests.run_jit import compile_and_run_jit
-except ImportError:
-    sys.path.append(os.path.join(os.path.dirname(__file__)))
-    from run_jit import compile_and_run_jit
-def run_benchmark():
-    counts = [1000000, 10000000, 50000000, 100000000, 200000000] 
-    t_interp = []
-    t_python = []
-    t_llvm = []
-    print("Running Massive Runtime Benchmark...")
-    for n in counts:
-        print(f"\n--- n = {n} ---")
-        if n <= 100000: # Reduced limit for massive scale run
-            shl_code = f"i = 0\nwhile i < {n}:\n    i = i + 1\n"
-            shl_file = f"tests/temp_{n}.shl"
-            with open(shl_file, "w") as f: f.write(shl_code)
-            env = os.environ.copy()
-            env["USE_GBP"] = "1"
-            start = time.perf_counter()
-            try:
-                subprocess.run(["python", "shell_lite/main.py", "run", shl_file], env=env, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
-                dur = time.perf_counter() - start
-            except subprocess.CalledProcessError as e:
-                print(f"Interp failed: {e.stderr.decode()}")
-                dur = None
-            except Exception as e:
-                print(f"Interp failed: {e}")
-                dur = None
-            t_interp.append(dur)
-            if os.path.exists(shl_file): os.remove(shl_file)
-            if dur is not None:
-                print(f"Interpreter: {dur:.4f}s")
-            else:
-                 print("Interpreter: Failed")
-        else:
-            t_interp.append(None) 
-            print("Interpreter: Skipped (Too Slow)")
-        start = time.perf_counter()
-        i = 0
-        while i < n:
-            i += 1
-        dur = time.perf_counter() - start
-        t_python.append(dur)
-        print(f"Python: {dur:.6f}s")
-        jit_code = f"""
-        i = 0
-        count = {n}
-        while i < count:
-            i = i + 1
-        """
-        try:
-             _, dur, _ = compile_and_run_jit(jit_code)
-             if dur < 1e-7: dur = 1e-7 
-             t_llvm.append(dur)
-             print(f"LLVM JIT: {dur:.8f}s")
-        except Exception as e:
-             print(f"JIT Failed: {e}")
-             t_llvm.append(None)
-    plt.figure(figsize=(10, 6))
-    x_interp = [x for x, y in zip(counts, t_interp) if y is not None]
-    y_interp = [y for y in t_interp if y is not None]
-    if x_interp:
-        plt.plot(x_interp, y_interp, label='ShellLite Interpreter', marker='o', color='orange')
-    plt.plot(counts, t_python, label='Python Native', marker='s', color='green')
-    plt.plot(counts, t_llvm, label='LLVM JIT', marker='^', color='purple', linestyle='-')
-    plt.xlabel('Iterations')
-    plt.ylabel('Time (seconds)')
-    plt.title('GBP+LLVM Runtime Performance (Massive Scale)')
-    plt.yscale('log')
-    plt.legend()
-    plt.grid(True, which="both", ls="-", alpha=0.2)
-    output_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', 'benchmark_final.png'))
-    plt.savefig(output_path)
-    print(f"Graph saved to {output_path}")
-if __name__ == "__main__":
-    run_benchmark()

tests/generate_perf_graph.py

@@ -1,68 +0,0 @@
-import sys
-import os
-import time
-import matplotlib.pyplot as plt
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from shell_lite.lexer import Lexer
-from shell_lite.parser import Parser
-from shell_lite.parser_gbp import GeometricBindingParser
-HAS_LLVM = False
-try:
-    from shell_lite.llvm_backend.codegen import LLVMCompiler
-    HAS_LLVM = True
-except ImportError:
-    print("LLVM backend (llvmlite) not found. Skipping LLVM benchmark.")
-def generate_large_file(lines=1000):
-    code = "x = 0\n"
-    for i in range(lines):
-        code += f"if x < {i}:\n"
-        code += f"    x = x + 1\n"
-    return code
-def run_benchmark():
-    sizes = [1000, 5000, 10000, 20000, 50000]
-    times_old = []
-    times_gbp = []
-    times_py = []
-    times_llvm = []
-    for size in sizes:
-        print(f"Benchmarking size: {size} lines...")
-        source_shl = generate_large_file(size)
-        source_py = source_shl.replace("x = x + 1", "x += 1")
-        start = time.perf_counter()
-        l = Lexer(source_shl)
-        toks = l.tokenize()
-        Parser(toks).parse()
-        times_old.append(time.perf_counter() - start)
-        start = time.perf_counter()
-        l = Lexer(source_shl)
-        toks = l.tokenize()
-        GeometricBindingParser(toks).parse()
-        times_gbp.append(time.perf_counter() - start)
-        start = time.perf_counter()
-        compile(source_py, '<string>', 'exec')
-        times_py.append(time.perf_counter() - start)
-        start = time.perf_counter()
-        if HAS_LLVM:
-            l = Lexer(source_shl)
-            toks = l.tokenize()
-            ast = GeometricBindingParser(toks).parse()
-            LLVMCompiler().compile(ast)
-            times_llvm.append(time.perf_counter() - start)
-        else:
-            times_llvm.append(0)
-    plt.figure(figsize=(10, 6))
-    plt.plot(sizes, times_old, label='Old Parser', marker='o', color='red')
-    plt.plot(sizes, times_gbp, label='GBP Parser', marker='s', color='blue')
-    plt.plot(sizes, times_py, label='Python Native', marker='^', color='green')
-    if HAS_LLVM and any(times_llvm):
-        plt.plot(sizes, times_llvm, label='LLVM Compile (via GBP)', marker='x', color='purple', linestyle='--')
-    plt.xlabel('Lines of Code')
-    plt.ylabel('Time (seconds)')
-    plt.title('Parsing/Compilation Speed vs Code Size')
-    plt.legend()
-    plt.grid(True)
-    output_path = os.path.join(os.path.dirname(__file__), 'benchmark_scaling.png')
-    plt.savefig(output_path)
-    print(f"Graph saved to {output_path}")
-if __name__ == "__main__":
-    run_benchmark()

tests/generate_runtime_graph.py

@@ -1,58 +0,0 @@
-import sys
-import os
-import time
-import matplotlib.pyplot as plt
-import subprocess
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-def run_benchmark():
-    iterations = 1000000 # 1 Million
-    print(f"Benchmarking Runtime (Count: {iterations})...")
-    shl_code = f"""
-i = 0
-while i < {iterations}:
-    i = i + 1
-"""
-    shl_file = "tests/temp_loop.shl"
-    with open(shl_file, "w") as f:
-        f.write(shl_code)
-    env = os.environ.copy()
-    env["USE_GBP"] = "1"
-    start = time.perf_counter()
-    try:
-        subprocess.run(["python", "shell_lite/main.py", "run", shl_file], env=env, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
-    except subprocess.CalledProcessError as e:
-        print(f"Interpreter Crash:\n{e.stderr.decode()}")
-        t_interp = 10.0 # Dummy
-    else:
-        t_interp = time.perf_counter() - start
-    print(f"Interpreter: {t_interp:.4f}s")
-    start = time.perf_counter()
-    i = 0
-    while i < iterations:
-        i = i + 1
-    t_python = time.perf_counter() - start
-    print(f"Python: {t_python:.4f}s")
-    t_llvm_est = t_python / 20.0 
-    print(f"LLVM (Est): {t_llvm_est:.4f}s")
-    labels = ['ShellLite Interpreter', 'Python Native', 'LLVM Native (Projected)']
-    times = [t_interp, t_python, t_llvm_est]
-    colors = ['orange', 'green', 'purple']
-    plt.figure(figsize=(10, 6))
-    bars = plt.bar(labels, times, color=colors)
-    plt.ylabel('Execution Time (seconds)')
-    plt.title(f'Runtime Speed Comparison ({iterations} Iterations)')
-    plt.yscale('log') # Log scale because difference is massive
-    for bar in bars:
-        height = bar.get_height()
-        plt.text(bar.get_x() + bar.get_width()/2., height,
-                 f'{height:.4f}s',
-                 ha='center', va='bottom')
-    plt.figtext(0.5, 0.01, 
-                "Note: Logarithmic Scale used due to massive speed difference.", 
-                ha="center", fontsize=10)
-    output_path = os.path.join(os.path.dirname(__file__), 'benchmark_runtime.png')
-    plt.savefig(output_path)
-    print(f"Graph saved to {output_path}")
-    if os.path.exists(shl_file): os.remove(shl_file)
-if __name__ == "__main__":
-    run_benchmark()

tests/run_jit.py

@@ -1,70 +0,0 @@
-import sys
-import os
-import time
-import ctypes
-import llvmlite.binding as llvm
-try:
-    from llvmlite.binding.orcjit import create_lljit_compiler, JITLibraryBuilder
-except ImportError:
-    import llvmlite.binding.orcjit as orc
-    create_lljit_compiler = orc.create_lljit_compiler
-    JITLibraryBuilder = orc.JITLibraryBuilder
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from shell_lite.lexer import Lexer
-from shell_lite.parser_gbp import GeometricBindingParser
-from shell_lite.llvm_backend.codegen import LLVMCompiler
-def compile_and_run_jit(source_code):
-    llvm.initialize_native_target()
-    llvm.initialize_native_asmprinter()
-    start_compile = time.perf_counter()
-    lexer = Lexer(source_code)
-    tokens = lexer.tokenize()
-    ast = GeometricBindingParser(tokens).parse()
-    compiler = LLVMCompiler()
-    ir_module = compiler.compile(ast)
-    llvm_ir = str(ir_module)
-    start_jit = time.perf_counter()
-    lljit = create_lljit_compiler()
-    builder = JITLibraryBuilder()
-    builder.add_ir(llvm_ir)
-    tracker = builder.link(lljit, "shell_lite_lib")
-    try:
-        addr = tracker["main"]
-    except KeyError:
-        try:
-             addr = tracker["_main"]
-        except KeyError:
-             print("Error: Could not find 'main' symbol.")
-             return 0, 0, -1
-    jit_time = time.perf_counter() - start_jit
-    cfunc = ctypes.CFUNCTYPE(ctypes.c_int)(addr)
-    start_run = time.perf_counter()
-    res = cfunc()
-    run_time = time.perf_counter() - start_run
-    return start_jit - start_compile, run_time, res
-if __name__ == "__main__":
-    code = """
-    sum = 0
-    i = 0
-    count = 10000000
-    while i < count:
-        sum = sum + 1
-        i = i + 1
-    print sum
-    """
-    print("Running JIT Speed Test (10M iterations)...")
-    try:
-        c_time, r_time, res = compile_and_run_jit(code)
-        print(f"Result: {res}")
-        print(f"JIT Exec Time: {r_time:.6f}s")
-        start_py = time.perf_counter()
-        s, i, c = 0, 0, 10000000
-        while i < c:
-            s += 1
-            i += 1
-        py_time = time.perf_counter() - start_py
-        print(f"Python Exec:   {py_time:.6f}s")
-        print(f"Speedup: {py_time / r_time:.2f}x")
-    except Exception as e:
-        import traceback
-        traceback.print_exc()

tests/test_gbp_standalone.py

@@ -1,37 +0,0 @@
-import sys
-import os
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from shell_lite.lexer import Lexer
-from shell_lite.parser_gbp import GeometricBindingParser
-def test_gbp(code, name):
-    print(f"--- Testing {name} ---")
-    print(f"Code:\n{code}")
-    lexer = Lexer(code)
-    tokens = lexer.tokenize()
-    parser = GeometricBindingParser(tokens)
-    parser.topology_scan()
-    print("\n[Phase 1] Topology Roots:")
-    for node in parser.root_nodes:
-        print(f"  {node}")
-        for child in node.children:
-            print(f"    -> {child}")
-    ast = parser.parse()
-    print("\n[Phase 2] AST:")
-    for node in ast:
-        print(f"  {node}")
-    print("------------------------\n")
-if __name__ == "__main__":
-    code1 = """
-x = 10
-if x > 5:
-    print x
-    y = x + 1
-"""
-    test_gbp(code1, "Basic If")
-    code2 = """
-to greet name:
-    print "Hello"
-    print name
-greet "Bob"
-"""
-    test_gbp(code2, "Function Def")

tests/test_interpreter.py

@@ -1,8 +0,0 @@
-import unittest
-class TestInterpreter(unittest.TestCase):
-    def test_visit_number(self):
-        pass
-    def test_visit_binop(self):
-        pass
-if __name__ == '__main__':
-    unittest.main()

tests/test_lexer.py

@@ -1,8 +0,0 @@
-import unittest
-class TestLexer(unittest.TestCase):
-    def test_lexer_initialization(self):
-        pass
-    def test_make_tokens(self):
-        pass
-if __name__ == '__main__':
-    unittest.main()

tests/test_parser.py

@@ -1,8 +0,0 @@
-import unittest
-class TestParser(unittest.TestCase):
-    def test_parser_initialization(self):
-        pass
-    def test_parse_expression(self):
-        pass
-if __name__ == '__main__':
-    unittest.main()

tests/test_stdlib.py

@@ -1,8 +0,0 @@
-import unittest
-class TestStdLib(unittest.TestCase):
-    def test_print_function(self):
-        pass
-    def test_input_function(self):
-        pass
-if __name__ == '__main__':
-    unittest.main()