Update app.py

app.py

@@ -1,48 +1,24 @@
 # app.py
-import requests
 import gradio as gr
-
-# Hugging Face Inference API configuration
-HF_API_KEY = "your_huggingface_api_key"  # Replace with your Hugging Face API key
-HF_API_URL = f"https://api-inference.huggingface.co/models/codeparrot/codeparrot-small"
+from groq import Groq
 
 # Groq API configuration
-GROQ_API_KEY = "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"
-GROQ_API_URL = "https://api.groq.com/v1/completions"
-
-# Function to query Hugging Face Inference API
-def query_huggingface(prompt):
-    try:
-        headers = {
-            "Authorization": f"Bearer {HF_API_KEY}",
-            "Content-Type": "application/json"
-        }
-        data = {
-            "inputs": prompt,
-            "parameters": {
-                "max_length": 150  # Limit the length of the generated text
-            }
-        }
-        response = requests.post(HF_API_URL, headers=headers, json=data, timeout=30)  # Add timeout
-        response.raise_for_status()  # Raise an error for bad responses (4xx, 5xx)
-        return response.json()[0]["generated_text"]
-    except Exception as e:
-        return f"Error querying Hugging Face API: {str(e)}"
+GROQ_API_KEY = "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"  # Replace with your Groq API key
+client = Groq(api_key=GROQ_API_KEY)
 
 # Function to query Groq API
 def query_groq(prompt):
     try:
-        headers = {
-            "Authorization": f"Bearer {GROQ_API_KEY}",
-            "Content-Type": "application/json"
-        }
-        data = {
-            "prompt": prompt,
-            "max_tokens": 150
-        }
-        response = requests.post(GROQ_API_URL, headers=headers, json=data, timeout=10)  # Add timeout
-        response.raise_for_status()  # Raise an error for bad responses (4xx, 5xx)
-        return response.json()["choices"][0]["text"]
+        chat_completion = client.chat.completions.create(
+            messages=[
+                {
+                    "role": "user",
+                    "content": prompt,
+                }
+            ],
+            model="llama-3.3-70b-versatile",  # Use the correct model
+        )
+        return chat_completion.choices[0].message.content
     except Exception as e:
         return f"Error querying Groq API: {str(e)}"
 
@@ -52,17 +28,14 @@ def generate_smart_contract(language, requirements):
         # Create a prompt for the model
         prompt = f"Generate a {language} smart contract with the following requirements: {requirements}"
         
-        # Use Hugging Face Inference API to generate code
-        generated_code = query_huggingface(prompt)
+        # Use Groq API to generate code
+        generated_code = query_groq(prompt)
         
-        # Enhance the code using Groq API
-        enhanced_code = query_groq(generated_code)
-        
-        return enhanced_code
+        return generated_code
     except Exception as e:
         return f"Error generating smart contract: {str(e)}"
 
-# Custom CSS for a 3D CGI Figma-like feel
+# Custom CSS for a dark box with green text
 custom_css = """
 body {
     font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif;
@@ -145,6 +118,19 @@ h1 {
 .gradio-container {
     animation: float 4s ease-in-out infinite;
 }
+
+/* Dark box with green text for output */
+.output-box {
+    background: #1e1e1e; /* Dark background */
+    padding: 15px;
+    border-radius: 10px;
+    color: #00ff00; /* Green text */
+    font-family: 'Courier New', Courier, monospace;
+    font-size: 14px;
+    line-height: 1.5;
+    overflow-x: auto;
+    white-space: pre-wrap; /* Preserve formatting */
+}
 """
 
 # Gradio interface for the app
@@ -154,18 +140,26 @@ def generate_contract(language, requirements):
 # Dropdown options for programming languages
 languages = ["Solidity", "Vyper", "Rust", "JavaScript", "Python"]
 
-interface = gr.Interface(
-    fn=generate_contract,
-    inputs=[
-        gr.Dropdown(label="Programming Language", choices=languages, value="Solidity"),  # Dropdown menu
-        gr.Textbox(label="Requirements", placeholder="e.g., ERC20 token with minting functionality")
-    ],
-    outputs=gr.Textbox(label="Generated Smart Contract"),
-    title="Smart Contract Generator",
-    description="Generate smart contracts using AI.",
-    css=custom_css
-)
+# Create a custom layout
+with gr.Blocks(css=custom_css) as demo:
+    gr.Markdown("# Smart Contract Generator")
+    gr.Markdown("Generate smart contracts using AI.")
+    
+    # Output box
+    output_box = gr.HTML(label="Generated Smart Contract", elem_classes="output-box")
+    
+    # Input row
+    with gr.Row(equal_height=True, variant="panel"):
+        language_dropdown = gr.Dropdown(label="Programming Language", choices=languages, value="Solidity")
+        requirements_input = gr.Textbox(label="Requirements", placeholder="e.g., ERC20 token with minting functionality")
+        submit_button = gr.Button("Generate", variant="primary")
+    
+    # Link the function to the inputs and output
+    submit_button.click(
+        generate_contract,
+        inputs=[language_dropdown, requirements_input],
+        outputs=output_box
+    )
 
 # Launch the Gradio app
-if __name__ == "__main__":
-    interface.launch()
+demo.launch()