Upload 8 files

Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.11.9-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Install system dependencies (optional, for resource limiting)
+RUN apt-get update && apt-get install -y procps && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first to leverage Docker cache
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of your ErasLang engine
+COPY . .
+
+# Hugging Face Spaces runs on port 7860 by default
+ENV PORT=7860
+EXPOSE 7860
+
+# Start the FastAPI server
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,12 +1,27 @@
----
-title: ErasLangBackend
-emoji: 📉
-colorFrom: green
-colorTo: gray
-sdk: docker
-pinned: false
-license: cc-by-nc-nd-4.0
-short_description: Compiler for the ErasLang programming languagee
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# ErasLang API
+
+FastAPI backend for the ErasLang programming language.
+
+## Endpoints
+
+- `GET /` - Health check
+- `POST /perform` - Execute ErasLang code
+
+## Request Format
+
+```json
+{
+  "code": "ARE YOU READY FOR IT?\n    BLANK SPACE x\n    YOU BELONG WITH ME 13\n    SPEAK NOW x\nLONG LIVE",
+  "inputs": [1989]
+}
+```
+
+## Response Format
+
+```json
+{
+  "status": "success",
+  "output": "13\n",
+  "error": null
+}
+```

__init__.py

@@ -0,0 +1 @@
+# ErasLang package

app.py

@@ -0,0 +1,135 @@
+import subprocess
+import sys
+import os
+
+from fastapi import FastAPI, HTTPException, Request # type: ignore
+from fastapi.middleware.cors import CORSMiddleware # type: ignore
+from pydantic import BaseModel # type: ignore
+from slowapi import Limiter, _rate_limit_exceeded_handler # type: ignore
+from slowapi.util import get_remote_address # type: ignore
+from slowapi.errors import RateLimitExceeded # type: ignore
+from compiler import ErasCompiler # type: ignore
+
+# Initialize FastAPI and Rate Limiter
+app = FastAPI(title="ErasLang IDE Backend")
+limiter = Limiter(key_func=get_remote_address)
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+
+# SWE Best Practice: Enable CORS so your frontend can communicate with this API
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], # In production, replace with your frontend URL
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+compiler = ErasCompiler()
+
+class PerformanceRequest(BaseModel):
+    code: str
+    inputs: list[int] = []
+
+@app.get("/")
+@limiter.limit("20/minute")
+async def root(request: Request):
+    return {"message": "ErasLang Stage is Live. Ready for the Performance?"}
+
+@app.post("/perform")
+@limiter.limit("10/minute")
+async def run_eraslang(request: Request, body: PerformanceRequest):
+    """
+    Main execution endpoint. 
+    1. Transpiles ErasLang -> Python
+    2. Spawns worker.py subprocess
+    3. Returns results or errors
+    """
+    
+    # --- Step 1: Transpilation ---
+    try:
+        # We ensure the compiler adds # ERAS_LINE_X comments for our worker
+        python_source = compiler.transpile(body.code)
+        
+        # If inputs are provided, inject an input provider function
+        if body.inputs:
+            import re
+            # Replace all int(input()) calls with our custom input function
+            python_source = re.sub(
+                r'int\s*\(\s*input\s*\(\s*\)\s*\)',
+                'int(_eras_input())',
+                python_source
+            )
+            # Prepend the input provider code
+            input_provider = f"""
+# Input provider for prefilled inputs
+_input_index = 0
+_input_values = {body.inputs}
+
+def _eras_input():
+    global _input_index
+    if _input_index < len(_input_values):
+        value = _input_values[_input_index]
+        _input_index += 1
+        return str(value)
+    else:
+        raise ValueError("Not enough inputs provided. Expected more TELL ME WHY calls.")
+
+"""
+            python_source = input_provider + python_source
+    except Exception as e:
+        # Catch BadBloodSyntaxErrors from the compiler
+        return {
+            "status": "transpilation_error",
+            "output": "",
+            "error": str(e)
+        }
+
+    # --- Step 2: Subprocess Execution ---
+    try:
+        # We call worker.py and pipe the python_source into its stdin
+        worker_path = os.path.join(os.path.dirname(__file__), "worker.py")
+        process = subprocess.Popen(
+            [sys.executable, worker_path],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+
+        # We set a strict timeout (e.g., 10 seconds) to prevent infinite loops
+        try:
+            stdout_data, stderr_data = process.communicate(
+                input=python_source, 
+                timeout=10
+            )
+        except subprocess.TimeoutExpired:
+            process.kill()
+            return {
+                "status": "timeout",
+                "output": "Performance Timed Out. Did you get stuck in an 'Is it Over Now?' loop?",
+                "error": "Execution exceeded 10 second limit."
+            }
+
+        # --- Step 3: Handle Results ---
+        if process.returncode == 0:
+            return {
+                "status": "success",
+                "output": stdout_data,
+                "error": None
+            }
+        else:
+            # The worker.py prints thematic errors to stdout on failure
+            return {
+                "status": "runtime_error",
+                "output": stdout_data,
+                "error": stderr_data.strip()
+            }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"System Error: {str(e)}")
+
+if __name__ == "__main__":
+    import uvicorn # type: ignore
+    # Start the server on port 8000
+    uvicorn.run(app, host="0.0.0.0", port=8000)

compiler.py

@@ -0,0 +1,140 @@
+class ErasCompiler:
+    def __init__(self):
+        self.KEYWORDS = {
+            "ARE YOU READY FOR IT?": "BEGIN_MAIN",
+            "LONG LIVE": "END_MAIN",
+            "BLANK SPACE": "DECLARE_VAR",
+            "YOU BELONG WITH ME": "ASSIGN_VAL",
+            "SHAKE IT OFF": "BEGIN_MATH",
+            "MINE": "ADD",
+            "BACK TO DECEMBER": "SUBTRACT",
+            "ENOUGH TALK": "END_MATH",
+            "SPEAK NOW": "PRINT",
+            "I KNEW YOU WERE TROUBLE": "IF",
+            "YOU'RE ON YOUR OWN, KID": "ELSE",
+            "EXILE": "END_IF",
+            "STAY STAY STAY": "==",
+            "LET'S GO BATTLE": ">",
+            "FROM THE VAULT": "BEGIN_FUNC",
+            "I'LL NAME MINE": "FUNC_ARG",
+            "CLEAN": "END_FUNC",
+            "I'LL BE BACK": "RETURN",
+            "ME!": "AND",
+            "THE 1": "OR",
+            "LOOK WHAT YOU MADE ME DO": "NOT",
+            "TELL ME WHY": "INPUT",
+            "WE ARE NEVER EVER GETTING BACK TOGETHER": "BREAK",
+            "IS IT OVER NOW?": "WHILE",
+            "OUT OF THE WOODS": "END_WHILE",
+        }
+
+    def transpile(self, source_code: str) -> str:
+        lines = source_code.splitlines()
+        python_output = ["enchanted = 1\nexile = 0\nthirteen = 13\n"]
+        indent_level = 0
+        math_target = None
+        last_var = None
+
+        for line in lines:
+            raw = line  # Save original line for counting
+            line = line.strip()
+            if not line or line.startswith("DEAR JOHN"):
+                continue
+
+            token = None
+            payload = ""
+            for lyric, t in self.KEYWORDS.items():
+                if line.startswith(lyric):
+                    token = t
+                    payload = line.replace(lyric, "").strip()
+                    break
+            
+            if not token:
+                continue
+
+            # Replace comparison operators in payload
+            payload = payload.replace("STAY STAY STAY", "==")
+            payload = payload.replace("LET'S GO BATTLE", ">")
+            # Replace input keyword in payload - this handles "YOU BELONG WITH ME TELL ME WHY"
+            payload = payload.replace("TELL ME WHY", "int(input())")
+            # Remove PLAY keyword (used for function calls)
+            payload = payload.replace("PLAY ", "")
+
+            current_indent = "    " * indent_level
+
+            # Core Logic Mapping
+            if token == "BEGIN_MAIN":
+                python_output.append("def main():\n")
+                indent_level += 1
+            elif token == "END_MAIN":
+                python_output.append("\nmain()\n")  # Simplified for API execution
+            elif token == "DECLARE_VAR":
+                last_var = payload
+                python_output.append(f"{current_indent}{payload} = 0\n")
+            elif token == "ASSIGN_VAL":
+                # payload already has "int(input())" if it contained "TELL ME WHY"
+                val = payload
+                if math_target:
+                    python_output.append(f"{current_indent}_acc = {val}\n")
+                else:
+                    python_output.append(f"{current_indent}{last_var} = {val}\n")
+            elif token == "BEGIN_MATH":
+                math_target = payload
+            elif token == "END_MATH":
+                python_output.append(f"{current_indent}{math_target} = _acc\n")
+                math_target = None
+            elif token == "ADD":
+                python_output.append(f"{current_indent}_acc += {payload}\n")
+            elif token == "SUBTRACT":
+                python_output.append(f"{current_indent}_acc -= {payload}\n")
+            elif token == "AND":
+                python_output.append(f"{current_indent}_acc = int(bool(_acc) and bool({payload}))\n")
+            elif token == "OR":
+                python_output.append(f"{current_indent}_acc = int(bool(_acc) or bool({payload}))\n")
+            elif token == "NOT":
+                # Count how many times Taylor told you to look
+                flip_count = raw.count("LOOK WHAT YOU MADE ME DO")
+                
+                # We start with the value (either the payload variable or the current accumulator)
+                target = payload if payload else "_acc"
+                
+                # Use modulo 2 instead of spamming nots
+                if flip_count % 2 == 1:
+                    python_output.append(f"{current_indent}_acc = int(not bool({target}))\n")
+                else:
+                    python_output.append(f"{current_indent}_acc = int(bool({target}))\n")
+            elif token == "==":
+                python_output.append(f"{current_indent}_acc = int(_acc == {payload})\n")
+            elif token == "WHILE":
+                python_output.append(f"{current_indent}while {payload}:\n")
+                indent_level += 1
+            elif token == "END_WHILE":
+                indent_level -= 1
+            elif token == "IF":
+                python_output.append(f"{current_indent}if {payload}:\n")
+                indent_level += 1
+            elif token == "ELSE":
+                indent_level -= 1
+                python_output.append(f"{'    ' * indent_level}else:\n")
+                indent_level += 1
+            elif token == "END_IF":
+                indent_level -= 1
+            elif token == "PRINT":
+                python_output.append(f"{current_indent}print({payload})\n")
+            elif token == "BREAK":
+                python_output.append(f"{current_indent}break\n")
+            elif token == "INPUT":
+                python_output.append(f"{current_indent}{last_var} = int(input())\n")
+            elif token == "BEGIN_FUNC":
+                python_output.append(f"def {payload}")
+            elif token == "FUNC_ARG":
+                python_output[-1] += f"({payload}):\n"
+                indent_level += 1
+            elif token == "END_FUNC":
+                # Functions in Python don't need an explicit 'end' keyword, 
+                # so we just manage the indentation.
+                indent_level -= 1
+            elif token == "RETURN":
+                python_output.append(f"{current_indent}return {payload}\n")
+
+        return "".join(python_output)

exceptions.py

@@ -0,0 +1,22 @@
+# eras_exceptions.py
+
+class ErasLangError(Exception):
+    """Base class for all ErasLang errors."""
+    def __init__(self, message, line_no=None):
+        self.line_no = line_no
+        self.message = f"🎶 Performance Issue: {message}"
+        if line_no:
+            self.message += f" (at line {line_no})"
+        super().__init__(self.message)
+
+class BadBloodSyntaxError(ErasLangError):
+    """Raised when the compiler finds lyrics it doesn't recognize."""
+    pass
+
+class ExileRuntimeError(ErasLangError):
+    """Raised when the logic fails during execution (e.g., div by zero)."""
+    pass
+
+class VaultAccessError(ErasLangError):
+    """Raised when calling a function that wasn't found in the vault."""
+    pass

requirements.txt

@@ -0,0 +1,5 @@
+fastapi==0.128.0
+uvicorn==0.40.0
+pydantic==2.12.5
+httpx==0.28.1
+slowapi==0.1.9

worker.py

@@ -0,0 +1,76 @@
+import sys
+import traceback
+import re
+import resource
+
+def limit_resources():
+    """
+    Prevents malicious or accidental resource exhaustion.
+    """
+    try:
+        # Limit CPU time to 5 seconds
+        resource.setrlimit(resource.RLIMIT_CPU, (5, 5))
+    except (ValueError, OSError):
+        # Resource limits may not be available on all platforms
+        pass
+    try:
+        # Limit memory usage to 128MB
+        resource.setrlimit(resource.RLIMIT_AS, (128 * 1024 * 1024, 128 * 1024 * 1024))
+    except (ValueError, OSError):
+        # Resource limits may not be available on all platforms
+        pass
+
+def translate_line_number(error_msg):
+    """
+    Search the traceback for the # ERAS_LINE_X comment 
+    to map Python errors back to the original ErasLang line.
+    """
+    match = re.search(r"# ERAS_LINE_(\d+)", error_msg)
+    return match.group(1) if match else "Unknown"
+
+def perform_execution():
+    # 1. Read the transpiled Python code from the standard input pipe
+    try:
+        code = sys.stdin.read()
+    except EOFError:
+        return
+
+    # 2. Set up the "Stage" (Global Constants)
+    globals_dict = {
+        "enchanted": 1,
+        "exile": 0,
+        "thirteen": 13,
+        "__name__": "__main__",  # Ensure __name__ is set for if __name__ checks
+        "__builtins__": __builtins__ # Keep basic functions like print()
+    }
+
+    try:
+        # 3. Apply SWE Guardrails
+        limit_resources()
+
+        # 4. Execute the performance
+        exec(code, globals_dict)
+
+    # 5. Catch and Translate Errors to ErasLang Terminology
+    except ZeroDivisionError:
+        print("EXILE ERROR: You tried to divide by zero. You're on your own, kid.")
+        sys.exit(1)
+    except NameError as e:
+        full_error = traceback.format_exc()
+        line = translate_line_number(full_error)
+        # Extract the missing variable name from the error message
+        var_match = re.search(r"name '(.+)' is not defined", str(e))
+        var_name = var_match.group(1) if var_match else "something"
+        print(f"VAULT ERROR: '{var_name}' was never declared at Line {line}. You left a Blank Space.")
+        sys.exit(1)
+    except SyntaxError as e:
+        print(f"BAD BLOOD: The bridge is broken. Syntax error near Line {e.lineno}.")
+        sys.exit(1)
+    except Exception as e:
+        full_error = traceback.format_exc()
+        line = translate_line_number(full_error)
+        print(f"RUNTIME ERROR at Line {line}: {str(e)}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    perform_execution()