Upload Tzefa Space (full pipeline: OCR + language + execution)

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+demo.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,12 +1,69 @@
----
-title: Tzefa
-emoji: 🌍
-colorFrom: gray
-colorTo: indigo
-sdk: gradio
-sdk_version: 6.8.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Tzefa
+emoji: "\U0001F40D"
+colorFrom: green
+colorTo: blue
+sdk: gradio
+sdk_version: "5.8.0"
+app_file: app.py
+pinned: true
+license: cc-by-nc-3.0
+pipeline_tag: image-to-text
+tags:
+- vision
+- ocr
+- document-processing
+- binarization
+- yolo
+- trocr
+- handwriting-recognition
+- programming-language
+- compiler
+thumbnail: >-
+  https://cdn-uploads.huggingface.co/production/uploads/6645e2ce9c6ed6c615e56bf0/eTdBX9sR1-qzBuEPVWwZA.jpeg
+---
+
+# Tzefa - Handwritten Code to Execution
+
+**Tzefa** is an end-to-end system that photographs handwritten code on a whiteboard,
+recognizes it via a custom OCR pipeline, compiles it through a custom programming language,
+and executes it -- all from a single image upload.
+
+## Pipeline
+```
+Image Upload
+  |-- Stage 1: Binarization        -- HighResMAnet (mit_b5), tiled 640x640
+  |-- Stage 2: Line Segmentation   -- YOLO11x-OBB, oriented bounding boxes
+  |-- Stage 3: Word Segmentation   -- Morphological dilation (exactly 3 words/line)
+  |-- Stage 4: Word OCR            -- Fine-tuned TrOCR
+  |-- Stage 5: Error Correction    -- Edit-distance matching against Tzefa vocabulary
+  |-- Stage 6: Compilation         -- Tzefa instructions -> Python code
+  '-- Stage 7: Execution           -- Subprocess with 15s timeout
+```
+
+## Modular Design
+All models load from their own HuggingFace repos. Push new weights to any repo
+and this Space picks them up on next run.
+
+| Component | Model Repo |
+|-----------|-----------|
+| Binarization (b3) | [WARAJA/Model](https://huggingface.co/spaces/WARAJA/Model) |
+| Binarization (b5) | [WARAJA/b5_model](https://huggingface.co/WARAJA/b5_model) |
+| Line Segmentation | [WARAJA/Tzefa-Line-Segmentation-YOLO](https://huggingface.co/WARAJA/Tzefa-Line-Segmentation-YOLO) |
+| Word OCR | [WARAJA/Tzefa-Word-OCR-TrOCR](https://huggingface.co/WARAJA/Tzefa-Word-OCR-TrOCR) |
+
+## Tzefa Language
+Every instruction is exactly 3 tokens: `COMMAND ARG1 ARG2`
+
+```
+MAKEINTEGER NUMY FIVE       -- create integer NUMY = 5
+MULTIPLY RESULT BIGLY       -- RESULT = RESULT * BIGLY
+PRINTINTEGER TEMPORARY BREAK -- print TEMPORARY with newline
+```
+
+Numbers are written as words (ZERO through ONEHUNDRED) to maximize OCR error correction.
+
+## Related Spaces
+- [Binarization Demo](https://huggingface.co/spaces/WARAJA/Tzefa-Binarization)
+- [OCR-Only Demo](https://huggingface.co/spaces/WARAJA/Tzefa-OCR)
+

app.py

@@ -0,0 +1,479 @@
+"""
+Tzefa - Complete Pipeline Demo Space
+Image -> Binarization -> Line Segmentation -> Word Segmentation -> OCR ->
+Error Correction -> Compilation -> Execution
+
+All models loaded from their HF repos. Modular: swap weights and this updates.
+Language files (ErrorCorrection, topy, createdpython, Number2Name) are bundled in language/
+"""
+import os
+import gc
+import sys
+import subprocess
+import importlib
+import traceback
+import cv2
+import torch
+import numpy as np
+from PIL import Image
+import gradio as gr
+from huggingface_hub import hf_hub_download
+import segmentation_models_pytorch as smp
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import TrOCRProcessor, VisionEncoderDecoderModel
+from ultralytics import YOLO
+
+# Add language/ to path so ErrorCorrection can import Number2Name etc.
+SPACE_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SPACE_DIR)
+
+from language import ErrorCorrection, topy
+
+# ══════════════════════════════════════════════════════════════
+# CONFIG
+# ══════════════════════════════════════════════════════════════
+HF_TOKEN = os.environ.get("HF_TOKEN")
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+
+BIN_B3_REPO = "WARAJA/Model"
+BIN_B3_FILE = "b3_model.pth"
+BIN_B5_REPO = "WARAJA/b5_model"
+BIN_B5_FILE = "b5_model.pth"
+YOLO_REPO   = "WARAJA/Tzefa-Line-Segmentation-YOLO"
+YOLO_FILE   = "best.pt"
+TROCR_REPO  = "WARAJA/Tzefa-Word-OCR-TrOCR"
+TROCR_BASE_PROC = "microsoft/trocr-small-stage1"
+
+TILE_SIZE = 640
+YOLO_IMGSZ = 640
+TARGET_WORDS = 3
+MAX_DILATE_ITERS = 200
+
+
+# ══════════════════════════════════════════════════════════════
+# 1. BINARIZATION
+# ══════════════════════════════════════════════════════════════
+class HighResMAnet(nn.Module):
+    def __init__(self, encoder_name="mit_b5", classes=1):
+        super().__init__()
+        self.base_model = smp.MAnet(
+            encoder_name=encoder_name, encoder_weights=None,
+            in_channels=3, classes=classes, encoder_depth=5,
+            decoder_channels=(256, 128, 64, 32, 16),
+        )
+        self.high_res_stem = nn.Sequential(
+            nn.Conv2d(3, 16, 3, padding=1), nn.BatchNorm2d(16), nn.ReLU(True),
+            nn.Conv2d(16, 32, 3, padding=1), nn.BatchNorm2d(32), nn.ReLU(True),
+        )
+        self.final_fusion = nn.Sequential(
+            nn.Conv2d(48, 16, 3, padding=1), nn.ReLU(True),
+            nn.Conv2d(16, classes, 1),
+        )
+
+    def forward(self, x):
+        hr = self.high_res_stem(x)
+        feat = self.base_model.encoder(x)
+        dec = self.base_model.decoder(feat)
+        return self.final_fusion(torch.cat([dec, hr], dim=1))
+
+
+def _load_bin_models():
+    models = {}
+    b3_path = hf_hub_download(BIN_B3_REPO, BIN_B3_FILE, token=HF_TOKEN, repo_type="space")
+    m3 = smp.Unet(encoder_name="mit_b3", encoder_weights=None, in_channels=3, classes=1)
+    ckpt3 = torch.load(b3_path, map_location=DEVICE)
+    m3.load_state_dict(ckpt3.get("model_state_dict", ckpt3))
+    models["mit_b3 (Standard)"] = m3.to(DEVICE).eval()
+    b5_path = hf_hub_download(BIN_B5_REPO, BIN_B5_FILE, token=HF_TOKEN, repo_type="model")
+    m5 = HighResMAnet(encoder_name="mit_b5")
+    ckpt5 = torch.load(b5_path, map_location=DEVICE)
+    m5.load_state_dict(ckpt5.get("model_state_dict", ckpt5))
+    models["mit_b5 (HighRes)"] = m5.to(DEVICE).eval()
+    return models
+
+
+def _preprocess_tile(pil_img):
+    arr = np.array(pil_img).astype(np.float32) / 255.0
+    mean, std = np.array([0.485, 0.456, 0.406]), np.array([0.229, 0.224, 0.225])
+    return torch.from_numpy(((arr - mean) / std).transpose(2, 0, 1))
+
+
+def binarize(pil_img, model):
+    orig_w, orig_h = pil_img.size
+    pad_w = (TILE_SIZE - orig_w % TILE_SIZE) % TILE_SIZE
+    pad_h = (TILE_SIZE - orig_h % TILE_SIZE) % TILE_SIZE
+    padded = Image.new("RGB", (orig_w + pad_w, orig_h + pad_h), (255, 255, 255))
+    padded.paste(pil_img, (0, 0))
+    nw, nh = padded.size
+    canvas = Image.new("L", (nw, nh), 255)
+    for y in range(0, nh, TILE_SIZE):
+        for x in range(0, nw, TILE_SIZE):
+            tile = padded.crop((x, y, x + TILE_SIZE, y + TILE_SIZE))
+            t = _preprocess_tile(tile).unsqueeze(0).to(DEVICE).float()
+            with torch.no_grad():
+                logits = model(t)
+                if logits.shape[-2:] != (TILE_SIZE, TILE_SIZE):
+                    logits = F.interpolate(logits, (TILE_SIZE, TILE_SIZE), mode="bilinear")
+                mask = (torch.sigmoid(logits) > 0.5).float().cpu().numpy()[0, 0]
+            canvas.paste(Image.fromarray(((1.0 - mask) * 255).astype(np.uint8)), (x, y))
+    return canvas.crop((0, 0, orig_w, orig_h))
+
+
+# ══════════════════════════════════════════════════════════════
+# 2. LINE SEGMENTATION
+# ══════════════════════════════════════════════════════════════
+def _load_yolo():
+    path = hf_hub_download(YOLO_REPO, YOLO_FILE, token=HF_TOKEN, repo_type="model")
+    return YOLO(path)
+
+
+def segment_lines(bin_arr, yolo_model):
+    img_rgb = cv2.cvtColor(bin_arr, cv2.COLOR_GRAY2RGB) if len(bin_arr.shape) == 2 else bin_arr
+    orig_h, orig_w = img_rgb.shape[:2]
+    results = yolo_model.predict(img_rgb, imgsz=YOLO_IMGSZ, conf=0.2, iou=0.2, verbose=False)
+    truelines = []
+    if len(results) > 0 and results[0].obb is not None:
+        obbs = sorted(results[0].obb.xyxyxyxy.cpu().numpy(), key=lambda p: np.min(p[:, 1]))
+        for pts in obbs:
+            rx0, rx1 = np.min(pts[:, 0]), np.max(pts[:, 0])
+            ry0, ry1 = np.min(pts[:, 1]), np.max(pts[:, 1])
+            pad = (rx1 - rx0) * 0.12
+            x0 = int(np.clip(rx0 - pad, 0, orig_w))
+            x1 = int(np.clip(rx1 + pad, 0, orig_w))
+            y0, y1 = int(np.clip(ry0, 0, orig_h)), int(np.clip(ry1, 0, orig_h))
+            if x1 - x0 > 0 and y1 - y0 > 0:
+                truelines.append((x0, y0, x1 - x0, y1 - y0))
+    return truelines
+
+
+# ══════════════════════════════════════════════════════════════
+# 3. WORD SEGMENTATION
+# ══════════════════════════════════════════════════════════════
+def _get_word_boxes(dilated, min_w, min_h):
+    contours, _ = cv2.findContours(dilated, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    boxes = sorted([b for b in [cv2.boundingRect(c) for c in contours] if b[2] >= min_w and b[3] >= min_h],
+                   key=lambda b: b[0])
+    return boxes
+
+
+def segment_words(bin_arr, lines):
+    words_dict = {}
+    for i, (lx, ly, lw, lh) in enumerate(lines):
+        ih, iw = bin_arr.shape[:2]
+        ly, lx = max(0, ly), max(0, lx)
+        lh, lw = min(lh, ih - ly), min(lw, iw - lx)
+        if lw <= 0 or lh <= 0:
+            continue
+        crop = bin_arr[ly:ly+lh, lx:lx+lw]
+        inv = cv2.bitwise_not(crop)
+        min_ww, min_wh = max(5, int(lw * 0.02)), max(5, int(lh * 0.25))
+        kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 3))
+        dilated, prev, found = inv.copy(), None, False
+        for _ in range(MAX_DILATE_ITERS):
+            dilated = cv2.dilate(dilated, kernel, iterations=1)
+            boxes = _get_word_boxes(dilated, min_ww, min_wh)
+            if len(boxes) == TARGET_WORDS:
+                prev = boxes; found = True; break
+            elif len(boxes) < TARGET_WORDS:
+                break
+            else:
+                prev = boxes
+        if not found and prev and len(prev) > TARGET_WORDS:
+            while len(prev) > TARGET_WORDS:
+                gaps = [(prev[j+1][0] - (prev[j][0]+prev[j][2]), j) for j in range(len(prev)-1)]
+                _, mi = min(gaps)
+                b1, b2 = prev[mi], prev[mi+1]
+                merged = (min(b1[0],b2[0]), min(b1[1],b2[1]),
+                          max(b1[0]+b1[2],b2[0]+b2[2])-min(b1[0],b2[0]),
+                          max(b1[1]+b1[3],b2[1]+b2[3])-min(b1[1],b2[1]))
+                prev = list(prev); prev[mi] = merged; prev.pop(mi+1)
+            found = True
+        if not found or not prev or len(prev) != TARGET_WORDS:
+            continue
+        line_words = {}
+        for wi, (wx, wy, ww, wh) in enumerate(prev):
+            line_words[wi+1] = (wx, wx+ww)
+        words_dict[i+1] = line_words
+    return words_dict
+
+
+# ══════════════════════════════════════════════════════════════
+# 4. OCR
+# ══════════════════════════════════════════════════════════════
+def _load_trocr():
+    proc = TrOCRProcessor.from_pretrained(TROCR_BASE_PROC, use_fast=False)
+    model = VisionEncoderDecoderModel.from_pretrained(TROCR_REPO, token=HF_TOKEN).to(DEVICE).eval()
+    return proc, model
+
+
+def _pad_aspect(img, max_ratio=4.0):
+    w, h = img.size
+    if w <= max_ratio * h:
+        return img
+    th = int(w / max_ratio)
+    pad = th - h
+    from PIL import ImageOps
+    return ImageOps.expand(img, (0, pad//2, 0, pad - pad//2), fill=(255,255,255))
+
+
+def ocr_word(img_pil, proc, model):
+    if img_pil.mode != "RGB":
+        img_pil = img_pil.convert("RGB")
+    img_pil = _pad_aspect(img_pil)
+    pv = proc(img_pil, return_tensors="pt").pixel_values.to(DEVICE)
+    with torch.no_grad():
+        ids = model.generate(pv)
+    txt = proc.batch_decode(ids, skip_special_tokens=True)[0]
+    parts = txt.split()
+    return max(parts, key=len) if parts else txt
+
+
+# ══════════════════════════════════════════════════════════════
+# 5. VISUALIZATION
+# ══════════════════════════════════════════════════════════════
+def draw_line_bboxes(img_arr, bboxes):
+    vis = cv2.cvtColor(img_arr, cv2.COLOR_GRAY2RGB) if len(img_arr.shape) == 2 else img_arr.copy()
+    for i, (x, y, w, h) in enumerate(bboxes):
+        cv2.rectangle(vis, (x, y), (x+w, y+h), (255, 50, 50), 2)
+        cv2.putText(vis, str(i+1), (x, max(y-5, 0)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (50, 50, 255), 2)
+    return vis
+
+
+def draw_word_bboxes(img_arr, word_tuples):
+    vis = cv2.cvtColor(img_arr, cv2.COLOR_GRAY2RGB) if len(img_arr.shape) == 2 else img_arr.copy()
+    colors = [(50, 220, 50), (50, 180, 255), (255, 180, 50)]
+    for lt in word_tuples:
+        for wi, (text, (x1, y1, x2, y2)) in enumerate(lt):
+            c = colors[wi % len(colors)]
+            cv2.rectangle(vis, (x1, y1), (x2, y2), c, 2)
+            cv2.putText(vis, text, (x1, max(y1-4, 0)), cv2.FONT_HERSHEY_SIMPLEX, 0.45, c, 1)
+    return vis
+
+
+# ══════════════════════════════════════════════════════════════
+# 6. CLEAR VRAM
+# ══════════════════════════════════════════════════════════════
+def clear_vram():
+    gc.collect()
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+
+
+# ══════════════════════════════════════════════════════════════
+# 7. CODE EXECUTION
+# ══════════════════════════════════════════════════════════════
+def execute_code(compiled_code):
+    try:
+        result = subprocess.run(
+            [sys.executable, "-c", compiled_code],
+            capture_output=True, text=True, timeout=15,
+            cwd=SPACE_DIR,
+        )
+        output = result.stdout
+        if result.stderr:
+            output += "\n--- STDERR ---\n" + result.stderr
+        if result.returncode != 0:
+            output += f"\n[Process exited with code {result.returncode}]"
+        return output.strip() if output.strip() else "(no output)"
+    except subprocess.TimeoutExpired:
+        return "[Execution timed out after 15 seconds]"
+    except Exception as e:
+        return f"[Execution error: {e}]"
+
+
+# ══════════════════════════════════════════════════════════════
+# 8. FULL PIPELINE
+# ══════════════════════════════════════════════════════════════
+def run_full_pipeline(input_image, bin_model_choice):
+    """Returns: binarized, line_vis, word_vis, raw_ocr, corrected, compiled, execution, status"""
+    if input_image is None:
+        return None, None, None, "", "", "", "", "No image provided."
+
+    if isinstance(input_image, np.ndarray):
+        pil_img = Image.fromarray(input_image).convert("RGB")
+    else:
+        pil_img = input_image.convert("RGB")
+
+    status = []
+
+    # Reset language global state between runs
+    importlib.reload(ErrorCorrection)
+    importlib.reload(topy)
+
+    # ── Stage 1: Binarization ──
+    try:
+        status.append("[1/6] Binarization...")
+        bin_models = _load_bin_models()
+        model = bin_models[bin_model_choice]
+        bin_pil = binarize(pil_img, model)
+        bin_arr = np.array(bin_pil)
+        del bin_models; clear_vram()
+        status.append("  OK")
+    except Exception as e:
+        return None, None, None, "", "", "", "", f"Binarization failed: {e}"
+
+    # ── Stage 2: Line Segmentation ──
+    try:
+        status.append("[2/6] Line Segmentation...")
+        yolo_model = _load_yolo()
+        truelines = segment_lines(bin_arr, yolo_model)
+        del yolo_model; clear_vram()
+        status.append(f"  Found {len(truelines)} lines")
+        line_vis = draw_line_bboxes(bin_arr, truelines)
+    except Exception as e:
+        return bin_arr, None, None, "", "", "", "", f"Line Seg failed: {e}"
+
+    # ── Stage 3: Word Seg + OCR ──
+    try:
+        status.append("[3/6] Word Segmentation + OCR...")
+        words = segment_words(bin_arr, truelines)
+        proc, trocr_model = _load_trocr()
+        all_line_tuples, raw_lines = [], []
+        for ln in sorted(words.keys()):
+            if ln - 1 >= len(truelines):
+                continue
+            lx, ly, lw, lh = truelines[ln - 1]
+            line_tuples = []
+            for wn in sorted(words[ln].keys()):
+                wx1, wx2 = words[ln][wn]
+                ax1, ax2 = max(0, int(lx + wx1)), min(bin_arr.shape[1], int(lx + wx2))
+                ay1, ay2 = max(0, ly - 20), min(bin_arr.shape[0], ly + lh + 20)
+                crop_pil = Image.fromarray(bin_arr[ay1:ay2, ax1:ax2])
+                text = ocr_word(crop_pil, proc, trocr_model)
+                line_tuples.append((text, (ax1, ay1, ax2, ay2)))
+            raw_lines.append(" ".join(t[0] for t in line_tuples))
+            all_line_tuples.append(line_tuples)
+        del proc, trocr_model; clear_vram()
+        word_vis = draw_word_bboxes(bin_arr, all_line_tuples)
+        raw_text = "\n".join(raw_lines)
+        status.append(f"  {len(raw_lines)} lines recognized")
+    except Exception as e:
+        return bin_arr, line_vis, None, "", "", "", "", f"OCR failed: {e}"
+
+    # ── Stage 4: Error Correction ──
+    try:
+        status.append("[4/6] Error Correction...")
+        ErrorCorrection.sendlines(len(truelines))
+        index_list, corrected_lines = [], []
+        for line_entries in all_line_tuples:
+            if not line_entries:
+                corrected_lines.append(""); index_list.append(0); continue
+            raw_tokens = [t[0].upper() for t in line_entries]
+            while len(raw_tokens) < 3:
+                raw_tokens.append("")
+            raw_tokens = raw_tokens[:3]
+            cleaned_first, index, _ = ErrorCorrection.handelfirstword(raw_tokens[0])
+            index_list.append(index)
+            simpler = ErrorCorrection.listsimplefunc[index]
+            if simpler[1] == 0:
+                bucket_idx = simpler[2]
+                if isinstance(bucket_idx, int) and bucket_idx < len(ErrorCorrection.listall):
+                    bucket = ErrorCorrection.listall[bucket_idx]
+                    if raw_tokens[1] and raw_tokens[1] not in bucket:
+                        bucket.append(raw_tokens[1])
+            corrected_lines.append(f"{cleaned_first} {raw_tokens[1]} {raw_tokens[2]}")
+        corrected_text = "\n".join(corrected_lines)
+        status.append("  OK")
+    except Exception as e:
+        return bin_arr, line_vis, word_vis, raw_text, "", "", "", f"Error Correction failed: {e}\n{traceback.format_exc()}"
+
+    # ── Stage 5: Compilation ──
+    try:
+        status.append("[5/6] Compilation...")
+        linelist = []
+        for i in range(len(corrected_lines)):
+            idx = index_list[i] if i < len(index_list) else 0
+            line_obj = ErrorCorrection.toline(corrected_lines[i], idx, ErrorCorrection.giveindents())
+            linelist.append(line_obj)
+        listfunctions_out, listezfunctions_out = ErrorCorrection.giveinstructions()
+        topy.getinstructions(listfunctions_out, listezfunctions_out)
+        compiled = ["from language.createdpython import *"]
+        counterindent = 0
+        for i in range(1, len(linelist) + 1):
+            counterindent += topy.listofindentchanges[i]
+            compiled.append("    " * counterindent + topy.makepredict(linelist[i - 1], i))
+        compiled.append("printvars()")
+        compiled_code = "\n".join(compiled)
+        status.append("  OK")
+    except Exception as e:
+        return bin_arr, line_vis, word_vis, raw_text, corrected_text, "", "", f"Compilation failed: {e}\n{traceback.format_exc()}"
+
+    # ── Stage 6: Execution ──
+    try:
+        status.append("[6/6] Execution...")
+        exec_output = execute_code(compiled_code)
+        status.append("  Done!")
+    except Exception as e:
+        exec_output = f"Execution error: {e}"
+
+    return bin_arr, line_vis, word_vis, raw_text, corrected_text, compiled_code, exec_output, "\n".join(status)
+
+
+# ══════════════════════════════════════════════════════════════
+# 9. GRADIO UI
+# ══════════════════════════════════════════════════════════════
+with gr.Blocks(title="Tzefa - Handwritten Code to Execution", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        "# Tzefa - Handwritten Code to Execution\n"
+        "Upload a photo of handwritten Tzefa code. The pipeline runs binarization, "
+        "line detection, word OCR, error correction, compilation, and execution."
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            input_image = gr.Image(type="pil", label="Upload Image")
+            bin_choice = gr.Dropdown(
+                choices=["mit_b3 (Standard)", "mit_b5 (HighRes)"],
+                value="mit_b5 (HighRes)",
+                label="Binarization Model",
+            )
+            run_btn = gr.Button("Run Full Pipeline", variant="primary", size="lg")
+        with gr.Column(scale=1):
+            status_box = gr.Textbox(label="Pipeline Status", lines=12, interactive=False)
+
+    with gr.Tabs():
+        with gr.Tab("Binarized"):
+            bin_out = gr.Image(label="Binarized Image")
+        with gr.Tab("Line Detection"):
+            line_out = gr.Image(label="Line Bounding Boxes")
+        with gr.Tab("Word Detection + OCR"):
+            word_out = gr.Image(label="Word Bboxes with OCR Labels")
+        with gr.Tab("Raw OCR"):
+            raw_out = gr.Textbox(label="Raw OCR (before correction)", lines=15, interactive=False)
+        with gr.Tab("Error Corrected"):
+            corrected_out = gr.Textbox(label="After Error Correction", lines=15, interactive=False)
+        with gr.Tab("Compiled Python"):
+            compiled_out = gr.Code(language="python", label="Generated Python Code")
+        with gr.Tab("Execution Output"):
+            exec_out = gr.Textbox(label="Program Output", lines=10, interactive=False)
+
+    run_btn.click(
+        fn=run_full_pipeline,
+        inputs=[input_image, bin_choice],
+        outputs=[bin_out, line_out, word_out, raw_out, corrected_out, compiled_out, exec_out, status_box],
+    )
+
+    gr.Examples(
+        examples=[["demo.png", "mit_b5 (HighRes)"]],
+        inputs=[input_image, bin_choice],
+        label="Example Images",
+    )
+
+    gr.Markdown(
+        "### Resources\n"
+        "| Component | Link |\n"
+        "|-----------|------|\n"
+        "| Binarization Demo | [WARAJA/Tzefa-Binarization](https://huggingface.co/spaces/WARAJA/Tzefa-Binarization) |\n"
+        "| OCR-Only Demo | [WARAJA/Tzefa-OCR](https://huggingface.co/spaces/WARAJA/Tzefa-OCR) |\n"
+        "| b5 Model | [WARAJA/b5_model](https://huggingface.co/WARAJA/b5_model) |\n"
+        "| YOLO Model | [WARAJA/Tzefa-Line-Segmentation-YOLO](https://huggingface.co/WARAJA/Tzefa-Line-Segmentation-YOLO) |\n"
+        "| TrOCR Model | [WARAJA/Tzefa-Word-OCR-TrOCR](https://huggingface.co/WARAJA/Tzefa-Word-OCR-TrOCR) |\n"
+        "| Binarization Dataset | [WARAJA/Tzefa-Binarization-Dataset](https://huggingface.co/datasets/WARAJA/Tzefa-Binarization-Dataset) |\n"
+        "| Line Seg Dataset | [WARAJA/Tzefa-Line-Segmentation-Dataset](https://huggingface.co/datasets/WARAJA/Tzefa-Line-Segmentation-Dataset) |\n"
+        "| Word OCR Dataset | [WARAJA/Tzefa-Word-OCR-Dataset](https://huggingface.co/datasets/WARAJA/Tzefa-Word-OCR-Dataset) |"
+    )
+
+if __name__ == "__main__":
+    demo.queue().launch()
+

language/ErrorCorrection.py

@@ -0,0 +1,373 @@
+from language import Number2Name
+from fast_edit_distance import edit_distance
+
+
+def giveinstructions():
+    ### returns instructions for each function in the language for topy
+    return listfunctions, listezfunc
+
+
+listofindents = []
+
+
+def updatesizelistofindnets(size):
+    global listofindents
+    listofindents = [0] * (size + 1)
+
+
+def tosimple(func):
+    simpler = ["a", "b", "c", "d"]
+    simpler[0] = func[0]
+    if func[1].startswith("NEW"):
+        simpler[1] = 0
+    else:
+        simpler[1] = 1
+    i = 1
+    j = 2
+    if func[i].endswith("INT"):
+        simpler[j] = 0
+    elif func[i].endswith("STR"):
+        simpler[j] = 1
+    elif func[i].endswith("LIST"):
+        simpler[j] = 2
+    elif func[i].endswith("BOOL"):
+        simpler[j] = 3
+    elif func[i].endswith("COND"):
+        simpler[j] = 4
+    elif func[i].endswith("STATE"):
+        simpler[j] = 5
+    elif func[i].endswith("TYPE"):
+        simpler[j] = 6
+    elif func[i].endswith("FUNC"):
+        simpler[j] = 7
+    elif func[i].endswith("TRUTH"):
+        simpler[j] = 8
+    elif func[i].endswith("COMPARE"):
+        simpler[j] = 9
+    elif func[i].endswith("NUMNAME"):
+        simpler[j] = 10
+    elif func[i].endswith("TEXT"):
+        simpler[j] = 11
+    i = 2
+    j = 3
+    if func[i].endswith("INT"):
+        simpler[j] = 0
+    elif func[i].endswith("STR"):
+        simpler[j] = 1
+    elif func[i].endswith("LIST"):
+        simpler[j] = 2
+    elif func[i].endswith("BOOL"):
+        simpler[j] = 3
+    elif func[i].endswith("COND"):
+        simpler[j] = 4
+    elif func[i].endswith("STATE"):
+        simpler[j] = 5
+    elif func[i].endswith("TYPE"):
+        simpler[j] = 6
+    elif func[i].endswith("FUNC"):
+        simpler[j] = 7
+    elif func[i].endswith("TRUTH"):
+        simpler[j] = 8
+    elif func[i].endswith("COMPARE"):
+        simpler[j] = 9
+    elif func[i].endswith("NUMNAME"):
+        simpler[j] = 10
+    elif func[i].endswith("TEXT"):
+        simpler[j] = 11
+    simpler.append(0)
+    return simpler
+
+
+
+# CHANGED: Replaced NUM/INT with NUMNAME for immediate value reading (Index 10)
+listfunctions = [
+    ["MAKEINTEGER", "NEWINT", "NUMNAME"],
+    ["MAKEBOOLEAN", "NEWBOOL", "TRUTH"],
+    ["MAKESTR", "NEWSTR", "TEXT"],
+    ["NEWLIST", "NEWLIST", "NUMNAME"],
+    ["BASICCONDITION", "NEWCOND", "COMPARE"],
+    ["LEFTSIDE", "COND", "INT"],
+    ["RIGHTSIDE", "COND", "INT"],
+    ["CHANGECOMPARE", "COND", "COMPARE"],
+    ["WHILE", "COND", "NUMNAME"],
+    ["COMPARE", "COND", "NUMNAME"],
+    ["ELSECOMPARE", "COND", "NUMNAME"],
+    ["ITERATE", "LIST", "NUMNAME"],
+    ["WHILETRUE", "BOOL", "NUMNAME"],
+    ["IFTRUE", "BOOL", "NUMNAME"],
+    ["ELSEIF", "BOOL", "NUMNAME"],
+    ["INTEGERFUNCTION", "NEWFUNC", "TYPE"],
+    ["STRINGFUNCTION", "NEWFUNC", "TYPE"],
+    ["LISTFUNCTION", "NEWFUNC", "TYPE"],
+    ["RETURN", "VALUE", "STATE"],
+    ["PRINTSTRING", "STR", "STATE"],
+    ["PRINTINTEGER", "INT", "STATE"],
+    ["SETINDEX", "LIST", "INT"],
+    ["TYPETOINT", "STR", "INT"],
+    ["GETSTRING", "LIST", "STR"],
+    ["GETINTEGER", "LIST", "INT"],
+    ["WRITEINTEGER", "LIST", "INT"],
+    ["WRITESTRING", "LIST", "STR"],
+    ["WRITEBOOL", "LIST", "BOOL"],
+    ["WRITELIST", "LIST", "LIST"],
+    ["GETLIST", "LIST", "LIST"],
+    ["GETBOOL", "LIST", "BOOL"],
+    ["GETTYPE", "LIST", "STR"],
+    ["LENGTH", "LIST", "INT"],
+    ["ADDVALUES", "INT", "INT"],
+    ["MULTIPLY", "INT", "INT"],
+    ["MATHPOW", "INT", "INT"],
+    ["DIVIDE", "INT", "INT"],
+    ["SIMPLEDIVIDE", "INT", "INT"],
+    ["SUBTRACT", "INT", "INT"],
+    ["MODULO", "INT", "INT"],
+    ["COMBINE", "STR", "STR"],
+    ["BLANKSPACES", "STR", "NUMNAME"],
+    ["ADDSIZE", "LIST", "INT"],
+    ["ASSSIGNINT", "INT", "INT"],
+    ["STRINGASSIGN", "STR", "STR"],
+    ["COPYLIST", "LIST", "LIST"],
+]
+listsimplefunc = [tosimple(i) for i in listfunctions]
+listofindents = []
+listezfunc = [i[0] for i in listfunctions]
+
+# Variable Names only
+listintegers = ["TEMPORARY", "LOCALINT", "LOOPINTEGER"]
+
+# Immediate Number Names (Index 10)
+listnumnames = []
+word_to_num = {}
+for i in range(101):
+    name = Number2Name.get_name(i)
+    listnumnames.append(name)
+    word_to_num[name] = str(i)
+
+liststrings = ["TEMPSTRING", "GLOBALSTR", "LOOPSTRING", "INTEGER", "STRING", "LIST", "BOOLEAN"]
+listlists = ["GLOBALLIST", "LOOPLIST"]
+listconds = ["THETRUTH"]
+listbools = ["LOOPBOOL"]
+liststate = ["STAY", "BREAK"]
+listype = ["INTEGER", "STRING", "LIST", "BOOLEAN"]
+lookuptype = {"INTEGER": "INT", "STRING": "STR", "LIST": "LIST", "BOOLEAN": "BOOL"}
+listtruth = ["TRUE", "FALSE"]
+listcompare = ["EQUALS", "BIGEQUALS", "BIGGER"]
+listtext = []  # Placeholder for raw text arguments (Index 11)
+
+listall = [
+    listintegers,
+    liststrings,
+    listlists,
+    listbools,
+    listconds,
+    liststate,
+    listype,
+    listezfunc,
+    listtruth,
+    listcompare,
+    listnumnames,  # Index 10: Immediates
+    listtext,  # Index 11: Text
+]
+thetype = []
+insidefunction = False
+counter = 0
+
+
+def getsimples():
+    return listsimplefunc
+
+
+def sendlines(i):
+    global listofindents
+    listofindents = [0] * max(i + 1, 1000)
+
+
+def giveindents():
+    return listofindents
+
+def ocr_edit_distance(word1, word2):
+    """
+    Custom Levenshtein distance tailored for OCR.
+    Heavily penalizes distant letter swaps (H vs Q), but forgives common OCR shapes.
+    """
+    word1, word2 = word1.upper(), word2.upper()
+
+    # Common OCR confusions get a low penalty (0.5).
+    # Add more to this dictionary as you find specific model confusions!
+    low_cost_subs = {
+        ('O', '0'): 0.5, ('0', 'O'): 0.5,
+        ('I', '1'): 0.5, ('1', 'I'): 0.5,
+        ('I', 'L'): 0.5, ('L', 'I'): 0.5,
+        ('S', '5'): 0.5, ('5', 'S'): 0.5,
+        ('Z', '2'): 0.5, ('2', 'Z'): 0.5,
+        ('C', 'O'): 0.5, ('O', 'C'): 0.5,
+        ('C', 'G'): 0.5, ('G', 'C'): 0.5,
+        ('B', '8'): 0.5, ('8', 'B'): 0.5,
+        ('D', 'O'): 0.5, ('O', 'D'): 0.5,
+        ('E', 'F'): 0.5, ('F', 'E'): 0.5,
+        ('A', '4'): 0.5, ('4', 'A'): 0.5,
+    }
+
+    m, n = len(word1), len(word2)
+    dp = [[0.0] * (n + 1) for _ in range(m + 1)]
+
+    for i in range(m + 1):
+        dp[i][0] = i * 1.0  # Cost of deletion
+    for j in range(n + 1):
+        dp[0][j] = j * 1.0  # Cost of insertion
+
+    for i in range(1, m + 1):
+        for j in range(1, n + 1):
+            if word1[i-1] == word2[j-1]:
+                cost = 0.0
+            else:
+                sub_pair = (word1[i-1], word2[j-1])
+                # Generic substitution is penalized heavily (2.0)
+                cost = low_cost_subs.get(sub_pair, 2.0)
+
+            dp[i][j] = min(
+                dp[i-1][j] + 1.0,      # deletion
+                dp[i][j-1] + 1.0,      # insertion
+                dp[i-1][j-1] + cost    # substitution
+            )
+    return dp[m][n]
+
+def findword(somelist, word, use_ocr_weights=False):
+    """
+    Find the closest match to `word` in `somelist`.
+
+    use_ocr_weights=True  → ocr_edit_distance (custom weighted, no cap)
+                            used for function/command name lookups where OCR
+                            can produce arbitrarily garbled prefixes/suffixes.
+    use_ocr_weights=False → standard edit_distance with a generous cap (32)
+                            used for argument vocab lookups (short words, small lists).
+    """
+    min_dist = 999
+    tobereturned = [word, 0]
+    lentobereturned = 16
+    for b in range(len(somelist)):
+        lenword = len(word)
+        i = somelist[b]
+        lenofi = len(i)
+        if i == word:
+            return [i, b]
+        else:
+            if use_ocr_weights:
+                distance = ocr_edit_distance(word, i)
+            else:
+                distance = edit_distance(word, i, 32)
+            if distance < min_dist:
+                min_dist = distance
+                tobereturned = [i, b]
+                lentobereturned = len(tobereturned[0])
+            elif distance == min_dist:
+                if abs(lenword - lenofi) < abs(lenword - lentobereturned):
+                    tobereturned = [i, b]
+                    lentobereturned = len(tobereturned[0])
+
+    return tobereturned
+
+
+def handelfirstword(firstword):
+    func, index = findword(listezfunc, firstword, use_ocr_weights=True)
+    # Check if Arg2 (Index 2 in definition) is NUMNAME (Index 10 in listall)
+    # We use listfunctions directly to check the string type
+    if listfunctions[index][2] == "NUMNAME":
+        return (func, index, 1)
+    else:
+        return (func, index, 0)
+
+
+def toline(line, index, listofindents):
+    global counter
+    global thetype
+    global insidefunction
+    disthreeline = line.split(" ")
+    threeline = ["", "", ""]
+    problem = False
+    threeline[0] = listezfunc[index]
+    simpler = listsimplefunc[index]
+    if threeline[0] == "STRINGFUNCTION":
+        if insidefunction:
+            problem = True
+        else:
+            insidefunction = True
+            threeline[1] = disthreeline[1]
+            threeline[2] = findword(listype, disthreeline[2])[0]
+            thetype.append(threeline[2])
+            newsomething = [threeline[1], "STR", lookuptype[threeline[2]]]
+            listezfunc.append(newsomething[0])
+            listfunctions.append(newsomething)
+            simplerer = tosimple(newsomething)
+            listsimplefunc.append(simplerer)
+    elif threeline[0] == "INTEGERFUNCTION":
+        if insidefunction:
+            problem = True
+        else:
+            insidefunction = True
+            threeline[1] = disthreeline[1]
+            threeline[2] = findword(listype, disthreeline[2])[0]
+            thetype.append(threeline[2])
+            newsomething = [threeline[1], "INT", lookuptype[threeline[2]]]
+            listezfunc.append(newsomething[0])
+            listfunctions.append(newsomething)
+            simplerer = tosimple(newsomething)
+            listsimplefunc.append(simplerer)
+    elif threeline[0] == "LISTFUNCTION":
+        if insidefunction:
+            problem = True
+        else:
+            insidefunction = True
+            threeline[1] = disthreeline[1]
+            threeline[2] = findword(listype, disthreeline[2])[0]
+            thetype.append(threeline[2])
+            newsomething = [threeline[1], "LIST", lookuptype[threeline[2]]]
+            listezfunc.append(newsomething[0])
+            listfunctions.append(newsomething)
+            simplerer = tosimple(newsomething)
+            listsimplefunc.append(simplerer)
+    elif simpler[0] == "RETURN":
+        if len(thetype) == 0:
+            problem = True
+        else:
+            threeline[0] = "RETURN"
+            threeline[1] = findword(listall[listype.index(thetype[-1])], disthreeline[1])[0]
+            threeline[2] = findword(liststate, disthreeline[2])[0]
+            if threeline[2] == "BREAK":
+                insidefunction = False
+                thetype.pop()
+                listofindents[counter] = -1
+    else:
+        # Arg 1
+        if simpler[1] == 0:
+            listall[simpler[2]].append(disthreeline[1])
+            threeline[1] = disthreeline[1]
+        else:
+            threeline[1] = findword(listall[simpler[2]], disthreeline[1])[0]
+            # If Arg 1 is a NUMNAME, replace with actual value
+            if simpler[2] == 10:
+                threeline[1] = word_to_num[threeline[1]]
+
+        # Arg 2
+        if simpler[3] < len(listall):
+            threeline[2] = findword(listall[simpler[3]], disthreeline[2])[0]
+            # If Arg 2 is a NUMNAME, replace with actual value
+            if simpler[3] == 10:
+                threeline[2] = word_to_num[threeline[2]]
+        else:
+            threeline[2] = disthreeline[2]
+
+    # Use the now-numeric value in threeline[2] for indents
+    # Only actual control flow: WHILE, ITERATE, COMPARE, ELSECOMPARE, WHILETRUE, IFTRUE, ELSEIF
+    # NOT BASICCONDITION, CHANGECOMPARE (these aren't control flow, their arg2 isn't a line number)
+    control_flow = {"WHILE", "ITERATE", "COMPARE", "ELSECOMPARE", "WHILETRUE", "IFTRUE", "ELSEIF"}
+    if threeline[0] in control_flow:
+        listofindents[counter] = 1
+        listofindents[int(threeline[2])] = -1
+    elif threeline[0] == "DEFINE":
+        listfunctions.append(threeline[0])
+        listofindents[int(counter)] = 1
+    counter += 1
+    if len(threeline[1]) == 0 or len(threeline[2]) == 0:
+        problem = True
+    return threeline

language/Number2Name.py

@@ -0,0 +1,15 @@
+def get_name(number):
+    namearray = ['ZERO', 'ONE', 'TWO', 'THREE', 'FOUR', 'FIVE', 'SIX', 'SEVEN', 'EIGHT', 'NINE', 'TEN', 'ELEVEN',
+                 'TWELVE', 'THIRTEEN', 'FOURTEEN', 'FIFTEEN', 'SIXTEEN', 'SEVENTEEN', 'EIGHTEEN', 'NINETEEN', 'TWENTY',
+                 'TWENTYONE', 'TWENTYTWO', 'TWENTYTHREE', 'TWENTYFOUR', 'TWENTYFIVE', 'TWENTYSIX', 'TWENTYSEVEN',
+                 'TWENTYEIGHT', 'TWENTYNINE', 'THIRTY', 'THIRTYONE', 'THIRTYTWO', 'THIRTYTHREE', 'THIRTYFOUR',
+                 'THIRTYFIVE', 'THIRTYSIX', 'THIRTYSEVEN', 'THIRTYEIGHT', 'THIRTYNINE', 'FORTY', 'FORTYONE', 'FORTYTWO',
+                 'FORTYTHREE', 'FORTYFOUR', 'FORTYFIVE', 'FORTYSIX', 'FORTYSEVEN', 'FORTYEIGHT', 'FORTYNINE', 'FIFTY',
+                 'FIFTYONE', 'FIFTYTWO', 'FIFTYTHREE', 'FIFTYFOUR', 'FIFTYFIVE', 'FIFTYSIX', 'FIFTYSEVEN', 'FIFTYEIGHT',
+                 'FIFTYNINE', 'SIXTY', 'SIXTYONE', 'SIXTYTWO', 'SIXTYTHREE', 'SIXTYFOUR', 'SIXTYFIVE', 'SIXTYSIX',
+                 'SIXTYSEVEN', 'SIXTYEIGHT', 'SIXTYNINE', 'SEVENTY', 'SEVENTYONE', 'SEVENTYTWO', 'SEVENTYTHREE',
+                 'SEVENTYFOUR', 'SEVENTYFIVE', 'SEVENTYSIX', 'SEVENTYSEVEN', 'SEVENTYEIGHT', 'SEVENTYNINE', 'EIGHTY',
+                 'EIGHTYONE', 'EIGHTYTWO', 'EIGHTYTHREE', 'EIGHTYFOUR', 'EIGHTYFIVE', 'EIGHTYSIX', 'EIGHTYSEVEN',
+                 'EIGHTYEIGHT', 'EIGHTYNINE', 'NINETY', 'NINETYONE', 'NINETYTWO', 'NINETYTHREE', 'NINETYFOUR',
+                 'NINETYFIVE', 'NINETYSIX', 'NINETYSEVEN', 'NINETYEIGHT', 'NINETYNINE', 'ONEHUNDRED']
+    return namearray[number]

language/__init__.py

@@ -0,0 +1,2 @@
+# language package for Tzefa HF Space
+

language/createdpython.py

@@ -0,0 +1,760 @@
+### finally found the bug
+### here it is:
+### lets say function f calls a new instance of itself
+### the new instance creates cond b and a new instance of itself
+### the new instance closes and returns to the instance with  cond b that also closes itself
+### now the original instance still owns cond b since no function was called to clean the stack or dict between the exiting calls
+dicte = {"EQUALS": 0, "BIGEQUALS": 1, "BIGGER": 2}
+listfunctions = [(lambda x, y: x == y), (lambda x, y: x >= y), (lambda x, y: x > y)]
+import sys
+import language.Number2Name as Number2Name
+linecount = 0
+currentline = 0
+linelimit = 1000
+functionlimit = 25
+functioncount = 0
+printed = ""
+alltheconds = {}
+reserveconds = {}
+reserveloc = {}
+reserveglob = {"INT": {}, "STR": {}, "LIST": {}, "BOOLEAN": {}}
+
+
+def line(linenum):
+    global currentline
+    currentline = linenum
+    # if("LISTOFTWO" in allthevars["LIST"]):
+    # print(linenum,getvar("LIST","LISTOFTWO").values)
+    return True
+
+
+class Node:
+    def __init__(self, value):
+        self.value = value
+        self.next = None
+
+    def setnext(self, nextvalue):
+        self.next = Node(value=nextvalue)
+
+    def setnextnode(self, next):
+        self.next = next
+
+    def getnext(self):
+        return self.next
+
+    def getvalue(self):
+        return self.value
+
+
+class Stack:
+    def __init__(self):
+        self.top = None
+        self.list = []
+
+    def isempty(self):
+        return len(self.list) == 0
+
+    def push(self, value):
+        self.list.append(value)
+
+    def pop(self):
+        return self.list.pop()
+
+
+functioncalls = Stack()
+
+
+def addcond(name, compare):
+    global alltheconds
+    if (name in alltheconds):
+        errore.varexistserror(name)
+    else:
+        alltheconds[name] = COND(compare)
+
+
+def addlocalcond(name, compare):
+    global alltheconds, allthelocalconds
+    if (name in alltheconds):
+        errore.varexistserror(name)
+    else:
+        alltheconds[name] = COND(compare)
+        allthelocalconds[name] = alltheconds[name]
+    return allthelocalconds
+
+
+# import dis
+# print(dis.dis(addlocalcond))
+def movetonewconds(localconds):
+    global stackoflocalconds
+    global alltheconds
+    global reserveconds
+    for i in localconds:
+        del alltheconds[i]
+    stackoflocalconds.push(localconds)
+
+
+def backtooldconds():
+    global stackoflocalconds
+    popped = stackoflocalconds.pop()
+    global alltheconds
+    global reserveconds
+    for i in reserveconds:
+        if i in alltheconds:
+            del alltheconds[i]
+    reserveconds = {}
+    for i in popped:
+        alltheconds[i] = popped[i]
+        reserveconds[i] = popped[i]
+    return popped
+
+
+def getcond(name):
+    global alltheconds
+    if (name in alltheconds):
+        return alltheconds[name]
+    else:
+        errore.doesntexisterror(name)
+
+
+def printvars():
+    global allthevars, printed
+    print("END OF PROGRAM")
+    print()
+    for i in allthevars:
+        print("All the vars used from type " + i)
+        for j in allthevars[i]:
+            if (allthevars[i][j].iswritable()):
+                print(j + " : " + allthevars[i][j].tostring())
+            else:
+                pass
+        print("")
+    print("All that was printed during the program")
+    print(printed)
+
+
+def addvar(type, name, value):
+    global allthevars
+    if name in allthevars[type]:
+        errore.varexistserror(name)
+    if (type == "LIST"):
+        allthevars[type][name] = LIST(name, value, True, True, type)
+    else:
+        allthevars[type][name] = VALUE(name, value, True, True, type)
+
+
+def getvar(type, name):
+    global allthevars
+    if (name in allthevars[type]):
+        return allthevars[type][name]
+    else:
+        errore.doesntexisterror(name)
+
+
+def addlocalvar(type, name, value):
+    global dictlocalvars, allthevars
+    allthelocalrvars = dictlocalvars
+    if name in allthevars[type]:
+        errore.varexistserror(name)
+    if (type == "LIST"):
+        allthevars[type][name] = LIST(name, value, True, True, type)
+        allthelocalrvars[type][name] = allthevars[type][name]
+
+    else:
+        allthevars[type][name] = VALUE(name, value, True, True, type)
+        allthelocalrvars[type][name] = allthevars[type][name]
+
+
+def switchtonewcall(dict1: dict, dict2: dict, stack: Stack):
+    for i in dict2:
+        for j in dict2[i]:
+            del dict1[i][j]
+    stack.push(dict2)
+    return {"INT": {}, "STR": {}, "LIST": {}, "BOOLEAN": {}}
+
+
+def returntoolastcall(dict1: dict):
+    stack = localsvars
+    lastcall = stack.pop()
+    global reserveloc
+    for i in reserveloc:
+        for j in reserveloc[i]:
+            if j in dict1[i]:
+                del dict1[i][j]
+    reserveloc = {"INT": {}, "STR": {}, "LIST": {}, "BOOLEAN": {}}
+    for i in lastcall:
+        for j in lastcall[i]:
+            dict1[i][j] = lastcall[i][j]
+            reserveloc[i][j] = lastcall[i][j]
+    return lastcall
+
+
+def Print(var, newline):
+    global printed
+    toprint = var.tostring() + newline * '\n' + ' ' * (1 - newline)
+    print(toprint, end='')
+    printed = printed + toprint
+
+
+class VALUE:
+    def __init__(self, name, value, readable, writable, TYPE):
+        self.name = name
+        self.value = value
+        self.readable = readable
+        self.writable = writable
+        self.type = TYPE
+
+    def write(self, value):
+        if (self.writable == True):
+            self.value = value
+        else:
+            errore.writeerror(self.name, value)
+
+    def forcewrite(self, value):
+        self.value = value
+
+    def read(self):
+        if (self.readable == True):
+            return self.value
+        else:
+            errore.readerror(self.name)
+
+    def forceread(self):
+        return self.value
+
+    def changeread(self, readstatus):
+        self.readable = readstatus
+
+    def changewrite(self, writestatus):
+        self.writable = writestatus
+
+    def getname(self):
+        return self.name
+
+    def iswritable(self):
+        return self.writable
+
+    def isreadable(self):
+        return self.readable
+
+    def tostring(self):
+        return str(self.value)
+
+    def givetype(self):
+        return self.type
+
+    def override(self, value):
+        self.value = value
+
+    def makecopy(self):
+        return VALUE(self.name, self.value, self.readable, True, self.type)
+
+    def copyvar(self, vari):
+        if (self.type != vari.type):
+            errore.typeerror(self.name, self.type, vari.type)
+        else:
+            if (vari.isreadable() == False):
+                errore.readerror(vari.getname())
+            else:
+                self.value = vari.value
+
+
+def add(Vali1, vali2):
+    getvar("INT", "TEMPORARY").forcewrite(getvar("INT", Vali1).read() + getvar("INT", vali2).read())
+
+
+def dec(Vali1, vali2):
+    getvar("INT", "TEMPORARY").forcewrite(getvar("INT", Vali1).read() - getvar("INT", vali2).read())
+
+def mult(Vali1, vali2):
+    getvar("INT", "TEMPORARY").forcewrite(getvar("INT", Vali1).read() * getvar("INT", vali2).read())
+
+
+def div(Vali1, vali2):
+    if (getvar("INT", vali2).read() == 0):
+        errore.DIVZEROERROR(vali2)
+    getvar("INT", "TEMPORARY").forcewrite(getvar("INT", Vali1).read() // getvar("INT", vali2).read())
+
+
+def betterdiv(Vali1, vali2):
+    if (getvar("INT", vali2).read() == 0):
+        errore.DIVZEROERROR(vali2)
+    getvar("INT", "TEMPORARY").forcewrite(getvar("INT", Vali1).read() / getvar("INT", vali2).read())
+
+
+def pow(Vali1, vali2):
+    getvar("INT", "TEMPORARY").forcewrite(getvar("INT", Vali1).read() ** getvar("INT", vali2).read())
+
+
+def mod(Vali1, vali2):
+    if (getvar("INT", vali2).read() == 0):
+        errore.DIVZEROERROR(vali2)
+    getvar("INT", "TEMPORARY").forcewrite(int(getvar("INT", Vali1).read() % getvar("INT", vali2).read()))
+
+
+def comb(Vali1, vali2):
+    getvar("STR", "TEMPSTRING").forcewrite(getvar("STR", Vali1).read() + getvar("STR", vali2).read())
+
+
+def addsize(Vali1, vali2):
+    getvar("LIST", Vali1).addsize(getvar("INT", vali2).read())
+
+
+def assignlist(Vali1, vali2):
+    getvar("LIST", Vali1).copyvar(getvar("LIST", vali2))
+
+
+def assignstr(Vali1, vali2):
+    getvar("STR", Vali1).copyvar(getvar("STR", vali2))
+
+
+def assignint(Vali1, vali2):
+    getvar("INT", Vali1).copyvar(getvar("INT", vali2))
+
+
+def blankspaces(Vali1, Vali2):
+    getvar("STR", Vali1).write(getvar("STR", Vali1).read() + ' ' * Vali2)
+
+
+def typetoint(vali1, vali2):
+    lookuptable = {"INT": 0, "STR": 1, "BOOLEAN": 2, "LIST": 3}
+    if (getvar('STR', vali1).read() in lookuptable):
+        getvar('INT', vali2).write(lookuptable[getvar('STR', vali1).read()])
+    else:
+        errore.typetointerror(getvar('STR', vali1).read())
+
+
+class COND:
+    def __init__(self, compare):
+        self.index = dicte[compare]
+        self.left = VALUE("0", 0, False, False, "INT")
+        self.right = VALUE("0", 0, False, False, "INT")
+
+    def changecompare(self, compare):
+        self.index = dicte[compare]
+
+    def changeleft(self, left):
+        self.left = left
+
+    def changeright(self, right):
+        self.right = right
+
+    def giveresult(self):
+        return listfunctions[self.index](self.left.read(), self.right.read())
+
+    def givetype(self):
+        return self.type
+
+
+class EERROR(Exception):
+    global sizeoflistinuse, wantedindex
+
+    def __init__(self):
+        pass
+
+    def nameerror(self, type, name):
+        global currentline
+        globalline = currentline
+        print("Error Line: " + str(globalline))
+        print("Var of name " + name + " doesn't exist as type " + type)
+        print(" ")
+        printvars()
+        sys.exit(0)
+
+    def makeeindexrror(self, sizeoflistinuse, wantedindex, name, name2):
+        global currentline
+        globalline = currentline
+        print("Error Line: " + str(globalline))
+        print("Tried to change index of list " + name + " with size of " + str(sizeoflistinuse) + " to value " + str(
+            wantedindex) + " placed in " + str(name2))
+        print(" ")
+        printvars()
+        sys.exit(0)
+
+    def DIVZEROERROR(self, name):
+        global currentline
+        globalline = currentline
+        print("Error Line: " + str(globalline))
+        print("Cant divide by zero and var " + name + " has value of zero")
+        print(" ")
+        printvars()
+        sys.exit(0)
+
+    def doesntexisterror(self, name):
+        global currentline
+        globalline = currentline
+        print("Error Line: " + str(globalline))
+        print("No object with name " + str(name) + " exists")
+        printvars()
+        sys.exit(0)
+
+    def writeerror(self, name, value):
+        global currentline
+        globalline = currentline
+        print("Error Line: " + str(globalline))
+        print("Tried to write value of " + str(value) + " to unwritable variable " + name)
+        print(" ")
+        printvars()
+        sys.exit(0)
+
+    def typetointerror(self, value):
+        global currentline
+        globalline = currentline
+        print("Error Line: " + str(globalline))
+        print("No type such as " + str(value))
+        print(" ")
+        printvars()
+        sys.exit(0)
+
+    def readerror(self, name):
+        global currentline
+        globalline = currentline
+        print("Error Line: " + str(globalline))
+        print("Tried to read from unreadable variable " + name)
+        print(" ")
+        printvars()
+        sys.exit(0)
+
+    def linelimiterror(self):
+        global currentline
+        globalline = currentline
+        print("Error Line: " + str(currentline))
+        print("Program ran for too long")
+        print(" ")
+        printvars()
+        sys.exit(0)
+
+    def overflowerror(self, functioncalls):
+        global currentline
+        globalline = currentline
+        print("Error Line: " + str(globalline))
+        print("Executing too many  function calls ")
+        print("List of function calls")
+        for i in functioncalls:
+            pass
+        print(" ")
+        printvars()
+        sys.exit(0)
+
+    def cantchangeindexerror(self, name, value):
+        global currentline
+        globalline = currentline
+        print("Error Line: " + str(globalline))
+        print("Tried to change indexes of list " + name + " and add size  " + str(value) + " but list is unwritable")
+
+    def varexistserror(self, name):
+        global currentline
+        globalline = currentline
+        print("Error Line: " + str(globalline))
+        print("Tried to create object with name " + name + " but var already exists")
+        print(" ")
+        printvars()
+        sys.exit(0)
+
+    def typeerror(self, name, type1, type2):
+        global currentline
+        globalline = currentline
+        print("Error Line: " + str(globalline))
+        print("Mismatch of types  " + type1 + " and " + type2 + " in list " + name)
+        print(" ")
+        printvars()
+        sys.exit(0)
+
+
+class LIST:
+    def __init__(self, name, size, readable, writable, TYPE):
+        self.size = size
+        self.index = 0
+        self.values = [VALUE(name=(str(name) + " " + str(i)), value=0, writable=True, readable=True, TYPE="INT") for i
+                       in range(size)]
+        self.types = ["INT" for i in range(size)]
+        self.readable = readable
+        self.writable = writable
+        self.name = name
+        self.type = TYPE
+
+    def addsize(self, added):
+        if (self.writable):
+            self.size = self.size + added
+            self.values = [
+                self.values[i] if listfunctions[2](self.size, i) else VALUE(name=(str(i) + " " + str(i)), value=0,
+                                                                            writable=True, readable=True, TYPE="INT")
+                for i in range(self.size + added)]
+        else:
+            errore.cantchangeindexerror(self.name, added)
+
+    def forceaddsize(self, added):
+        self.size = self.size + added
+        self.values = [
+            self.values[i] if listfunctions[2](self.size, i) else VALUE(name=(str(i) + " " + str(i)), value=0,
+                                                                        writable=True, readable=True, TYPE="INT") for i
+            in range(self.size + added)]
+
+    def changeindex(self, newindex):
+        if (self.readable):
+            if (newindex >= self.size):
+                errore.makeeindexrror(newindex, self.size, self.name)
+            else:
+                self.index = newindex
+        else:
+            errore.readerror(self.name)
+
+    def forcechangeindex(self, newindex):
+        if (newindex >= self.size):
+            errore.makeeindexrror(newindex, self.size, self.name)
+        else:
+            self.index = newindex
+
+    def placevalue(self, name, type):
+        if (self.writable):
+            thevar = getvar(type, name)
+            if (thevar.isreadable()):
+                self.types[self.index] = type
+                self.values[self.index] = thevar.makecopy()
+            else:
+                errore.readerror(name)
+        else:
+            errore.writeerror(self.name, name)
+
+    def forceplacevalue(self, name, type):
+        thevar = getvar(type, name)
+        if (thevar.isreadable()):
+            self.types[self.index] = type
+            self.values[self.index] = thevar.makecopy()
+        else:
+            errore.readerror()
+
+    def returnvalue(self):
+        if (self.readable):
+            return self.values[self.index]
+        else:
+            errore.readerror(self.name)
+
+    def read(self):
+        if (self.readable):
+            return self.values[self.index]
+        else:
+            errore.readerror(self.name)
+
+    def forcereturnvalue(self):
+        return self.values[self.index]
+
+    def copybyvalue(self, newvalue: VALUE):
+        if (self.types[self.index] == newvalue.givetype()):
+            newvalue.write(self.values[self.index].read())
+        else:
+            errore.typeerror(name=self.name, type1=self.types[self.index], type2=newvalue.givetype())
+
+    def returntype(self):
+        if (self.readable):
+            return self.types[self.index]
+        else:
+            errore.readerror(self.name)
+
+    def forcereturntype(self):
+        return self.types[self.index]
+
+    def tostring(self):
+        strei = ""
+        for i in self.values:
+            strei = strei + str(i.tostring()) + " "
+        return "[ " + strei + " ]"
+
+    def tostringoftypes(self):
+        if (self.readable):
+            stre = ""
+            for i in self.types:
+                stre = stre + i[0]
+            return stre
+        else:
+            errore.readerror(self.name)
+
+    def forcetostringoftypes(self):
+        stre = ""
+        for i in self.types:
+            stre = stre + i[0]
+        return stre
+
+    def changeread(self, readstatus):
+        self.readable = readstatus
+
+    def changewrite(self, writestatus):
+        self.writable = writestatus
+
+    def getname(self):
+        return self.name
+
+    def iswritable(self):
+        return self.writable
+
+    def isreadable(self):
+        return self.readable
+
+    def getvalues(self):
+        return self.values
+
+    def gettypes(self):
+        return self.types
+
+    def getsize(self):
+        return self.size
+
+    def makecopy(self):
+        thelist = LIST(self.name, self.size, self.readable, True, self.type)
+        thelist.types = self.types.copy()
+        thelist.values = [val.makecopy() for val in self.values]
+        return thelist
+
+    def override(self, values, types, size):
+        self.values = values
+        self.types = types
+        self.size = size
+
+    def givetype(self):
+        return self.type
+
+    def copyvar(self, listi):
+        if (self.type != listi.type):
+            errore.typeerror(self.name, self.type, listi.type)
+        else:
+            if (listi.isreadable() == False):
+                errore.readerror(listi.getname())
+            else:
+                self.type = 'LIST'
+                self.types = listi.types.copy()
+                self.size = listi.size
+                self.values = [var.makecopy() for var in listi.values]
+
+
+def join(listi: LIST, linee):
+    if (listi.isreadable() == False):
+        errore.readerror(listi.name)
+    for i in range(listi.size):
+        listi.index = i
+        value = listi.values[i]
+        typi = listi.types[i]
+        goodloopvars[typi].copyvar(value)
+        getvar('STR', 'TEMPSTRING').forcewrite(typi)
+        line(linee)
+        endline()
+        yield value
+
+
+def returntooldlocals(dictofglobals, dictoflocals):
+    global reserveglob
+    for i in reserveglob:
+        for j in reserveglob[i]:
+            del dictofglobals[i][j]
+    reserveglob = {"INT": {}, "STR": {}, "LIST": {}}
+    for i in dictoflocals:
+        for j in dictoflocals[i]:
+            dictofglobals[i][j] = dictoflocals[i][j]
+            reserveglob[i][j] = dictoflocals[i][j]
+
+
+def endline():
+    global errore, linecount
+    linecount += 1
+    if (linecount == linelimit):
+        errore.linelimiterror()
+    else:
+        return True
+
+
+def updateline():
+    global errore, linecount
+    linecount += 1
+    if (linecount == linelimit):
+        errore.linelimiterror()
+    else:
+        return True
+
+
+def updatelinewithcall(type, namevarinput, function, typeoutput, nameoutput, lini):
+    line(lini)
+    global allthevars, functioncount, localsstack, programlocals, nameofprogramlocals, dictlocalvars, functionlimit, allthelocalconds, nameofprogramlocals
+    localsstack.push(programlocals)
+
+    varinput = getvar(type, namevarinput)
+    for i in nameofprogramlocals:
+        if (i == 'STR'):
+            allthevars[i][nameofprogramlocals[i]] = VALUE(nameofprogramlocals[i], '', False, False, 'STR')
+        elif (i == 'INT'):
+            allthevars[i][nameofprogramlocals[i]] = VALUE(nameofprogramlocals[i], 0, False, False, 'INT')
+        else:
+            allthevars[i][nameofprogramlocals[i]] = LIST(nameofprogramlocals[i], 8, False, False, 'LIST')
+    programlocals = {"INT": {"LOCALINT": allthevars["INT"]["LOCALINT"]},
+                     "STR": {"LOCALSTR": allthevars["STR"]["LOCALSTR"]},
+                     "LIST": {"LOCALLIST": allthevars["LIST"]["LOCALLIST"]}}
+    allthevars[type][nameofprogramlocals[type]].copyvar(varinput)
+    vartosend = allthevars[type][nameofprogramlocals[type]]
+    functioncount += 1
+    if (functioncount == functionlimit):
+        errore.overflowerror(functioncalls)
+    else:
+        dictlocalvars = switchtonewcall(allthevars, dictlocalvars, localsvars)
+        vartosend.changeread(True)
+        vartosend.changewrite(True)
+        movetonewconds(allthelocalconds)
+        allthelocalconds = {}
+        output = getvar(typeoutput, nameoutput)
+        outi = function()
+        output.copyvar(outi)
+        endline()
+
+
+def updatelineexitingcall(type, namevaroutput):
+    global allthevars, localsstack, functioncount, allthelocalconds, dictlocalvars, localsvars
+    thevar = getvar(type, namevaroutput)
+    functioncount = functioncount - 1
+    popped = localsstack.pop()
+    ### because i can't remember
+    ### get old "global"
+    returntooldlocals(allthevars, popped)
+    ### get old locals
+    dictlocalvars = returntoolastcall(allthevars)
+    ### get old conds
+    allthelocalconds = backtooldconds()
+    endline()
+    return thevar
+
+localsvars = Stack()  #### the stack for locals created in function
+localsvars.push({"INT": {}, "STR": {}, "LIST": {}})
+localsstack = Stack()  ###### the stack of the program locals
+LOOPINTEGER = VALUE(name="LOOPINTEGER", value=0, readable=True, writable=False, TYPE="INT")
+LOOPSTRING = VALUE(name="LOOPSTRING", value="", readable=True, writable=False, TYPE="STR")
+LOOPBOOL = VALUE(name="LOOPBOOL", value=True, readable=True, writable=False, TYPE="BOOL")
+LOOPLIST = LIST(name="LOOPLIST", size=8, readable=True, writable=False, TYPE="LIST")
+TEMPORARY = VALUE(name="TEMPORARY", value=0, readable=True, writable=True, TYPE="INT")
+LOCALINT = VALUE(name="LOCALINT", value=0, readable=0, writable=0, TYPE="INT")
+loopvars = {"INT": {"LOOPINTEGER": LOOPINTEGER}, "STR": {"LOOPSTRING": LOOPSTRING}, "LIST": {"LOOPLIST": LOOPLIST},
+            "BOOLEAN": {"LOOPBOOL": LOOPBOOL}}
+goodloopvars = {"INT": LOOPINTEGER, "STR": LOOPSTRING, "LIST": LOOPLIST, "BOOLEAN": LOOPBOOL}
+TEMPSTRING = VALUE(name="TEMPSTRING", value="", readable=True, writable=False, TYPE="STR")
+LOCALSTR = VALUE(name="LOCALSTR", value="", readable=0, writable=0, TYPE="STR")
+INTEGER = VALUE(name="INTEGER", value="INT", readable=True, writable=False, TYPE="STR")
+STRING = VALUE(name="STRING", value="STR", readable=True, writable=False, TYPE="STR")
+LISTI = VALUE(name="LIST", value="LIST", readable=True, writable=False, TYPE="STR")
+BOOLEAN = VALUE(name="BOOLEAN", value="BOOLEAN", readable=True, writable=False, TYPE="STR")
+LOCALLIST = LIST(name="LOCALLIST", size=8, readable=0, writable=0, TYPE="LIST")
+THETRUTH = COND('EQUALS')
+THETRUTH.changeleft(TEMPORARY)
+THETRUTH.changeright(TEMPORARY)
+allthevars = {"INT": {"LOOPINTEGER": LOOPINTEGER, "TEMPORARY": TEMPORARY, "LOCALINT": LOCALINT},
+              "STR": {"LOOPSTRING": LOOPSTRING, "TEMPSTRING": TEMPORARY, "LOCALSTR": LOCALSTR, "INTEGER": INTEGER,
+                      "STRING": STRING, "LIST": LISTI, "BOOLEAN": BOOLEAN},
+              "LIST": {"LOOPLIST": LOOPLIST, "LOCALLIST": LOCALLIST}, "BOOLEAN": {"LOOPBOOL": LOOPBOOL}}
+# Number names (ZERO..ONEHUNDRED) are compile-time constants only.
+# They are resolved to plain integer literals by the compiler (toline/word_to_num)
+# and must NOT live in allthevars["INT"] — that would prevent users from naming
+# their own variables ONE, ZERO, etc.
+examplelocalvars = {"INT": {}, "STR": {}, "LIST": {}, "BOOLEAN": {}}
+dictlocalvars = examplelocalvars.copy()
+programlocals = {"INT": {"LOCALINT": allthevars["INT"]["LOCALINT"]}, "STR": {"LOCALSTR": allthevars["STR"]["LOCALSTR"]},
+                 "LIST": {"LOCALLIST": allthevars["LIST"]["LOCALLIST"]}}
+nameofprogramlocals = {"INT": "LOCALINT", "STR": "LOCALSTR", "LIST": "LOCALLIST"}
+stackoflocalconds = Stack()
+localsstack.push(programlocals)
+dictlocalvars = examplelocalvars.copy()
+allthelocalconds = {}
+errore = EERROR()
+alltheconds['THETRUTH'] = THETRUTH

language/topy.py

@@ -0,0 +1,454 @@
+def makeparenthasis(listofvals):
+    stri = "("
+    for i in range(len(listofvals) - 1):
+        stri = stri + " " + str(listofvals[i]) + " " + ","
+    stri = stri + " " + str(listofvals[-1]) + " )"
+    return stri
+
+
+def strreadvalue(type, name):
+    return "getvar" + makeparenthasis([tostri(type), tostri(name)]) + ".read()"
+
+
+lineupdate = "endline() ;"
+infunction = False
+dictoffunct = {i[0]: i for i in [[0]]}
+dictofinstructions = {i: "thetext" for i in dictoffunct}
+listfunctionswithtypes = {i[0]: i for i in [[0]]}
+listfunctionswithtypes["GREATESTDIV"] = ["GREATESTDIV", "LIST", "LIST"]
+for i in listfunctionswithtypes:
+    for j in range(len(listfunctionswithtypes[i])):
+        if (listfunctionswithtypes[i][j] == "BOOL"):
+            listfunctionswithtypes[i][j] = "BOOLEAN"
+
+listofindentchanges = [0 for i in range(1, 1000 + 1)]
+
+
+def getinstructions(listfunctions, listezfunctions):
+    global dictoffunct, listfunctionswithtypes
+    dictoffunct = {i[0]: i for i in listezfunctions}
+    listfunctionswithtypes = {i[0]: i for i in listfunctions}
+
+
+def tostri(value):
+    return "'" + str(value) + "'"
+
+
+def MAKEINTEGER(name, value, linenum):
+    global infunction
+    inparan = makeparenthasis(['"INT"', tostri(name), value])
+    if (infunction):
+        declarestr = "addlocalvar" + inparan
+    else:
+        declarestr = "addvar" + inparan
+    stri = "line(" + str(linenum) + ")" + "; " + declarestr + "; " + lineupdate
+    return stri
+
+
+def MAKESTR(name, value, linenum):
+    global infunction
+    inparan = makeparenthasis(['"STR"', tostri(name), "'" + str(value) + "'"])
+    if (infunction):
+        declarestr = "addlocalvar" + inparan
+    else:
+        declarestr = "addvar" + inparan
+    stri = "line(" + str(linenum) + ")" + "; " + declarestr + "; " + lineupdate
+    return stri
+
+
+def MAKEBOOLEAN(name, value, linenum):
+    global infunction
+    if value == "TRUE":
+        value = "True"
+    elif value == "FALSE":
+        value = "False"
+    inparan = makeparenthasis(['"BOOLEAN"', tostri(name), value])
+    if (infunction):
+        declarestr = "addlocalvar" + inparan
+    else:
+        declarestr = "addvar" + inparan
+    stri = "line(" + str(linenum) + ")" + "; " + declarestr + "; " + lineupdate
+    return stri
+
+
+
+def NEWLIST(name, value, linenum):
+    global infunction
+    # value is already a plain integer string (e.g. '6') resolved at compile time
+    inparan = makeparenthasis(['"LIST"', tostri(name), str(int(value))])
+    if (infunction):
+        declarestr = "addlocalvar" + inparan
+    else:
+        declarestr = "addvar" + inparan
+    stri = "line(" + str(linenum) + ")" + "; " + declarestr + "; " + lineupdate
+    return stri
+
+
+def BASICCONDITION(name, compare, linenum):
+    global infunction
+    if (infunction == False):
+        declarestr = "addcond" + makeparenthasis([tostri(name), tostri(compare)])
+    else:
+        declarestr = "addlocalcond" + makeparenthasis([tostri(name), tostri(compare)])
+
+    stri = "line(" + str(linenum) + ")" + "; " + declarestr + "; " + lineupdate
+    return stri
+
+
+def LEFTSIDE(name, othername, linenum):
+    thegetvar = "getvar" + makeparenthasis(['"INT"', tostri(othername)])
+    stri = "line(" + str(linenum) + ")" + "; " + \
+           "getcond" + makeparenthasis([tostri(name)]) + ".changeleft(" + thegetvar + ")" + "; " + lineupdate
+
+    return (stri)
+
+
+def RIGHTSIDE(name, othername, linenum):
+    thegetvar = "getvar" + makeparenthasis(['"INT"', tostri(othername)])
+    stri = "line(" + str(linenum) + ")" + "; " + \
+           "getcond" + makeparenthasis([tostri(name)]) + ".changeright(" + thegetvar + ")" + "; " + lineupdate
+    return (stri)
+
+
+def CHANGECOMPARE(name, valuecompare, linenum):
+    stri = "line(" + str(linenum) + ")" + "; " + \
+           "getcond" + makeparenthasis([tostri(name)]) + ".changecompare(" + tostri(
+        valuecompare) + ")" + "; " + lineupdate
+    return (stri)
+
+
+def WHILE(compare, endline, linenum):
+    global listofindentchanges
+    lineofwhile = "while" + makeparenthasis(["line(" + str(linenum) + ") and " + (
+            "getcond" + makeparenthasis([tostri(compare)])) + ".giveresult() and endline()"]) + ":"
+    listofindentchanges[linenum + 1] = 1
+    listofindentchanges[int(endline) + 1] = -1
+    return (lineofwhile)
+
+
+def ITERATE(listi, endline, linenum):
+    global listofindentchanges
+    lineofwhile = "for i in join" + makeparenthasis(["getvar('LIST'," + tostri(listi) + ")", str(linenum)]) + ":"
+    listofindentchanges[linenum + 1] = 1
+    listofindentchanges[int(endline) + 1] = -1
+    return lineofwhile
+
+
+def COMPARE(compare, endline, linenum):
+    global listofindentchanges
+    lineofwhile = "if" + makeparenthasis(["line(" + str(linenum) + ") and " + (
+            "getcond" + makeparenthasis([tostri(compare)])) + ".giveresult() and endline()"]) + ":"
+    listofindentchanges[linenum + 1] = 1
+    listofindentchanges[int(endline) + 1] = -1
+    return (lineofwhile)
+
+
+def ELSECOMPARE(compare, endline, linenum):
+    global listofindentchanges
+    lineofwhile = "elif" + makeparenthasis(["line(" + str(linenum) + ") and " + (
+            "getcond" + makeparenthasis([tostri(compare)])) + ".giveresult() and endline()"]) + ":"
+    listofindentchanges[linenum + 1] = 1
+    listofindentchanges[int(endline) + 1] = -1
+    return (lineofwhile)
+
+
+def WHILETRUE(bool, endline, linenum):
+    global listofindentchanges
+    lineofwhile = "while" + makeparenthasis(["line(" + str(linenum) + ") and " + (
+            "getvar('BOOLEAN'," + tostri(bool) + ").read() " + "and endline()")]) + ":"
+    listofindentchanges[linenum + 1] = 1
+    listofindentchanges[int(endline) + 1] = -1
+    return (lineofwhile)
+
+
+def IFTRUE(bool, endline, linenum):
+    global listofindentchanges
+    lineofwhile = "if" + makeparenthasis(["line(" + str(linenum) + ") and " + (
+            "getvar('BOOLEAN'," + tostri(bool) + ").read() " + "and endline()")]) + ":"
+    listofindentchanges[linenum + 1] = 1
+    listofindentchanges[int(endline) + 1] = -1
+    return (lineofwhile)
+
+
+def ELSEIF(bool, endline, linenum):
+    global listofindentchanges
+    lineofwhile = "elif" + makeparenthasis(["line(" + str(linenum) + ") and " + (
+            "getvar('BOOLEAN'," + tostri(bool) + ").read() " + "and endline()")]) + ":"
+    listofindentchanges[linenum + 1] = 1
+    listofindentchanges[int(endline) + 1] = -1
+    return (lineofwhile)
+
+
+def INTEGERFUNCTION(name, type, linenum):
+    global thetype, infunction
+    infunction = True
+    thetype = "INT"
+    listofindentchanges[linenum + 1] = 1
+    return "def " + name + "" + '():'
+
+
+def STRINGFUNCTION(name, type, linenum):
+    global thetype, infunction
+    infunction = True
+    thetype = "STR"
+    listofindentchanges[linenum + 1] = 1
+    return "def " + name + "" + '():'
+
+
+def LISTFUNCTION(name, type, linenum):
+    global thetype, infunction
+    infunction = True
+    thetype = "LIST"
+    listofindentchanges[linenum + 1] = 1
+    return "def " + name + "" + '():'
+
+
+def RETURN(name, stay, linenum):
+    if (stay == "BREAK"):
+        listofindentchanges[linenum + 1] = -1
+        global infunction
+        infunction = False
+    return ("line(" + str(linenum) + "); " + "return(updatelineexitingcall" + makeparenthasis(
+        [tostri(thetype), tostri(name)]) + ")")
+
+
+def PRINTSTRING(name, state, linenum):
+    if (state == "BREAK"):
+        state = "True"
+    else:
+        state = "False"
+    return "line(" + str(linenum) + "); " + "Print(" + "getvar('STR'," + tostri(name) + ")," + state + "); " + "endline()"
+
+
+def PRINTINTEGER(name, state, linenum):
+    if (state == "BREAK"):
+        state = "True"
+    else:
+        state = "False"
+    return "line(" + str(linenum) + "); " + "Print(" + "getvar('INT'," + tostri(
+        name) + ")," + state + "); " + "endline()"
+
+
+def SETINDEX(name, index, linenum):
+    # index is already a plain integer string resolved at compile time
+    return ("line(" + str(linenum) + "); getvar('LIST'," + tostri(name) + ").changeindex(" + str(int(index)) + "); endline()")
+
+
+def GETSTRING(listname, name, linenum):
+    name = tostri(name)
+    listname = tostri(listname)
+    return ("line(" + str(
+        linenum) + ");getvar('STR'," + name + ").copyvar(getvar('LIST'," + listname + ").read()); endline()")
+
+
+def GETINTEGER(listname, name, linenum):
+    name = tostri(name)
+    listname = tostri(listname)
+    return ("line(" + str(
+        linenum) + ");getvar('INT'," + name + ").copyvar(getvar('LIST'," + listname + ").read()); endline()")
+
+
+def GETLIST(listname, name, linenum):
+    name = tostri(name)
+    listname = tostri(listname)
+    return ("line(" + str(
+        linenum) + ");getvar('LIST'," + name + ").copyvar(getvar('LIST'," + listname + ").read()); endline()")
+
+
+def GETBOOL(listname, name, linenum):
+    name = tostri(name)
+    listname = tostri(listname)
+    return ("line(" + str(
+        linenum) + ");getvar('BOOLEAN'," + name + ").copyvar(getvar('LIST'," + listname + ").read()); endline()")
+
+
+def WRITESTRING(listname, name, linenum):
+    name = tostri(name)
+    listname = tostri(listname)
+    return ("line(" + str(linenum) + ");getvar('LIST'," + listname + ") .placevalue(" + name + ',"STR"'"); endline()")
+
+
+def WRITEINTEGER(listname, name, linenum):
+    name = tostri(name)
+    listname = tostri(listname)
+    return ("line(" + str(linenum) + ");getvar('LIST'," + listname + ") .placevalue(" + name + ',"INT"'"); endline()")
+
+
+def WRITEBOOL(listname, name, linenum):
+    name = tostri(name)
+    listname = tostri(listname)
+    return ("line(" + str(
+        linenum) + ");getvar('LIST'," + listname + ") .placevalue(" + name + ',"BOOLEAN"'"); endline()")
+
+
+def WRITELIST(listname, name, linenum):
+    name = tostri(name)
+    listname = tostri(listname)
+    return ("line(" + str(linenum) + ");getvar('LIST'," + listname + ") .placevalue(" + name + ',"LIST"'"); endline()")
+
+
+def GETTYPE(listname, strname, linenum):
+    strname = tostri(strname)
+    listname = tostri(listname)
+    return ("line(" + str(
+        linenum) + ");getvar('STR'," + strname + ").write(getvar('LIST'," + listname + ").returntype()); endline()")
+
+
+def LENGTH(listname, intname, linenum):
+    intname = tostri(intname)
+    listname = tostri(listname)
+    return ("line(" + str(
+        linenum) + ");getvar('INT'," + intname + ").write(getvar('LIST'," + listname + ").getsize()); endline()")
+
+
+def ADDVALUES(vali, vali2, linenum):
+    return ("line(" + str(linenum) + "); " + "add" + makeparenthasis([tostri(vali), tostri(vali2)]) + "; endline()")
+
+
+def MULTIPLY(vali, vali2, linenum):
+    return ("line(" + str(linenum) + "); " + "mult" + makeparenthasis([tostri(vali), tostri(vali2)]) + "; endline()")
+
+
+def MATHPOW(vali, vali2, linenum):
+    return ("line(" + str(linenum) + "); " + "pow" + makeparenthasis([tostri(vali), tostri(vali2)]) + "; endline()")
+
+
+def DIVIDE(vali, vali2, linenum):
+    return ("line(" + str(linenum) + "); " + "betterdiv" + makeparenthasis(
+        [tostri(vali), tostri(vali2)]) + "; endline()")
+
+
+def SIMPLEDIVIDE(vali, vali2, linenum):
+    return ("line(" + str(linenum) + "); " + "div" + makeparenthasis([tostri(vali), tostri(vali2)]) + "; endline()")
+
+
+def SUBTRACT(vali, vali2, linenum):
+    return ("line(" + str(linenum) + "); " + "dec" + makeparenthasis([tostri(vali), tostri(vali2)]) + "; endline()")
+
+
+def MODULO(vali, vali2, linenum):
+    return ("line(" + str(linenum) + "); " + "mod" + makeparenthasis([tostri(vali), tostri(vali2)]) + "; endline()")
+
+
+def COMBINE(vali, vali2, linenum):
+    return ("line(" + str(linenum) + "); " + "comb" + makeparenthasis([tostri(vali), tostri(vali2)]) + "; endline()")
+
+
+def ADDSIZE(vali, vali2, linenum):
+    return ("line(" + str(linenum) + "); " + "addsize" + makeparenthasis([tostri(vali), tostri(vali2)]) + "; endline()")
+
+
+def ASSSIGNINT(vali, vali2, linenum):
+    return ("line(" + str(linenum) + "); " + "assignint" + makeparenthasis(
+        [tostri(vali), tostri(vali2)]) + "; endline()")
+
+
+def STRINGASSIGN(vali, vali2, linenum):
+    return ("line(" + str(linenum) + "); " + "assignstr" + makeparenthasis(
+        [tostri(vali), tostri(vali2)]) + "; endline()")
+
+
+def COPYLIST(vali, vali2, linenum):
+    return ("line(" + str(linenum) + "); " + "assignlist" + makeparenthasis(
+        [tostri(vali), tostri(vali2)]) + "; endline()")
+
+
+def BLANKSPACES(vali, vali2, linenum):
+    return ("line(" + str(linenum) + "); " + "blankspaces" + makeparenthasis([tostri(vali), vali2]) + "; endline()")
+
+
+def TYPETOINT(vali, vali2, linenum):
+    return ("line(" + str(linenum) + "); " + "typetoint" + makeparenthasis(
+        [tostri(vali), tostri(vali2)]) + "; endline()")
+
+
+dictofinstructions["MAKEINTEGER"] = MAKEINTEGER
+dictofinstructions["MAKESTR"] = MAKESTR
+dictofinstructions["MAKEBOOLEAN"] = MAKEBOOLEAN
+dictofinstructions["NEWLIST"] = NEWLIST
+dictofinstructions["BASICCONDITION"] = BASICCONDITION
+dictofinstructions["LEFTSIDE"] = LEFTSIDE
+dictofinstructions["RIGHTSIDE"] = RIGHTSIDE
+dictofinstructions["CHANGECOMPARE"] = CHANGECOMPARE
+dictofinstructions["WHILE"] = WHILE
+dictofinstructions["ITERATE"] = ITERATE
+dictofinstructions["COMPARE"] = COMPARE
+dictofinstructions["ELSECOMPARE"] = ELSECOMPARE
+dictofinstructions["WHILETRUE"] = WHILETRUE
+dictofinstructions["IFTRUE"] = IFTRUE
+dictofinstructions["ELSEIF"] = ELSEIF
+dictofinstructions["SETINDEX"] = SETINDEX
+dictofinstructions["INTEGERFUNCTION"] = INTEGERFUNCTION
+dictofinstructions["STRINGFUNCTION"] = STRINGFUNCTION
+dictofinstructions["LISTFUNCTION"] = LISTFUNCTION
+dictofinstructions["PRINTSTRING"] = PRINTSTRING
+dictofinstructions["PRINTINTEGER"] = PRINTINTEGER
+dictofinstructions["GETSTRING"] = GETSTRING
+dictofinstructions["GETINTEGER"] = GETINTEGER
+dictofinstructions["GETLIST"] = GETLIST
+dictofinstructions["GETBOOL"] = GETBOOL
+dictofinstructions["WRITESTRING"] = WRITESTRING
+dictofinstructions["WRITEINTEGER"] = WRITEINTEGER
+dictofinstructions["WRITEBOOL"] = WRITEBOOL
+dictofinstructions["WRITELIST"] = WRITELIST
+dictofinstructions["GETTYPE"] = GETTYPE
+dictofinstructions["LENGTH"] = LENGTH
+dictofinstructions["ASSSIGNINT"] = ASSSIGNINT
+dictofinstructions["ADDSIZE"] = ADDSIZE
+dictofinstructions["STRINGASSIGN"] = STRINGASSIGN
+dictofinstructions["COPYLIST"] = COPYLIST
+dictofinstructions["ADDVALUES"] = ADDVALUES
+dictofinstructions["MULTIPLY"] = MULTIPLY
+dictofinstructions["MATHPOW"] = MATHPOW
+dictofinstructions["DIVIDE"] = DIVIDE
+dictofinstructions["SIMPLEDIVIDE"] = SIMPLEDIVIDE
+dictofinstructions["SUBTRACT"] = SUBTRACT
+dictofinstructions["MODULO"] = MODULO
+dictofinstructions["COMBINE"] = COMBINE
+dictofinstructions["BLANKSPACES"] = BLANKSPACES
+dictofinstructions["RETURN"] = RETURN
+dictofinstructions["TYPETOINT"] = TYPETOINT
+
+
+
+def makepredict(listi, i):
+    if listi[0] in dictofinstructions:
+        return dictofinstructions[listi[0]](listi[1], listi[2], i)
+    else:
+        listfun = listfunctionswithtypes[listi[0]]
+        return ("updatelinewithcall" + makeparenthasis(
+            [tostri(listfun[1]), tostri(listi[1]), listi[0], tostri(listfun[2]), tostri(listi[2]), i]))
+
+
+def makepyfile(listi):
+    from pathlib import Path
+
+    outfile = Path(__file__).parent / "test.py"
+    with outfile.open("w+", encoding="utf-8") as f:
+        f.write("from Tzefa_Language.createdpython import *\n")
+        counterindent = 0
+        indent = "    "
+        for i in range(1, len(listi) + 1):
+            counterindent += listofindentchanges[i]
+            f.write(indent * counterindent + makepredict(listi[i - 1], i) + '\n')
+        f.write("printvars()")
+
+
+
+
+if __name__ == '__main__':
+    listi = [["MAKEINTEGER", "THEINT", '2769'], ["MAKEINTEGER", "THEINTI", '1065'], ["MAKEINTEGER", "THROWONE", '1065'],
+             ["MAKEINTEGER", "THROWTWO", '1065'], ["NEWLIST", "LISTOFTWO", '2'], ["SETINDEX", "LISTOFTWO", '0'],
+             ["WRITEINTEGER", "LISTOFTWO", 'THEINT'], ["SETINDEX", "LISTOFTWO", '1'],
+             ["WRITEINTEGER", "LISTOFTWO", 'THEINTI'], ["MAKEINTEGER", "ZERO", '0'], ["ADDVALUES", "THEINT", 'THEINTI'],
+             ["PRINTINTEGER", "TEMPORARY", 'BREAK'], ["LISTFUNCTION", "GREATESTDIV", 'LIST'],
+             ["SETINDEX", "LISTOFTWO", '0'], ["GETINTEGER", "LISTOFTWO", 'THROWONE'], ["SETINDEX", "LISTOFTWO", '1'],
+             ["GETINTEGER", "LISTOFTWO", 'THROWTWO'], ["BASICCONDITION", "EUCLIDCOMPARE", 'EQUALS'],
+             ["LEFTSIDE", "EUCLIDCOMPARE", 'THROWTWO'], ["RIGHTSIDE", "EUCLIDCOMPARE", 'ZERO'],
+             ["COMPARE", "EUCLIDCOMPARE", '23'], ["WRITEINTEGER", "LISTOFTWO", 'THROWTWO'],
+             ["RETURN", "LISTOFTWO", "STAY"], ["RIGHTSIDE", "EUCLIDCOMPARE", 'THROWTWO']
+        , ["SETINDEX", "LISTOFTWO", '0'], ["WRITEINTEGER", "LISTOFTWO", 'THROWTWO'], ["MODULO", "THROWONE", 'THROWTWO'],
+             ["SETINDEX", "LISTOFTWO", '1'], ["WRITEINTEGER", "LISTOFTWO", 'TEMPORARY'],
+             ["GREATESTDIV", "LISTOFTWO", 'LISTOFTWO'], ["RETURN", "LISTOFTWO", 'BREAK'],
+             ["GREATESTDIV", "LISTOFTWO", 'LISTOFTWO']]
+    makepyfile(listi)

requirements.txt

@@ -0,0 +1,14 @@
+torch
+torchvision
+transformers
+segmentation-models-pytorch
+albumentations
+ultralytics
+timm
+opencv-python-headless
+pillow
+numpy
+gradio
+huggingface_hub
+fast_edit_distance
+