Update app.py

app.py

@@ -1,15 +1,30 @@
 # app.py
 
-from constants import *
+from typing import Optional, Dict, List, Tuple
+import gradio as gr
+
+from constants import HTML_SYSTEM_PROMPT, AVAILABLE_MODELS, DEMO_LIST
 from hf_client import get_inference_client, tavily_client
 from tavily_search import enhance_query_with_search
-from utils import *
-from search_replace import *
-from web_scraper import *
-from deploy import *
+from utils import (
+    extract_text_from_file,
+    extract_website_content,
+    apply_search_replace_changes,
+    apply_transformers_js_search_replace_changes,
+    history_to_messages,
+    history_to_chatbot_messages,
+    remove_code_block,
+    parse_transformers_js_output,
+    format_transformers_js_output
+)
+from search_replace import SEARCH_START, DIVIDER, REPLACE_END
+from web_scraper import extract_text_from_image
+from deploy import send_to_sandbox, handle_load_project
 
-import gradio as gr
+# Type aliases
+History = List[Tuple[str, str]]
 
+# Core generation function
 def generation_code(
     query: Optional[str],
     image: Optional[gr.Image],
@@ -21,112 +36,112 @@ def generation_code(
     enable_search: bool,
     language: str,
     provider: str
-):
-    # (Exact same logic as in your monolith; omitted here for brevity)
-    # It should handle multimodal input, web scraping, file extraction,
-    # search/replace modifications, and stream responses via HF client.
-    ...
+) -> Tuple[str, History, str, List[Dict[str, str]]]:
+    # Initialize inputs
+    if query is None:
+        query = ''
+    if _history is None:
+        _history = []
+
+    # Prepare system prompt and history
+    system_prompt = _setting.get('system', HTML_SYSTEM_PROMPT)
+    messages = history_to_messages(_history, system_prompt)
+
+    # Append file content if provided
+    if file:
+        file_text = extract_text_from_file(file)
+        if file_text:
+            query += f"\n\n[Reference file content below]\n{file_text[:5000]}"
+
+    # Append website content if provided
+    if website_url:
+        website_text = extract_website_content(website_url)
+        if not website_text.startswith("Error"):
+            query += f"\n\n[Website content below]\n{website_text[:8000]}"
+
+    # Enhance with web search if enabled
+    final_query = enhance_query_with_search(query, enable_search)
+    messages.append({'role': 'user', 'content': final_query})
+
+    # Call HF inference
+    client = get_inference_client(_current_model['id'], provider)
+    completion = client.chat.completions.create(
+        model=_current_model['id'],
+        messages=messages,
+        max_tokens=10000
+    )
+    content = completion.choices[0].message.content
+
+    # Process output based on language and existing content
+    has_existing = bool(_history and _history[-1][1])
+    if language == 'transformers.js':
+        files = parse_transformers_js_output(content)
+        code_str = format_transformers_js_output(files)
+        sandbox_html = send_to_sandbox(files['index.html'])
+    else:
+        clean = remove_code_block(content)
+        if has_existing and not clean.strip().startswith('<!DOCTYPE'):
+            clean = apply_search_replace_changes(_history[-1][1], clean)
+        code_str = clean
+        sandbox_html = send_to_sandbox(clean) if language == 'html' else ''
 
+    # Update history and prepare chatbot messages
+    new_history = _history + [(query, code_str)]
+    chat_msgs = history_to_chatbot_messages(new_history)
+
+    # Return exactly four outputs: code, history state, preview HTML, and chat history
+    return code_str, new_history, sandbox_html, chat_msgs
+
+# Build Gradio UI
 with gr.Blocks(
-    theme=gr.themes.Base(
-        primary_hue="blue",
-        secondary_hue="gray",
-        neutral_hue="gray",
-        font=gr.themes.GoogleFont("Inter"),
-        font_mono=gr.themes.GoogleFont("JetBrains Mono"),
-        text_size=gr.themes.sizes.text_md,
-        spacing_size=gr.themes.sizes.spacing_md,
-        radius_size=gr.themes.sizes.radius_md
-    ),
+    theme=gr.themes.Base(),
     title="AnyCoder - AI Code Generator"
 ) as demo:
-    history = gr.State([])
-    setting = gr.State({"system": HTML_SYSTEM_PROMPT})
+    history_state = gr.State([])
+    setting_state = gr.State({ 'system': HTML_SYSTEM_PROMPT })
     current_model = gr.State(AVAILABLE_MODELS[9])
-    open_panel = gr.State(None)
-    last_login_state = gr.State(None)
 
-    # Sidebar
     with gr.Sidebar():
-        login_button = gr.LoginButton()
-        gr.Markdown("📥 Load Existing Project")
-        load_project_url = gr.Textbox(label="Hugging Face Space URL", placeholder="https://huggingface.co/spaces/username/project", lines=1)
-        load_project_btn = gr.Button("Import Project", variant="secondary", size="sm")
+        gr.LoginButton()
+        load_project_url = gr.Textbox(label="Hugging Face Space URL")
+        load_project_btn = gr.Button("Import Project")
         load_project_status = gr.Markdown(visible=False)
 
-        gr.Markdown("---")
-        input_box = gr.Textbox(label="What would you like to build?", placeholder="Describe your application...", lines=3)
-        language_dropdown = gr.Dropdown(
-            choices=[
-                "html", "python", "c", "cpp", "markdown", "latex", "json",
-                "css", "javascript", "jinja2", "typescript", "yaml", "dockerfile",
-                "shell", "r", "sql", "transformers.js"
-            ],
-            value="html",
-            label="Code Language"
-        )
-        website_url_input = gr.Textbox(label="Website for redesign", placeholder="https://example.com", lines=1)
-        file_input = gr.File(
-            label="Reference file",
-            file_types=[".pdf", ".txt", ".md", ".csv", ".docx", ".jpg", ".png"]
-        )
-        image_input = gr.Image(label="UI design image", visible=False)
-        search_toggle = gr.Checkbox(label="🔍 Web search", value=False)
-        model_dropdown = gr.Dropdown(
-            choices=[m["name"] for m in AVAILABLE_MODELS],
-            value=AVAILABLE_MODELS[9]["name"],
-            label="Model"
-        )
-
-        btn = gr.Button("Generate", variant="primary", size="lg")
-        clear_btn = gr.Button("Clear", variant="secondary", size="sm")
-
-    # Main panel with tabs
+        input_box = gr.Textbox(label="What to build?", lines=3)
+        language_dropdown = gr.Dropdown(choices=["html","python","transformers.js"], value="html")
+        website_input = gr.Textbox(label="Website URL")
+        file_input = gr.File(label="Reference file")
+        image_input = gr.Image(label="Design image")
+        search_toggle = gr.Checkbox(label="Web search")
+        model_dropdown = gr.Dropdown(choices=[m['name'] for m in AVAILABLE_MODELS], value=AVAILABLE_MODELS[9]['name'])
+
+        generate_btn = gr.Button("Generate")
+        clear_btn = gr.Button("Clear")
+
     with gr.Column():
         with gr.Tabs():
             with gr.Tab("Code"):
-                code_output = gr.Code(language="html", lines=25, interactive=True, label="Generated code")
+                code_output = gr.Code(label="Generated code")
             with gr.Tab("Preview"):
-                sandbox = gr.HTML(label="Live preview")
+                preview = gr.HTML(label="Live preview")
             with gr.Tab("History"):
-                history_output = gr.Chatbot(show_label=False, height=400, type="messages")
+                history_output = gr.Chatbot()
 
-    # Event hookups
     load_project_btn.click(
-        fn=lambda url: handle_load_project(url),
+        fn=handle_load_project,
         inputs=[load_project_url],
-        outputs=[load_project_status, code_output, sandbox, load_project_url, history, history_output]
+        outputs=[load_project_status, code_output, preview, load_project_url, history_state, history_output]
     )
 
-    btn.click(
+    generate_btn.click(
         fn=generation_code,
-        inputs=[
-            input_box, image_input, file_input, website_url_input,
-            setting, history, current_model, search_toggle,
-            language_dropdown, gr.State("auto")
-        ],
-        outputs=[code_output, history, sandbox, history_output]
+        inputs=[input_box, image_input, file_input, website_input,
+                setting_state, history_state, current_model,
+                search_toggle, language_dropdown, gr.State('auto')],
+        outputs=[code_output, history_state, preview, history_output]
     )
 
-    clear_btn.click(
-        fn=lambda: ([], [], None, ""),
-        outputs=[history, history_output, file_input, website_url_input]
-    )
-
-    # Preview update
-    code_output.change(
-        fn=lambda code, lang: send_to_sandbox(code) if lang=="html" else "<div>No preview</div>",
-        inputs=[code_output, language_dropdown],
-        outputs=sandbox
-    )
-
-    # Model switch
-    model_dropdown.change(
-        fn=lambda name: (next(m for m in AVAILABLE_MODELS if m["name"]==name),),
-        inputs=model_dropdown,
-        outputs=current_model
-    )
+    clear_btn.click(lambda: ([], [], "", []), outputs=[history_state, history_output, preview, code_output])
 
 if __name__ == "__main__":
-    demo.queue(api_open=False, default_concurrency_limit=20) \
-        .launch(show_api=False, ssr_mode=True, mcp_server=False)
+    demo.queue().launch()