app.py

# SkyCode Version 1.0 - Complete Code  
import gradio as gr  
from fastapi import FastAPI, HTTPException  
from pydantic import BaseModel  
from transformers import AutoModelForCausalLM, AutoTokenizer  
import subprocess  
import requests  
import uvicorn  

# Initialize FastAPI  
app = FastAPI()  

# AI Models  
model = AutoModelForCausalLM.from_pretrained("deepseek-ai/codex-1")  
tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/codex-1")  

# Pydantic Models  
class Prompt(BaseModel):  
    prompt: str  

class Question(BaseModel):  
    code: str  
    question: str  

class BuggyCode(BaseModel):  
    code: str  

# API Endpoints  
@app.post("/text-to-code")  
def text_to_code(prompt: Prompt):  
    inputs = tokenizer(prompt.prompt, return_tensors="pt")  
    outputs = model.generate(inputs["input_ids"], max_length=100)  
    return {"code": tokenizer.decode(outputs[0], skip_special_tokens=True)}  

@app.post("/ask")  
def ask_question(question: Question):  
    # Example: Integrate with Q&A AI  
    return {"answer": "This code calculates the factorial of a number."}  

@app.post("/fix-bugs")  
def fix_bugs(buggy_code: BuggyCode):  
    # Example: Integrate with Bug Fixing AI  
    return {"fixed_code": "def factorial(n):\n    return 1 if n == 0 else n * factorial(n-1)"}  

@app.post("/analyze-code")  
def analyze_code(code: str):  
    # Analyze code for vulnerabilities  
    with open("sandbox/tmp_code.py", "w") as f:  
        f.write(code)  
    result = subprocess.run(["bandit", "-r", "sandbox/tmp_code.py"], capture_output=True)  
    return {"result": result.stdout.decode("utf-8")}  

# Gradio Frontend  
def skycode_interface(prompt):  
    response = requests.post("http://localhost:8000/text-to-code", json={"prompt": prompt})  
    return response.json().get("code")  

def ask_skycode(code, question):  
    response = requests.post("http://localhost:8000/ask", json={"code": code, "question": question})  
    return response.json().get("answer")  

def fix_skycode_bugs(code):  
    response = requests.post("http://localhost:8000/fix-bugs", json={"code": code})  
    return response.json().get("fixed_code")  

def analyze_skycode(code):  
    response = requests.post("http://localhost:8000/analyze-code", json={"code": code})  
    return response.json().get("result")  

with gr.Blocks() as demo:  
    gr.Markdown("# SkyCode: AI-Powered Software Engineering Tool")  
    with gr.Tab("Text to Code"):  
        prompt = gr.Textbox(label="Enter your prompt", placeholder="Create a Python function to calculate factorial.")  
        code_output = gr.Textbox(label="Generated Code", interactive=False)  
        gr.Button("Generate Code").click(skycode_interface, inputs=prompt, outputs=code_output)  
    with gr.Tab("Ask SkyCode"):  
        code_input = gr.Textbox(label="Paste your code", placeholder="def factorial(n):...")  
        question_input = gr.Textbox(label="Ask a question", placeholder="What does this code do?")  
        answer_output = gr.Textbox(label="Answer", interactive=False)  
        gr.Button("Ask").click(ask_skycode, inputs=[code_input, question_input], outputs=answer_output)  
    with gr.Tab("Fix Bugs"):  
        buggy_code = gr.Textbox(label="Paste your buggy code", placeholder="def factorial(n):...")  
        fixed_code = gr.Textbox(label="Fixed Code", interactive=False)  
        gr.Button("Fix Bugs").click(fix_skycode_bugs, inputs=buggy_code, outputs=fixed_code)  
    with gr.Tab("Analyze Code"):  
        code_to_analyze = gr.Textbox(label="Paste your code", placeholder="def factorial(n):...")  
        analysis_output = gr.Textbox(label="Analysis Result", interactive=False)  
        gr.Button("Analyze").click(analyze_skycode, inputs=code_to_analyze, outputs=analysis_output)  

# Run the App  
if __name__ == "__main__":  
    # Start the backend server  
    uvicorn.run(app, host="0.0.0.0", port=8000)  
    # Start the frontend interface  
    demo.launch()