Python Compiler Code

Source code for the compiler project.

 #!/usr/bin/env python3
"""
term_compiler.py (Version 7.1 - Final Polished Version)

A terminal-based Python editor for demoscenes. This script provides a
split-screen Curses interface for writing and running Python code, with
special features for creating graphical demoscenes.

- This version fixes a UI issue where the F2 line limit was not displayed
  in the main header and corrects the F3 Math Mode status message.
"""

# =============================================================================
# --- 1. IMPORTS AND GLOBAL CONFIGURATION ---
# =============================================================================
import curses
import tempfile
import subprocess
import os
import sys
import threading
import venv
import ast
import importlib.util
import shutil
from typing import List, Optional, IO, Set, Callable, Tuple

# --- Constants ---
VENV_DIR = ".demo_venv"
PRESET_LIMITS = [12, 40, 300]  # {Lines Limit}

PACKAGE_MAP = {
    "cv2": "opencv-python", "PIL": "Pillow", "skimage": "scikit-image",
    "sklearn": "scikit-learn", "bs4": "beautifulsoup4", "pygame": "pygame",
    "numpy": "numpy", "rich": "rich", "kivy": "kivy", "urwid": "urwid",
    "PySide6": "PySide6", "pyglet": "pyglet", "PyQt5": "PyQt5", "flet": "flet",
    "textual": "textual"
}


# =============================================================================
# --- 2. CORE TEMPLATES ---
# =============================================================================

# {Math Mode} Template for the graphical tkinter canvas.
GRAPHICAL_CANVAS_TEMPLATE = """
import tkinter as tk
import time
import math
import numpy as np
import random

WIDTH, HEIGHT = 400, 300
PIXEL_SIZE = 2
WIN_WIDTH, WIN_HEIGHT = WIDTH * PIXEL_SIZE, HEIGHT * PIXEL_SIZE
t = 0.0

try:
    window = tk.Tk()
    window.title("Math Mode Canvas")
    window.geometry(f"{WIN_WIDTH}x{WIN_HEIGHT}")
    canvas = tk.Canvas(window, width=WIN_WIDTH, height=WIN_HEIGHT, bg="black")
    canvas.pack()
    
    image = tk.PhotoImage(width=WIN_WIDTH, height=WIN_HEIGHT)
    canvas.create_image((0, 0), image=image, anchor="nw")

    def rgb_to_hex(r, g, b):
        return f"#{int(r)&0xff:02x}{int(g)&0xff:02x}{int(b)&0xff:02x}"

    def update_frame():
        global t
        pixel_data = []
        for y in range(HEIGHT):
            row_data = []
            for x in range(WIDTH):
                # --- INJECTED SHADER CODE ---
                __SHADER_CODE_HERE__
                # --- END INJECTED CODE ---
                r, g, b = locals().get('r', 0), locals().get('g', 0), locals().get('b', 0)
                r, g, b = max(0, min(255, r)), max(0, min(255, g)), max(0, min(255, b))
                hex_color = rgb_to_hex(r, g, b)
                row_data.extend([hex_color] * PIXEL_SIZE)
            for _ in range(PIXEL_SIZE):
                pixel_data.append("{" + " ".join(row_data) + "}")
        
        image.put(" ".join(pixel_data))
        t += 0.03
        window.after(16, update_frame)

    window.after(0, update_frame)
    window.mainloop()
except tk.TclError as e:
    print(f"--- GRAPHICS ERROR: Could not initialize canvas. ---")
    print(f"--- Details: {e} ---")
    input("\\nPress Enter to return...")
except Exception as e:
    print(f"\\n--- SHADER ERROR ---\\n{e}")
    try: print(f"Occurred at x={x}, y={y}, t={t}")
    except NameError: print("Error occurred before animation loop.")
    input("\\nPress Enter to return...")
"""


# =============================================================================
# --- 3. GLOBAL STATE MANAGEMENT ---
# =============================================================================
demo_proc: Optional[subprocess.Popen] = None
output_lines: List[str] = ["Welcome! Dependencies will be auto-installed on run."]
VENV_PYTHON = ""


# =============================================================================
# --- 4. VIRTUAL ENVIRONMENT & DEPENDENCY MANAGEMENT ---
# =============================================================================

def setup_venv():
    """Checks for, creates, and validates the Python virtual environment."""
    global VENV_PYTHON
    scripts_dir = "Scripts" if sys.platform == "win32" else "bin"
    VENV_PYTHON = os.path.join(VENV_DIR, scripts_dir, "python")
    try:
        if not os.path.exists(VENV_PYTHON) or subprocess.run([VENV_PYTHON, "--version"], check=True, capture_output=True).returncode != 0:
            raise FileNotFoundError
    except (subprocess.CalledProcessError, FileNotFoundError):
        print(f"--- Creating virtual environment in ./{VENV_DIR} ---")
        shutil.rmtree(VENV_DIR, ignore_errors=True)
        try:
            venv.create(VENV_DIR, with_pip=True)
            subprocess.run([VENV_PYTHON, "-m", "pip", "install", "--upgrade", "pip"], check=True, capture_output=True)
            print("--- Setup complete. ---")
        except Exception as e:
            print(f"\n--- VENV CREATION FAILED: {e} ---")
            VENV_PYTHON = sys.executable
            input("--- Falling back to system Python. Press Enter. ---")

def install_dependencies(lines: List[str], log_func: Callable[[str], None]):
    """Parses code for imports and auto-installs missing packages."""
    # {Automatic Dependency Installation}
    if VENV_PYTHON == sys.executable: return
    try:
        tree = ast.parse("\n".join(lines))
        imports = {node.names[0].name.split('.')[0] for node in ast.walk(tree) if isinstance(node, ast.Import)}
        imports.update({node.module.split('.')[0] for node in ast.walk(tree) if isinstance(node, ast.ImportFrom) and node.module})
    except SyntaxError: return

    if not imports: return
    log_func("--- Checking dependencies... ---")
    result = subprocess.run([VENV_PYTHON, "-m", "pip", "freeze"], capture_output=True, text=True)
    installed = {p.split('==')[0].lower() for p in result.stdout.splitlines()}
    
    for imp in imports:
        spec = importlib.util.find_spec(imp)
        is_std_lib = spec and "site-packages" not in (spec.origin or "") and "dist-packages" not in (spec.origin or "")
        package_name = PACKAGE_MAP.get(imp, imp)
        if not is_std_lib and package_name and package_name.lower() not in installed:
            log_func(f"--- Installing: {package_name} ---")
            try:
                subprocess.run([VENV_PYTHON, "-m", "pip", "install", package_name], check=True, capture_output=True, text=True)
                log_func(f"--- Installed {package_name} successfully. ---")
            except subprocess.CalledProcessError:
                log_func(f"--- FAILED to install {package_name}. ---")


# =============================================================================
# --- 5. PROCESS EXECUTION AND MANAGEMENT ---
# =============================================================================

def stop_running_demo():
    """Safely terminates any running background demo process."""
    global demo_proc
    if demo_proc and demo_proc.poll() is None:
        try:
            demo_proc.terminate()
            demo_proc.wait(timeout=0.5)
        except subprocess.TimeoutExpired:
            demo_proc.kill()
        except Exception: pass
    demo_proc = None

def run_code(lines: List[str], in_background: bool) -> Tuple[bool, str]:
    """Executes user code, either in the background or foreground."""
    global demo_proc
    stop_running_demo()
    install_dependencies(lines, log_func=output_lines.append if in_background else print)
    
    temp_path = ""
    try:
        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False, encoding="utf-8") as tf:
            tf.write("\n".join(lines)); temp_path = tf.name
        
        if in_background:
            # {Background Run}
            output_lines.append("--- LAUNCHING BACKGROUND DEMO ---")
            demo_proc = subprocess.Popen([VENV_PYTHON, temp_path], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, encoding='utf-8')
            def read_output(pipe: IO):
                for line in iter(pipe.readline, ''):
                    if len(output_lines) > 200: output_lines.pop(0)
                    output_lines.append(line.strip())
            threading.Thread(target=read_output, args=(demo_proc.stdout,), daemon=True).start()
        else:
            # {Terminal Run}
            print("--- LAUNCHING DEMO (Close window or press Ctrl+C to stop) ---")
            try:
                subprocess.run([VENV_PYTHON, temp_path], check=False)
            except KeyboardInterrupt:
                print("\n--- DEMO INTERRUPTED BY USER ---")
            
            # {Robust Interrupt Handling}
            print("--- Press Enter to return to the editor ---")
            try:
                input()
            except KeyboardInterrupt:
                print("\n--- Returning to editor. ---")

        return True, "Launched."
    except Exception as e:
        msg = f"--- FAILED TO LAUNCH: {e} ---"
        (output_lines.append if in_background else print)(msg)
        return False, "Launch failed."
    finally:
        if temp_path:
            threading.Timer(1.0, lambda p=temp_path: os.unlink(p) if os.path.exists(p) else None).start()


# =============================================================================
# --- 6. MAIN CURSES EDITOR UI & LOGIC ---
# =============================================================================

def draw_panes(stdscr, state: dict):
    """Draws the entire editor UI."""
    # {UI}
    h, w = stdscr.getmaxyx()
    if h < 5 or w < 20:
        stdscr.addstr(0, 0, "Terminal too small."); return

    editor_w, content_h = w // 2, h - 3
    
    # --- Draw Header --- {FIXED}
    header = "Ctrl+R=BG Run|Ctrl+T=Run|Ctrl+N=Clear|F2=Limit|F3=Math|Ctrl+X=Quit"
    stdscr.addstr(0, 0, header.ljust(w)[:w-1], curses.A_REVERSE)

    # --- Draw Panes ---
    for i in range(content_h):
        y, line_idx = 1 + i, state['scroll'] + i
        line_display = f"{line_idx+1:>3} {state['lines'][line_idx]}" if line_idx < len(state['lines']) else "~"
        stdscr.addstr(y, 0, line_display.ljust(editor_w)[:editor_w-1])
        stdscr.addch(y, editor_w, curses.ACS_VLINE)
        output_idx = len(output_lines) - content_h + i
        if output_idx >= 0 and output_idx < len(output_lines):
            stdscr.addstr(y, editor_w + 1, output_lines[output_idx][:w-editor_w-2])

    # --- Draw Status and Help Bars ---
    mode = " [Math Mode]" if state['math_mode_enabled'] else ""
    code_lines = sum(1 for line in state['lines'] if line.strip())
    status = f"Cursor: {state['cursor'][0]+1}:{state['cursor'][1]+1}|Lines: {code_lines}/{state['limit']}|{state['msg']}{mode}"
    stdscr.addstr(h-2, 0, status.ljust(w)[:w-1], curses.A_REVERSE)
    stdscr.addstr(h-1, 0, "Standard text editing keys: Arrows, Enter, Backspace, Del, Home/End...".ljust(w)[:w-1])

    if state['scroll'] <= state['cursor'][0] < state['scroll'] + content_h:
        cur_y, cur_x = 1 + (state['cursor'][0] - state['scroll']), 4 + state['cursor'][1]
        if cur_x < editor_w: stdscr.move(cur_y, cur_x)

def run_editor(stdscr):
    """The main editor loop: manages state and handles user input."""
    curses.curs_set(1); stdscr.keypad(True); stdscr.timeout(100)
    
    if not hasattr(run_editor, "state"):
        run_editor.state = {"lines": [""], "cursor": [0,0], "scroll": 0, "limit_idx": 1,
                            "limit": PRESET_LIMITS[1], "msg": "Ready.", "math_mode_enabled": False}
    state = run_editor.state
    
    last_out_len, redraw, confirm_clear = -1, True, False

    while True:
        if len(output_lines) != last_out_len:
            redraw, last_out_len = True, len(output_lines)
        if redraw:
            stdscr.erase(); draw_panes(stdscr, state); stdscr.refresh()
            redraw = False
        try: key = stdscr.get_wch()
        except curses.error: continue

        if confirm_clear: # {Clear All Feature}
            state["msg"] = "Code cleared." if isinstance(key, str) and key.lower() == 'y' else "Clear cancelled."
            if state["msg"] == "Code cleared.": state.update({"lines": [""], "cursor": [0,0], "scroll": 0})
            confirm_clear, redraw = False, True
            continue

        redraw = True
        r, c = state["cursor"]; h, _ = stdscr.getmaxyx(); page_size = h - 3
        is_limit_reached = sum(1 for line in state['lines'] if line.strip()) >= state['limit']

        if isinstance(key, str):
            if key == '\x18': return "QUIT"      # Ctrl+X
            elif key == '\x0e':                  # Ctrl+N (New/Clear)
                state['msg'] = "Clear all code? (y/n)"; confirm_clear = True
            elif key == '\x12':                  # Ctrl+R (BG Run)
                state['msg'] = "Math Mode runs graphically (Ctrl+T)." if state['math_mode_enabled'] else "Code limit exceeded." if is_limit_reached else run_code(state['lines'], True)[1]
            elif key == '\x14':                  # Ctrl+T (Terminal Run)
                if is_limit_reached: state['msg'] = "Code limit exceeded."; continue
                lines_to_run = state['lines']
                if state['math_mode_enabled']:
                    user_code = "\n".join([f"                {line}" for line in state["lines"]])
                    lines_to_run = GRAPHICAL_CANVAS_TEMPLATE.replace("                __SHADER_CODE_HERE__", user_code).splitlines()
                return lines_to_run
            elif key == '\n':
                if is_limit_reached: state['msg'] = "Line limit reached."; continue
                state["lines"].insert(r + 1, state["lines"][r][c:]); state["lines"][r] = state["lines"][r][:c]
                state["cursor"] = [r + 1, 0]
            elif key.isprintable():
                if is_limit_reached and not state["lines"][r].strip(): state['msg'] = "Line limit reached."; continue
                state["lines"][r] = f"{state['lines'][r][:c]}{key}{state['lines'][r][c:]}"; state["cursor"][1] += 1
        elif isinstance(key, int):
            if key == curses.KEY_F2:  # {Lines Limit}
                state["limit_idx"] = (state["limit_idx"] + 1) % len(PRESET_LIMITS)
                state["limit"] = PRESET_LIMITS[state["limit_idx"]]
                state["msg"] = f"Limit: {state['limit']} lines."
            elif key == curses.KEY_F3:  # {Math Mode} {FIXED}
                state["math_mode_enabled"] = not state["math_mode_enabled"]
                state["msg"] = f"Math Mode {'ENABLED' if state['math_mode_enabled'] else 'DISABLED'}."
            elif key == curses.KEY_LEFT:
                if c > 0: state["cursor"][1] -= 1
                elif r > 0: state["cursor"] = [r - 1, len(state["lines"][r - 1])]
            elif key == curses.KEY_RIGHT:
                if c < len(state["lines"][r]): state["cursor"][1] += 1
                elif r < len(state["lines"]) - 1: state["cursor"] = [r + 1, 0]
            elif key == curses.KEY_UP: state["cursor"][0] = max(0, r - 1)
            elif key == curses.KEY_DOWN: state["cursor"][0] = min(len(state["lines"]) - 1, r + 1)
            elif key == curses.KEY_HOME: state["cursor"][1] = 0
            elif key == curses.KEY_END: state["cursor"][1] = len(state["lines"][r])
            elif key == curses.KEY_PPAGE: state["cursor"][0] = max(0, r - page_size)
            elif key == curses.KEY_NPAGE: state["cursor"][0] = min(len(state["lines"]) - 1, r + page_size)
            elif key == curses.KEY_BACKSPACE:
                if c > 0:
                    state["lines"][r] = state["lines"][r][:c-1] + state["lines"][r][c:]; state["cursor"][1] -= 1
                elif r > 0:
                    prev_len = len(state["lines"][r-1]); state["lines"][r-1] += state["lines"].pop(r); state["cursor"] = [r - 1, prev_len]
            elif key == curses.KEY_DC:
                if c < len(state["lines"][r]): state["lines"][r] = state["lines"][r][:c] + state["lines"][r][c+1:]
                elif r < len(state["lines"]) - 1: state["lines"][r] += state["lines"].pop(r + 1)

        r_cur, c_cur = state["cursor"]
        state["cursor"][0] = max(0, min(len(state["lines"]) - 1, r_cur))
        state["cursor"][1] = max(0, min(len(state["lines"][state["cursor"][0]]), c_cur))
        if state["cursor"][0] < state["scroll"]: state["scroll"] = state["cursor"][0]
        elif state["cursor"][0] >= state["scroll"] + page_size: state["scroll"] = state["cursor"][0] - page_size + 1


# =============================================================================
# --- 7. APPLICATION ENTRY POINT ---
# =============================================================================

def main():
    """Initializes the application and runs the main editor loop."""
    if importlib.util.find_spec("tkinter") is None:
        print("--- WARNING: 'tkinter' not found. Math Mode requires it. ---")
        print("--- On Debian/Ubuntu: sudo apt-get install python3-tk ---")
        input("--- Press Enter to continue ---")
    
    setup_venv()
    
    while True:
        result = curses.wrapper(run_editor)
        if result == "QUIT": break
        if isinstance(result, list):
            run_code(result, in_background=False)
            
    stop_running_demo()
    print("Editor closed. All background processes terminated.")

if __name__ == "__main__":
    main()"

def main():
    print("Compiler initialized")
    
if __name__ == "__main__":
    main()