Update app.py

app.py

@@ -1,60 +1,154 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+import gc
 
-# Initialize the Qwen client
-client = InferenceClient("Qwen/Qwen2.5-Coder")
+# Initialize model and tokenizer globally
+def load_model():
+    model_name = "Qwen/Qwen2.5-Coder-32B-Instruct"
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+        model = AutoModelForCausalLM.from_pretrained(
+            model_name,
+            device_map="auto",
+            trust_remote_code=True,
+            torch_dtype=torch.float16
+        )
+        return model, tokenizer
+    except Exception as e:
+        print(f"Error loading model: {str(e)}")
+        return None, None
+
+model, tokenizer = load_model()
 
 def generate_code(prompt):
-    messages = [
-        {"role": "system", "content": "You are an expert Python developer who creates clean, efficient code."},
-        {"role": "user", "content": f"Create a Python tool for the following requirement: {prompt}"}
-    ]
-    
-    response = client.text_generation(
-        messages,
-        max_new_tokens=1024,
-        temperature=0.7,
-        top_p=0.9,
-        repetition_penalty=1.1
-    )
-    
-    return response["generated_text"]
+    try:
+        # Clear CUDA cache
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            gc.collect()
+        
+        # Prepare the prompt
+        messages = [
+            {"role": "system", "content": "You are an expert Python developer. Generate clean, efficient, and well-commented code based on the user's requirements."},
+            {"role": "user", "content": f"Create a Python tool for the following requirement: {prompt}"}
+        ]
+        
+        # Format the messages using the chat template
+        text = tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True
+        )
+        
+        # Generate the response
+        model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
+        generated_ids = model.generate(
+            **model_inputs,
+            max_new_tokens=1024,
+            temperature=0.7,
+            top_p=0.9,
+            repetition_penalty=1.1,
+            do_sample=True
+        )
+        
+        # Decode the response
+        response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
+        
+        # Extract only the code part from the response
+        code_start = response.find("```python")
+        code_end = response.find("```", code_start + 8)
+        
+        if code_start != -1 and code_end != -1:
+            code = response[code_start + 8:code_end].strip()
+        else:
+            code = response
+            
+        return code
+        
+    except Exception as e:
+        raise gr.Error(f"Code generation failed: {str(e)}")
+    finally:
+        # Clear memory
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            gc.collect()
 
 # Create the Gradio interface
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="purple")) as demo:
-    gr.Markdown("# 🛠️ AI Tool Builder by Syncmerce")
-    gr.Markdown("Enter your tool requirements and get production-ready Python code!")
+    gr.Markdown(
+        """
+        # 🛠️ AI Tool Builder by Syncmerce
+        
+        Generate production-ready Python code for your tools using AI. Simply describe what you want to build!
+        """
+    )
     
     with gr.Row():
-        with gr.Column():
+        with gr.Column(scale=1):
             prompt_input = gr.Textbox(
                 label="Tool Requirements",
-                placeholder="Describe the tool you want to build...",
+                placeholder="Describe the tool you want to build... Be specific about features and functionality.",
                 lines=4
             )
-            generate_btn = gr.Button("Generate Tool", variant="primary")
+            with gr.Row():
+                generate_btn = gr.Button("🔨 Generate Tool", variant="primary")
+                clear_btn = gr.Button("🗑️ Clear")
         
-        with gr.Column():
+        with gr.Column(scale=1):
             code_output = gr.Code(
                 label="Generated Code",
                 language="python",
-                lines=20
+                lines=25,
+                show_label=True
             )
     
+    # Add examples
+    gr.Examples(
+        examples=[
+            ["Create a PDF text extractor that can process multiple files and save the extracted text to a txt file"],
+            ["Build a web scraper that extracts product prices from Amazon and saves results to CSV"],
+            ["Create an image processing tool that can resize multiple images and add watermarks"],
+            ["Build a YouTube video downloader with progress bar and quality selection"],
+        ],
+        inputs=prompt_input,
+        outputs=code_output,
+        fn=generate_code,
+        cache_examples=True,
+    )
+    
+    # Add event handlers
     generate_btn.click(
         fn=generate_code,
         inputs=prompt_input,
-        outputs=code_output
+        outputs=code_output,
+        api_name="generate"
     )
     
-    gr.Markdown("### Examples:")
-    gr.Examples(
-        [
-            ["Create a PDF text extractor tool that can process multiple files"],
-            ["Build a web scraper that extracts product prices from e-commerce sites"],
-            ["Make a tool for batch image resizing with a progress bar"]
-        ],
-        inputs=prompt_input
+    clear_btn.click(
+        fn=lambda: (None, None),
+        inputs=None,
+        outputs=[prompt_input, code_output],
+        api_name="clear"
+    )
+    
+    # Add footer
+    gr.Markdown(
+        """
+        ### Tips for better results:
+        - Be specific about the features you want
+        - Mention input/output formats
+        - Specify any special requirements or libraries
+        
+        *Note: Generated code may need minor adjustments based on your specific use case.*
+        """
     )
 
-demo.launch()
+# Launch the app
+demo.launch(
+    share=True,
+    enable_queue=True,
+    show_error=True,
+    server_name="0.0.0.0",
+    server_port=7860
+)