app.py

"""
Python to JavaScript Translator using Fireworks AI (Kimi K2-0905)
Single-file Gradio app for code translation with editable output and notes.
"""

import gradio as gr
import json
import requests
from typing import Optional, Tuple, Union
from pydantic import BaseModel, ValidationError
import tempfile
import os

# Configurable constants - adjust these if needed
BASE_URL = "https://api.fireworks.ai/inference/v1"  # Fireworks OpenAI-compatible endpoint
MODEL_ID = "accounts/fireworks/models/kimi-k2-instruct-0905"  # Kimi K2 model on Fireworks
MAX_INPUT_CHARS = 20000  # Character limit for input code

class TranslationResponse(BaseModel):
    """Validated response schema from the model"""
    js_code: str
    notes: str

def create_system_prompt() -> str:
    """Create the system prompt for strict JSON output"""
    return """You are a precise code translator. Task: translate Python → modern JavaScript.
Requirements:
- Output STRICT JSON with keys: "js_code" (string), "notes" (string).
- No prose outside JSON. Do not wrap in markdown. Do not include triple backticks.
- Be faithful to logic. Avoid hallucinated imports. Use idiomatic JS.
- Prefer ES modules, async/await where appropriate, and clear error handling.
- If Python uses libraries without direct JS equivalent, stub or suggest closest widely used package and explain in notes.
- If behavior is ambiguous, call it out in notes.
- Include in "notes": any assumptions, required packages, runtime constraints (Node/browser), performance/security concerns, differences in exceptions, I/O, concurrency, numeric precision, date/time, types, and mutability."""

def create_user_prompt(python_code: str) -> str:
    """Create the user prompt with the Python code to translate"""
    return f"""Translate this Python code to JavaScript.

Source Python:
{python_code}

Context for translator:
- Target runtime: Node.js LTS or browser-friendly (choose best; specify in notes).
- Preserve functionality and public API shape where possible.
- Replace Pythonic constructs (list comps, generators, context managers) with idiomatic JS.
- For file I/O, network calls, async behavior, propose suitable JS equivalents.
- For type clarity, add minimal JSDoc comments where helpful (no TypeScript).
- If the input is a script with a __main__ guard, structure JS with a main() and an IIFE or top-level await.
- Return ONLY JSON with "js_code" and "notes"."""

def call_fireworks_api(api_key: str, python_code: str, retry_on_invalid_json: bool = True) -> Union[TranslationResponse, str]:
    """
    Call Fireworks AI API for translation
    Returns either TranslationResponse or error string
    """
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": MODEL_ID,
        "messages": [
            {"role": "system", "content": create_system_prompt()},
            {"role": "user", "content": create_user_prompt(python_code)}
        ],
        "temperature": 0.2,
        "top_p": 0.9,
        "max_tokens": 4000
    }
    
    try:
        response = requests.post(
            f"{BASE_URL}/chat/completions",
            headers=headers,
            json=payload,
            timeout=30
        )
        
        if response.status_code != 200:
            return f"API Error: {response.status_code} - {response.text[:200]}"
        
        result = response.json()
        content = result.get("choices", [{}])[0].get("message", {}).get("content", "")
        
        # Try to parse as JSON
        try:
            # Clean up common issues
            content = content.strip()
            if content.startswith("```json"):
                content = content[7:]
            if content.startswith("```"):
                content = content[3:]
            if content.endswith("```"):
                content = content[:-3]
            content = content.strip()
            
            parsed = json.loads(content)
            return TranslationResponse(**parsed)
            
        except (json.JSONDecodeError, ValidationError) as e:
            if retry_on_invalid_json:
                # Retry with stricter prompt
                payload["messages"].append({
                    "role": "assistant", 
                    "content": content
                })
                payload["messages"].append({
                    "role": "user",
                    "content": "Your response was not valid JSON. Please respond with ONLY valid JSON containing 'js_code' and 'notes' fields. No markdown, no backticks, just raw JSON."
                })
                return call_fireworks_api(api_key, python_code, retry_on_invalid_json=False)
            else:
                return f"Failed to parse model response as JSON. Raw response:\n\n{content}"
                
    except requests.exceptions.Timeout:
        return "Request timed out. Please try again."
    except requests.exceptions.RequestException as e:
        return f"Network error: {str(e)}"
    except Exception as e:
        return f"Unexpected error: {str(e)}"

def translate(
    api_key: str,
    python_text: str,
    file_upload,
    want_notes: bool
) -> Tuple[str, str, gr.update]:
    """
    Main translation function
    Returns: (js_code, notes_markdown, status_message)
    """
    # Validate API key
    if not api_key or not api_key.strip():
        return "", "❌ **Error:** Please provide your Fireworks API key", gr.update(value="Missing API key", visible=True)
    
    # Determine input source
    python_code = ""
    status_msg = ""
    
    if file_upload is not None:
        try:
            with open(file_upload.name, 'r', encoding='utf-8') as f:
                python_code = f.read()
            status_msg = "Using uploaded file"
        except Exception as e:
            return "", f"❌ **Error reading file:** {str(e)}", gr.update(value="File read error", visible=True)
    elif python_text and python_text.strip():
        python_code = python_text
        status_msg = "Using pasted code"
    else:
        return "", "❌ **Error:** Please provide Python code either by pasting or uploading a file", gr.update(value="No input provided", visible=True)
    
    # Check input size
    if len(python_code) > MAX_INPUT_CHARS:
        truncated = python_code[:MAX_INPUT_CHARS]
        warning = f"⚠️ **Warning:** Input truncated from {len(python_code)} to {MAX_INPUT_CHARS} characters\n\n"
        python_code = truncated
    else:
        warning = ""
    
    # Show character count
    char_count = f"Input: {len(python_code)} characters"
    
    # Call API
    result = call_fireworks_api(api_key.strip(), python_code)
    
    if isinstance(result, str):
        # Error occurred
        return "", f"{warning}❌ **Translation Error:**\n\n{result}", gr.update(value=f"Error: {result[:50]}...", visible=True)
    
    # Success
    js_code = result.js_code
    notes = result.notes if want_notes else ""
    
    notes_display = f"{warning}## 📋 Translation Notes\n\n{notes}" if notes else f"{warning}*Notes disabled*"
    
    return js_code, notes_display, gr.update(value=f"✅ Translation successful | {char_count}", visible=True)

def download_js(js_code: str) -> Tuple[str, bytes]:
    """
    Create downloadable JS file
    Returns: (filename, content_bytes)
    """
    if not js_code:
        return None
    
    # Create temporary file
    with tempfile.NamedTemporaryFile(mode='w', suffix='.js', delete=False, encoding='utf-8') as f:
        f.write(js_code)
        temp_path = f.name
    
    return temp_path

# Example snippets
EXAMPLE_SNIPPETS = {
    "Simple Function": '''def greet(name):
    """Greet a person with their name."""
    return f"Hello, {name}!"

if __name__ == "__main__":
    print(greet("World"))''',
    
    "File I/O": '''import json

def read_config(filepath):
    """Read configuration from JSON file."""
    with open(filepath, 'r') as f:
        config = json.load(f)
    return config

def save_results(data, output_file):
    """Save results to JSON file."""
    with open(output_file, 'w') as f:
        json.dump(data, f, indent=2)
    print(f"Results saved to {output_file}")''',
    
    "Class with Inheritance": '''class Animal:
    def __init__(self, name, species):
        self.name = name
        self.species = species
    
    def make_sound(self):
        return "Some generic sound"
    
    def info(self):
        return f"{self.name} is a {self.species}"

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name, "Canine")
        self.breed = breed
    
    def make_sound(self):
        return "Woof!"
    
    def fetch(self, item):
        return f"{self.name} fetched the {item}!"'''
}

def load_example(example_name: str) -> str:
    """Load an example snippet"""
    return EXAMPLE_SNIPPETS.get(example_name, "")

# Build Gradio interface
with gr.Blocks(title="Python → JavaScript Translator", theme=gr.themes.Soft()) as app:
    gr.Markdown(
        """
        # 🐍→📜 Python → JavaScript Translator
        ### Powered by Kimi K2-0905 on Fireworks AI
        
        Translate Python code to modern, idiomatic JavaScript with detailed migration notes.
        """
    )
    
    # Row 1: API Key
    with gr.Row():
        api_key_box = gr.Textbox(
            label="🔑 Fireworks API Key",
            placeholder="fw-...",
            type="password",
            scale=3,
            info="Your key is used only for this session"
        )
    
    # Row 2: Main content
    with gr.Row():
        # Left column: Input
        with gr.Column(scale=1):
            gr.Markdown("### 📥 Input")
            
            # Example dropdown
            example_dropdown = gr.Dropdown(
                choices=list(EXAMPLE_SNIPPETS.keys()),
                label="Load Example",
                value=None,
                interactive=True
            )
            
            python_text = gr.Code(
                label="Python Code",
                language="python",
                lines=15,
                interactive=True
            )
            
            file_upload = gr.File(
                label="Or upload a .py file",
                file_types=[".py"],
                type="filepath"
            )
            
            want_notes = gr.Checkbox(
                label="Return step-by-step notes & caveats",
                value=True
            )
            
            translate_btn = gr.Button(
                "🚀 Translate to JavaScript",
                variant="primary",
                size="lg"
            )
        
        # Right column: Output
        with gr.Column(scale=1):
            gr.Markdown("### 📤 Output")
            
            with gr.Tabs():
                with gr.Tab("JavaScript (editable)"):
                    js_output = gr.Code(
                        label="Generated JavaScript",
                        language="javascript",
                        lines=15,
                        interactive=True
                    )
 
                
                with gr.Tab("Considerations & Notes"):
                    notes_output = gr.Markdown(
                        value="*Translation notes will appear here*"
                    )
    
    # Status message (initially hidden)
    status_msg = gr.Textbox(
        label="Status",
        visible=False,
        interactive=False
    )
    
    # Footer
    gr.Markdown(
        """
        ---
        ⚠️ **Important:** Always review and test generated code. This tool provides a starting point for migration but may require manual adjustments for complex scenarios.
        
        📝 **Tips:**
        - The model excels at translating algorithmic logic and data structures
        - For library-specific code, check the notes for recommended JS equivalents
        - Generated code targets modern ES6+ JavaScript
        """
    )
    
    # Wire up interactions
    example_dropdown.change(
        fn=load_example,
        inputs=[example_dropdown],
        outputs=[python_text]
    )
    
    translate_btn.click(
        fn=translate,
        inputs=[api_key_box, python_text, file_upload, want_notes],
        outputs=[js_output, notes_output, status_msg]
    )
    

if __name__ == "__main__":
    app.launch(
        share=False,
        server_name="0.0.0.0",
        server_port=7860,
        show_error=True
    )