Update app.py

app.py

@@ -2,55 +2,39 @@ import gradio as gr
 from huggingface_hub import InferenceClient
 import os
 import re
-# import traceback # Optional: for more detailed error logging if needed
 
-# --- Configuration ---
 API_TOKEN = os.getenv("HF_TOKEN", None)
 MODEL = "Qwen/Qwen2.5-Coder-32B-Instruct"
 
-# --- Initialize Inference Client ---
 try:
     print(f"Initializing Inference Client for model: {MODEL}")
     client = InferenceClient(model=MODEL, token=API_TOKEN) if API_TOKEN else InferenceClient(model=MODEL)
 except Exception as e:
     raise gr.Error(f"Failed to initialize model client for {MODEL}. Error: {e}. Check HF_TOKEN and model availability.")
 
-
-# --- Helper Function to Parse Code into Files ---
 def parse_code_into_files(raw_response: str) -> dict:
-    """
-    Parses raw AI output containing .TAB separators
-    into a dictionary where keys are filenames and values are code blocks.
-    Returns keys like 'index.html', 'backend_file', 'backend_filename', 'backend_language'.
-    """
     files = {}
-    # Default filename for the first block if no TAB is present or before the first TAB
     default_first_filename = "index.html"
-    separator_pattern = r'\.TAB\[NAME=([^\]]+)\]\n?' # Capture filename
+    separator_pattern = r'\.TAB\[NAME=([^\]]+)\]\n?'
 
-    # Find all separators and their positions
     matches = list(re.finditer(separator_pattern, raw_response))
 
     start_index = 0
-    # Handle the first file (always assume index.html for now)
     first_separator_pos = matches[0].start() if matches else len(raw_response)
     first_block = raw_response[start_index:first_separator_pos].strip()
     if first_block:
          files[default_first_filename] = first_block
 
-    # Handle the second file (if separator exists)
     if matches:
-        backend_filename = matches[0].group(1).strip() # Get filename from first match
-        start_index = matches[0].end() # Start after the first separator
+        backend_filename = matches[0].group(1).strip()
+        start_index = matches[0].end()
 
-        # Find the position of the *next* separator, or end of string
         second_separator_pos = matches[1].start() if len(matches) > 1 else len(raw_response)
         backend_code = raw_response[start_index:second_separator_pos].strip()
 
         if backend_code:
             files['backend_file'] = backend_code
             files['backend_filename'] = backend_filename
-            # Determine language from filename extension
             if backend_filename.endswith(".py"):
                 files['backend_language'] = 'python'
             elif backend_filename.endswith(".js"):
@@ -58,26 +42,21 @@ def parse_code_into_files(raw_response: str) -> dict:
             elif backend_filename.endswith(".css"):
                  files['backend_language'] = 'css'
             else:
-                 files['backend_language'] = None # Default to plain text
-
-    # If more files were generated (more separators), they are currently ignored by this simple parser.
+                 files['backend_language'] = None
 
     return files
 
-
-# --- Core Code Generation Function ---
 def generate_code(
     prompt: str,
     backend_choice: str,
     max_tokens: int,
     temperature: float,
     top_p: float,
-    progress=gr.Progress(track_ τότε=True) # Add progress tracker
+    progress=gr.Progress(track_tqdm=True)
 ):
     print(f"Generating code for: {prompt[:100]}... | Backend: {backend_choice}")
     progress(0, desc="Initializing Request...")
 
-    # System message remains the same - instructing the AI on format
     system_message = (
          "You are an AI that generates website code. You MUST ONLY output the raw code, without any conversational text like 'Here is the code' or explanations before or after the code blocks. "
          "You MUST NOT wrap the code in markdown fences like ```html, ```python, or ```js. "
@@ -103,7 +82,7 @@ def generate_code(
 
     full_response = ""
     token_count = 0
-    est_total_tokens = max_tokens # Rough estimate for progress
+    est_total_tokens = max_tokens
 
     try:
         progress(0.1, desc="Sending Request to Model...")
@@ -121,22 +100,16 @@ def generate_code(
             if isinstance(token, str):
                 full_response += token
                 token_count += 1
-                # Update progress based on tokens received vs max_tokens
-                # Adjust the scaling factor (e.g., 0.7) as needed
                 prog = min(0.2 + (token_count / est_total_tokens) * 0.7, 0.9)
                 progress(prog, desc="Generating Code...")
 
 
         progress(0.9, desc="Processing Response...")
-        # --- Post-processing ---
         cleaned_response = full_response.strip()
-        # Fallback fence removal
         cleaned_response = re.sub(r"^\s*```[a-z]*\s*\n?", "", cleaned_response)
         cleaned_response = re.sub(r"\n?\s*```\s*$", "", cleaned_response)
-        # Remove potential chat markers
         cleaned_response = re.sub(r"<\s*\|?\s*(user|system|assistant)\s*\|?\s*>", "", cleaned_response, flags=re.IGNORECASE).strip()
-        # Remove common conversational phrases (if they slip through)
-        common_phrases = [ # Simplified list as prompt should handle most
+        common_phrases = [
             "Here is the code:", "Okay, here is the code:", "Here's the code:",
             "Sure, here is the code you requested:",
         ]
@@ -146,14 +119,11 @@ def generate_code(
                 cleaned_response = cleaned_response[len(phrase):].lstrip()
                 temp_response_lower = cleaned_response.lower()
 
-        # Check for refusal message
         refusal_message = "hey there! am here to create websites for you unfortunately am programmed to not create codes! otherwise I would go on the naughty list :-("
         if refusal_message in full_response:
-             # Return updates to clear both code blocks and show refusal in the first
              progress(1, desc="Refusal Message Generated")
-             return gr.update(value=refusal_message, language=None, visible=True), gr.update(value="", visible=False)
+             return gr.update(value=refusal_message, language=None, visible=True), gr.update(value="", visible=False, label="Backend")
 
-        # --- PARSE the final cleaned response into files ---
         parsed_files = parse_code_into_files(cleaned_response)
 
         html_code = parsed_files.get("index.html", "")
@@ -161,35 +131,28 @@ def generate_code(
         backend_filename = parsed_files.get("backend_filename", "Backend")
         backend_language = parsed_files.get("backend_language", None)
 
-        # --- Prepare Gradio Updates ---
-        # Update for the HTML code block (always visible)
         html_update = gr.update(value=html_code, language='html', visible=True)
 
-        # Update for the Backend code block (visible only if backend code exists)
         if backend_code:
             backend_update = gr.update(value=backend_code, language=backend_language, label=backend_filename, visible=True)
         else:
-            backend_update = gr.update(value="", visible=False) # Hide if no backend code
+            backend_update = gr.update(value="", visible=False, label="Backend")
 
         progress(1, desc="Done")
-        # Return tuple of updates for the outputs list
         return html_update, backend_update
 
     except Exception as e:
-        print(f"ERROR during code generation: {e}") # Log detailed error
-        # traceback.print_exc() # Uncomment for full traceback
+        print(f"ERROR during code generation: {e}")
         progress(1, desc="Error Occurred")
         error_message = f"## Error\n\nFailed to generate or process code.\n**Reason:** {e}"
-        # Return updates to show error in the first block and hide the second
-        return gr.update(value=error_message, language=None, visible=True), gr.update(value="", visible=False)
+        return gr.update(value=error_message, language=None, visible=True), gr.update(value="", visible=False, label="Backend")
 
 
-# --- Build Gradio Interface ---
 with gr.Blocks(css=".gradio-container { max-width: 90% !important; }") as demo:
     gr.Markdown("# ✨ Website Code Generator ✨")
     gr.Markdown(
         "Describe the website you want. The AI will generate the necessary code.\n"
-        "If multiple files are generated (e.g., for Flask/Node.js), they will appear in separate tabs below." # Updated description
+        "If multiple files are generated (e.g., for Flask/Node.js), they will appear in separate tabs below."
     )
 
     with gr.Row():
@@ -208,29 +171,24 @@ with gr.Blocks(css=".gradio-container { max-width: 90% !important; }") as demo:
             generate_button = gr.Button("✨ Generate Website Code", variant="primary")
 
         with gr.Column(scale=3):
-            # Define Tabs to hold the code outputs
             with gr.Tabs(elem_id="code-tabs") as code_tabs:
-                # Tab 1: Always present for HTML
                 with gr.Tab("index.html", elem_id="html-tab") as html_tab:
                      html_code_output = gr.Code(
-                         label="index.html", # Label for the code block itself
+                         label="index.html",
                          language="html",
-                         lines=25, # Adjusted lines slightly
+                         lines=25,
                          interactive=False,
-                         elem_id="html_code", # Unique ID for targeting
+                         elem_id="html_code",
                      )
-                # Tab 2: For Backend code, initially hidden
                 with gr.Tab("Backend", elem_id="backend-tab", visible=False) as backend_tab:
                      backend_code_output = gr.Code(
-                         label="Backend Code", # Label will be updated dynamically
-                         language=None, # Language updated dynamically
+                         label="Backend",
+                         language=None,
                          lines=25,
                          interactive=False,
-                         elem_id="backend_code", # Unique ID for targeting
-                         visible=False # Component also starts hidden
+                         elem_id="backend_code",
+                         visible=False
                      )
-                # Add more tabs here if needed (e.g., for CSS) following the same pattern
-
 
     with gr.Accordion("Advanced Settings", open=False):
         max_tokens_slider = gr.Slider(
@@ -243,15 +201,13 @@ with gr.Blocks(css=".gradio-container { max-width: 90% !important; }") as demo:
             minimum=0.1, maximum=1.0, value=0.9, step=0.05, label="Top-P"
         )
 
-    # The click function now targets the specific code blocks within the tabs
     generate_button.click(
         fn=generate_code,
         inputs=[prompt_input, backend_radio, max_tokens_slider, temperature_slider, top_p_slider],
-        # The outputs list MUST match the order and number of code blocks we want to update
         outputs=[html_code_output, backend_code_output],
     )
 
 if __name__ == "__main__":
     if not API_TOKEN:
         print("Warning: HF_TOKEN environment variable not set. Using anonymous access.")
-    demo.queue(max_size=10).launch() # Allow queueing
+    demo.queue(max_size=10).launch()