transpilatron 0.1.0__tar.gz

transpilatron-0.1.0/.env

@@ -0,0 +1 @@
+MISTRAL_API_KEY=WUC14lA58HjkpIH9GGM1tTaSHXIG6dXa

transpilatron-0.1.0/.python-version

@@ -0,0 +1 @@
+3.14

transpilatron-0.1.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: transpilatron
+Version: 0.1.0
+Summary: A tool for transpiling code from python to C using AI agents.
+Author-email: Johnny Konczal <johndrostan@outlook.com>
+Requires-Python: >=3.14
+Requires-Dist: python-dotenv>=1.2.2
+Requires-Dist: smolagents[litellm]>=1.26.0
+Description-Content-Type: text/markdown
+
+# Transpilatron
+
+A tool for transpiling code from python to C using AI agents.
+
+## Usage
+
+```bash
+transpilatron <python_file>
+```
+
+### API Key
+Set the MISTRAL_API_KEY environment variable to use the Mistral API.

transpilatron-0.1.0/README.md

@@ -0,0 +1,12 @@
+# Transpilatron
+
+A tool for transpiling code from python to C using AI agents.
+
+## Usage
+
+```bash
+transpilatron <python_file>
+```
+
+### API Key
+Set the MISTRAL_API_KEY environment variable to use the Mistral API.

transpilatron-0.1.0/build/build/Makefile

@@ -0,0 +1,14 @@
+
+CC = gcc
+CFLAGS = -static -Wall -Wextra
+TARGET = exe/booterthingy
+SRC = main.c
+
+all: $(TARGET)
+
+$(TARGET): $(SRC)
+	mkdir -p $(@D)
+	$(CC) $(CFLAGS) -o $(TARGET) $(SRC)
+
+clean:
+	rm -rf exe

transpilatron-0.1.0/build/build/main.c

@@ -0,0 +1,51 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/mount.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+void mount_fs(const char *source, const char *target, const char *fstype) {
+    if (mount(source, target, fstype, 0, NULL) != 0) {
+        fprintf(stderr, "Failed to mount %s on %s: %s\n", source, target, strerror(errno));
+        exit(EXIT_FAILURE);
+    }
+}
+
+int main() {
+    printf("Hello from booterthingy!\n");
+    printf(
+        "             _             _            _            _            _              _     _      _        _     \n"
+        "        /\\ \     _    /\\ \         /\\ \         /\\ \         _\\ \           /\\ \ /_/\\    /\\ \     /\\_\    \n"
+        "       /  \\ \   /\\_\\ /  \\ \       /  \\ \       /  \\ \____   /\\__ \\          \\ \ \\\ \ \   \\ \\_\   / / /    \n"
+        "      / /\\ \ \_/ / // /\\ \ \     / /\\ \ \     / /\\ \_____\\ / /_ \\_\         /\\ \\_\\\ \ \__/ / /  / / /_    \n"
+        "     / / /\\ \___/ // / /\\ \ \   / / /\\ \ \   / / /\\/___  // / /\\/_/        / /\\/_/ \\ \__ \\/_/  / /___/\\   \n"
+        "    / / /  \\/____// / /  \\ \\_\ / / /  \\ \\_\ / / /   / / // / /            / / /     \\/_/\\__/\\  \\____ \\ \  \n"
+        "   / / /    / / // / /   / / // / /   / / // / /   / / // / /            / / /       _\\/\\__\\ \     / / /  \n"
+        "  / / /    / / // / /   / / // / /   / / // / /   / / // / / ____       / / /       / _/_/\\ \ \   / / /   \n"
+        " / / /    / / // / /___/ / // / /___/ / / \\ \ \__/ / // /_/_/ ___/\\ ___/ / /__     / / /   \\ \ \\ _\\/_/    \n"
+        "/ / /    / / // / /____\\/ // / /____\\/ /   \\ \___\\/ //_______/\\__\\//\\__\\_/___\\   / / /    /_/ //\\_\\      \n"
+        "\\_/     \\/_/ \\/_________/ \\/_________/     \\/_____/ \\_______\\/    \\/_________/   \\/_/     \\_/ \\/_/      \n"
+        "                                                                                                          \n"
+    );
+
+    if (getpid() != 1) {
+        fprintf(stderr, "This script must be run as init (PID 1)\n");
+        exit(EXIT_FAILURE);
+    }
+
+    printf("I need to mount proc, sysfs, and devtmpfs...\n");
+    mkdir("/proc", 0555);
+    mkdir("/sys", 0555);
+    mkdir("/dev", 0755);
+
+    mount_fs("proc", "/proc", "proc");
+    mount_fs("sysfs", "/sys", "sysfs");
+    mount_fs("devtmpfs", "/dev", "devtmpfs");
+
+    printf("Mounting complete, continuing...\n");
+    return 0;
+}

transpilatron-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "transpilatron"
+version = "0.1.0"
+description = "A tool for transpiling code from python to C using AI agents."
+readme = "README.md"
+authors = [
+    { name = "Johnny Konczal", email = "johndrostan@outlook.com" }
+]
+requires-python = ">=3.14"
+dependencies = [
+    "python-dotenv>=1.2.2",
+    "smolagents[litellm]>=1.26.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[dependency-groups]
+dev = [
+    "twine>=6.2.0",
+]
+[project.scripts]
+transpilatron = "transpilatron.agent:main"

transpilatron-0.1.0/src/transpilatron/__init__.py

@@ -0,0 +1 @@
+

transpilatron-0.1.0/src/transpilatron/agent.py

@@ -0,0 +1,71 @@
+from smolagents import LiteLLMModel, CodeAgent, ToolCallingAgent
+from dotenv import load_dotenv
+from .tools import tools
+from .sysprompt import sysprompt
+import sys
+import shutil
+import os
+import subprocess
+from smolagents import LogLevel
+
+load_dotenv()
+
+model = LiteLLMModel(
+    model_id="mistral/mistral-large-latest", api_key=os.getenv("MISTRAL_API_KEY")
+)
+
+agent = CodeAgent(
+    model=model,
+    tools=tools,
+    instructions=sysprompt,
+    verbosity_level=LogLevel.ERROR,
+    max_steps=50,
+)
+
+
+def main():
+    if not os.path.exists("build"):
+        os.makedirs("build")
+    else:
+        shutil.rmtree("build")
+        os.makedirs("build")
+    if len(sys.argv) > 1:
+        print("Transpilating: " + " ".join(sys.argv[1:]))
+        try:
+            agent.run(
+                "Turn the following Python file and all its dependencies into C code: "
+                + " ".join(sys.argv[1:])
+            )
+        except Exception as e:
+            print(f"Warning: Agent run encountered an error: {e}")
+        if os.path.exists("build/exe"):
+            if not os.path.exists("out"):
+                os.makedirs("out")
+            else:
+                shutil.rmtree("out")
+                os.makedirs("out")
+            shutil.copytree("build/exe/", "out/")
+            print("Output: " + os.getcwd() + "/out/")
+        elif os.path.exists("buildfs"):
+            if not os.path.exists("out"):
+                os.makedirs("out")
+            else:
+                shutil.rmtree("out")
+                os.makedirs("out")
+            for item in os.listdir("buildfs"):
+                s = os.path.join("buildfs", item)
+                d = os.path.join("out", item)
+                if os.path.isdir(s):
+                    shutil.copytree(s, d)
+                else:
+                    shutil.copy2(s, d)
+            print("Output (from buildfs): " + os.getcwd() + "/out/")
+        else:
+            print("No output generated. Check if API key is configured correctly.")
+    else:
+        print("Usage: transpilatron <python_file>")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

transpilatron-0.1.0/src/transpilatron/sysprompt.py

@@ -0,0 +1,49 @@
+sysprompt = """
+You are a code transpilation agent. Your task is to convert code from python to C, then use make to write a makefile. Then, run the makefile.
+Always use make to compile and run the code. Output the binary at the exe folder in the build folder.
+NEVER DYNAMICALLY LINK LIBRARIES.
+You may read anywhere in the filesystem, but you may only write to the build directory.
+This is helpful if you need to read a site-packages for imports. Translate anything that you need. 
+CRITICAL: Do not dynamically link libraries. Use static linking only.
+Always use the provided tools. Do not use any other tools.
+...
+SHORTCUTS (use these C equivalents, never transpile the Python source):
+- numpy → CBLAS/LAPACKE (link -lblas -llapack)
+- pandas → use plain C arrays + CSV parsing
+- PIL/Pillow → libpng, libjpeg, stb_image.h
+- requests/urllib3 → libcurl
+- pygame → SDL2
+- matplotlib → Cairo or skip (write raw PPM files)
+- torch/tensorflow → NEVER attempt. Abort with an error.
+- cryptography → OpenSSL
+- sqlalchemy/sqlite → SQLite3 (link -lsqlite3)
+- scipy → GSL (link -lgsl -lgslcblas) or NAG
+- sklearn → manual C with GSL for math operations
+- opencv-python/cv2 → OpenCV C API (link -lopencv_core -lopencv_imgproc -lopencv_highgui)
+- beautifulsoup/lxml → libxml2 or Gumbo HTML parser
+- json → use cJSON (link -lcjson) or JSON-C
+- regex → PCRE2 (link -lpcre2-8)
+- threading/multiprocessing → pthreads (link -lpthread)
+- asyncio → libuv or manual event loop
+- socket/http → libcurl or raw BSD sockets
+- datetime → time.h functions
+- random → stdlib random or custom PRNG
+- hashlib → OpenSSL (link -lcrypto)
+- subprocess → popen or posix_spawn
+- os/pathlib → direct POSIX syscalls
+- enum → manual int constants or C enum
+- heapq → manual binary heap with C arrays
+- bisect → binary search in stdlib
+- pickle → manual serialization or cJSON
+- logging → write to stderr with syslog(3)
+- collections.deque → manual circular buffer in C
+- itertools → manual loops/generators in C
+- functools.lru_cache → manual hash table with TTL
+- typing → skip (C doesn't have runtime typing)
+- copy/deepcopy → manual struct copying in C
+
+CRITICAL: If a dependency has no shortcut and is not pure Python, 
+write a stub that errors at runtime and warn the user.
+CRITICAL: All outputs must live in the exe folder.
+
+"""

transpilatron-0.1.0/src/transpilatron/tools.py

@@ -0,0 +1,168 @@
+from smolagents import tool
+import os
+import requests
+import sys
+import shutil
+
+
+@tool
+def log(text: str) -> str:
+    """Log a message to the console.
+
+    Args:
+        text: The message to log.
+
+    Returns:
+        A confirmation message.
+    """
+    print(f"[AGENT] {text}")
+    return "Message logged."
+
+
+@tool
+def read_file(path: str) -> str:
+    """Read a file.
+
+    Args:
+        path: The path to the file.
+
+    Returns:
+        The content of the file.
+    """
+    print(f"[AGENT] File read: {path}")
+    with open(path, "r") as f:
+        return f.read()
+
+
+@tool
+def read_binary_file(path: str) -> bytes:
+    """Read a binary file.
+
+    Args:
+        path: The path to the file.
+
+    Returns:
+        The content of the file.
+    """
+    print(f"[AGENT] File read: {path}")
+    with open(f"{path}", "rb") as f:
+        return f.read()
+
+
+@tool
+def write_file(path: str, content: str) -> None:
+    """Write a file.
+
+    Args:
+        path: The path to the file inside the build directory.
+        content: The content to write.
+
+    """
+    with open(f"build/{path}", "w") as f:
+        f.write(content)
+    print(f"[AGENT] File written: {path}")
+
+
+@tool
+def write_binary_file(path: str, content: bytes) -> None:
+    """Write a binary file.
+
+    Args:
+        path: The path to the file inside the build directory.
+        content: The content to write.
+    """
+    with open(f"build/{path}", "wb") as f:
+        f.write(content)
+    print(f"[AGENT] File written: {path}")
+
+
+@tool
+def make_directory(path: str) -> None:
+    """Make a directory.
+
+    Args:
+        path: The path to the directory inside the build directory.
+    """
+    os.makedirs(f"build/{path}", exist_ok=True)
+    print(f"[AGENT] Directory made: {path}")
+
+
+
+
+@tool
+def copy_output_to_out() -> str:
+    """Copy contents from build/exe to out directory.
+
+    Returns:
+        Status message.
+    """
+    if os.path.exists("build/build/exe"):
+        if os.path.exists("out"):
+            shutil.rmtree("out")
+        shutil.copytree("build/build/exe/", "out/")
+        return f"Copied to {os.getcwd()}/out/"
+    return "No build/build/exe directory found."
+
+@tool
+def run_makefile() -> None:
+    """Run the makefile."""
+    original_dir = os.getcwd()
+    os.chdir("build/build")
+    try:
+        os.system("make")
+        print("[AGENT] Makefile run.")
+    finally:
+        os.chdir(original_dir)
+        copy_output_to_out()
+
+@tool
+def download_file(url: str, path: str) -> None:
+    """Download a file.
+
+    Args:
+        url: The URL to download from.
+        path: The path to save the file to.
+    """
+
+    response = requests.get(url)
+    with open(f"build/{path}", "wb") as f:
+        f.write(response.content)
+    print(f"[AGENT] File downloaded: {path}")
+
+
+@tool
+def get_interpreter_path() -> str:
+    """Get the path to the Python interpreter.
+
+    Returns:
+        The path to the Python interpreter.
+    """
+    return sys.executable
+
+
+@tool
+def listdir(path: str) -> list[str]:
+    """List the contents of a directory.
+
+    Args:
+        path: The path to the directory.
+
+    Returns:
+        A list of the contents of the directory.
+    """
+    return os.listdir(path)
+
+
+tools = [
+    log,
+    read_file,
+    read_binary_file,
+    write_file,
+    write_binary_file,
+    make_directory,
+    run_makefile,
+    download_file,
+    get_interpreter_path,
+    listdir,
+    copy_output_to_out,
+]

transpilatron-0.1.0/test_transpile.py

@@ -0,0 +1 @@
+print("hello world")