PsycheC

Dockerfile

@@ -1,12 +1,18 @@
-# read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
-# you will also find guides on how best to write your Dockerfile
+# Build on top of the psychec type inference Docker image
+FROM ghcr.io/edmcman/psychec-typeinference-docker:original
 
-FROM python:3.12
+# Install Python and pip
+RUN apt-get update && apt-get install -y \
+    python3 \
+    python3-pip \
+    python3-venv \
+    && rm -rf /var/lib/apt/lists/*
 
-WORKDIR /code
+# Create a virtual environment and install dependencies
+RUN python3 -m venv /opt/venv
+ENV PATH="/opt/venv/bin:$PATH"
 
 COPY ./requirements.txt /code/requirements.txt
-
 RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
 
 # Set up a new user named "user" with user ID 1000
@@ -17,7 +23,7 @@ USER user
 
 # Set home to the user's home directory
 ENV HOME=/home/user \
-    PATH=/home/user/.local/bin:$PATH
+    PATH=/home/user/.local/bin:/opt/venv/bin:$PATH
 
 # Set the working directory to the user's home directory
 WORKDIR $HOME/app
@@ -28,4 +34,7 @@ COPY --chown=user . $HOME/app
 # Disable buffering to allow logging of standard output.
 ENV PYTHONUNBUFFERED=1
 
+# Expose the port Gradio runs on
+EXPOSE 7860
+
 CMD ["python", "main.py"]

README.md

@@ -1,11 +1,43 @@
 ---
-title: Demo Docker Gradio
-emoji: 📈
-colorFrom: indigo
-colorTo: indigo
+title: PsycheC Type Inference
+emoji: 🔍
+colorFrom: blue
+colorTo: purple
 sdk: docker
 pinned: false
-license: apache-2.0
+license: lgpl-2.1
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# PsycheC Type Inference
+
+This Space provides a web interface to [PsycheC](https://github.com/ltcmelo/psychec), a compiler frontend for the C programming language that can infer missing type declarations.
+
+## What it does
+
+PsycheC analyzes C source code and:
+- Infers types for undeclared identifiers
+- Generates a header file (`_gen.h`) with the inferred type declarations
+- Produces a fixed C file (`_fixed.c`) that includes the generated header
+
+## Usage
+
+1. Paste your C code in the input text area
+2. Click "Run Type Inference"
+3. View the generated header and fixed C code in the output tabs
+
+## Example
+
+Input:
+```c
+int main() {
+    x = 10;
+    y = foo(x);
+    return y;
+}
+```
+
+The tool will infer the types of `x`, `y`, and `foo` and generate appropriate declarations.
+
+## Credits
+
+Based on [psychec-typeinference-docker](https://github.com/edmcman/psychec-typeinference-docker), a Docker image wrapper for the PsycheC type inference functionality.

main.py

@@ -1,33 +1,92 @@
 import gradio as gr
-import torch
-import requests
-from torchvision import transforms
-import frontmatter
+import subprocess
+import tempfile
+import os
+from pathlib import Path
 
-description = frontmatter.load("README.md").content
-model = torch.hub.load("pytorch/vision:v0.6.0", "resnet18", pretrained=True).eval()
-response = requests.get("https://git.io/JJkYN")
-labels = response.text.split("\n")
+EXAMPLE_CODE = """int main() {
+    x = 10;
+    y = foo(x);
+    return y;
+}"""
 
+def run_psychec(c_code: str) -> tuple[str, str, str]:
+    """Run PsycheC type inference on the provided C code."""
+    if not c_code.strip():
+        return "Please provide some C code.", "", ""
+    
+    with tempfile.TemporaryDirectory() as tmpdir:
+        input_file = Path(tmpdir) / "input.c"
+        input_file.write_text(c_code)
+        
+        try:
+            result = subprocess.run(
+                ["python3", "/workspace/psychec/reconstruct.py", str(input_file)],
+                capture_output=True,
+                text=True,
+                timeout=30,
+                cwd="/workspace/psychec"
+            )
+            
+            gen_header = Path(tmpdir) / "input_gen.h"
+            fixed_c = Path(tmpdir) / "input_fixed.c"
+            
+            header_content = gen_header.read_text() if gen_header.exists() else "No header generated"
+            fixed_content = fixed_c.read_text() if fixed_c.exists() else "No fixed file generated"
+            
+            log_output = result.stdout + ("\n" + result.stderr if result.stderr else "")
+            if not log_output.strip():
+                log_output = "Type inference completed successfully." if result.returncode == 0 else "Type inference failed."
+            
+            return log_output, header_content, fixed_content
+            
+        except subprocess.TimeoutExpired:
+            return "Error: Type inference timed out after 30 seconds.", "", ""
+        except Exception as e:
+            return f"Error: {e}", "", ""
 
-def predict(inp):
-    inp = transforms.ToTensor()(inp).unsqueeze(0)
-    with torch.no_grad():
-        prediction = torch.nn.functional.softmax(model(inp)[0], dim=0)
-        confidences = {labels[i]: float(prediction[i]) for i in range(1000)}
-    return confidences
-
-
-def run():
-    demo = gr.Interface(
-        fn=predict,
-        inputs=gr.Image(type="pil"),
-        outputs=gr.Label(num_top_classes=3),
-        description=description
-    )
-
-    demo.launch(server_name="0.0.0.0", server_port=7860)
-
+def create_demo():
+    with gr.Blocks(title="PsycheC Type Inference") as demo:
+        gr.Markdown("# 🔍 PsycheC Type Inference")
+        gr.Markdown(
+            "Analyze C code and infer missing type declarations. "
+            "PsycheC will generate a header file with inferred types and a fixed C file."
+        )
+        
+        with gr.Row():
+            with gr.Column():
+                code_input = gr.Code(
+                    label="C Source Code",
+                    language="c",
+                    value=EXAMPLE_CODE,
+                    lines=15
+                )
+                run_btn = gr.Button("Run Type Inference", variant="primary")
+            
+            with gr.Column():
+                with gr.Tabs():
+                    with gr.Tab("Log"):
+                        log_output = gr.Textbox(label="Output Log", lines=10)
+                    with gr.Tab("Generated Header"):
+                        header_output = gr.Code(label="Generated Header (_gen.h)", language="c", lines=10)
+                    with gr.Tab("Fixed C File"):
+                        fixed_output = gr.Code(label="Fixed C File (_fixed.c)", language="c", lines=10)
+        
+        run_btn.click(
+            fn=run_psychec,
+            inputs=[code_input],
+            outputs=[log_output, header_output, fixed_output]
+        )
+        
+        gr.Markdown(
+            "---\n"
+            "Based on [PsycheC](https://github.com/ltcmelo/psychec) - "
+            "A compiler frontend for C with type inference capabilities.\n\n"
+            "Docker image: [psychec-typeinference-docker](https://github.com/edmcman/psychec-typeinference-docker)"
+        )
+    
+    return demo
 
 if __name__ == "__main__":
-    run()
+    demo = create_demo()
+    demo.launch(server_name="0.0.0.0", server_port=7860)

requirements.txt

@@ -1,5 +1 @@
-gradio
-torch
-torchvision
-requests
-python-frontmatter
+gradio