Update app.py

app.py

@@ -1,33 +1,75 @@
 import os
 import streamlit as st
 from groq import Groq
+from streamlit_tags import st_tags
 
 # Configuration
 PRIMARY_MODEL = "qwen-2.5-coder-32b"
 BACKUP_MODEL = "llama3-70b-8192"
+LANGUAGES = ["Python", "JavaScript", "Java", "C++", "Go", "Rust", "TypeScript", "Swift"]
+THEMES = ["Neon", "Cyberpunk", "Solarized", "Dracula", "Monokai"]
 
 # Streamlit UI Config
 st.set_page_config(
-    page_title="AI Code Generator",
-    page_icon="🚀",
+    page_title="✨ AI Code Generator Pro",
+    page_icon="✨",
     layout="wide",
     initial_sidebar_state="expanded"
 )
 
-# Custom CSS for Enhanced UI
-def inject_custom_css():
-    st.markdown("""
+# Custom CSS for Modern Theme
+def inject_custom_css(theme="Neon"):
+    theme_colors = {
+        "Neon": {"primary": "#4fffb0", "secondary": "#ff4fd8", "bg": "#1a1a2e"},
+        "Cyberpunk": {"primary": "#ff2a6d", "secondary": "#05d9e8", "bg": "#1a1a2e"},
+        "Solarized": {"primary": "#268bd2", "secondary": "#d33682", "bg": "#fdf6e3"},
+        "Dracula": {"primary": "#bd93f9", "secondary": "#ff79c6", "bg": "#282a36"},
+        "Monokai": {"primary": "#a6e22e", "secondary": "#fd971f", "bg": "#272822"}
+    }
+    colors = theme_colors.get(theme, theme_colors["Neon"])
+    
+    st.markdown(f"""
     <style>
-        .main { background: linear-gradient(135deg, #0f0f0f 0%, #1a1a2e 100%); color: #fff; }
-        .stTextInput input { color: #4fffb0 !important; background: rgba(0,0,0,0.3) !important; }
-        .stButton>button { background: #4fffb0 !important; border: 2px solid #00ffcc !important; color: black; }
-        .code-box { border: 2px solid #4fffb0; border-radius: 10px; padding: 1rem; background: rgba(0,0,0,0.5); color: #fff; }
-        .stSelectbox div { background: rgba(0,0,0,0.3) !important; color: #4fffb0 !important; }
+        .main {{
+            background: linear-gradient(135deg, {colors['bg']} 0%, #16213e 100%) !important;
+            color: white !important;
+        }}
+        .stTextInput input, .stSelectbox select, .stTextArea textarea {{
+            color: {colors['primary']} !important;
+            background: rgba(0,0,0,0.3) !important;
+            border-radius: 10px !important;
+        }}
+        .stButton>button {{
+            background: rgba(79,255,176,0.2) !important;
+            border: 2px solid {colors['primary']} !important;
+            color: {colors['primary']} !important;
+            border-radius: 10px !important;
+            transition: all 0.3s !important;
+        }}
+        .stButton>button:hover {{
+            background: rgba(79,255,176,0.4) !important;
+            transform: scale(1.05);
+        }}
+        .code-block {{
+            border: 2px solid {colors['secondary']};
+            border-radius: 15px;
+            padding: 1rem;
+            background: rgba(0,0,0,0.5);
+            margin-bottom: 1rem;
+        }}
+        .sidebar .sidebar-content {{
+            background: rgba(0,0,0,0.3) !important;
+        }}
+        h1, h2, h3 {{
+            color: {colors['primary']} !important;
+        }}
+        .st-expander {{
+            background: rgba(0,0,0,0.3) !important;
+            border: 1px solid {colors['secondary']} !important;
+        }}
     </style>
     """, unsafe_allow_html=True)
 
-inject_custom_css()
-
 # Initialize Groq Client
 def get_groq_client():
     api_key = os.getenv("GROQ_API_KEY")
@@ -37,15 +79,21 @@ def get_groq_client():
     return Groq(api_key=api_key)
 
 # Code Generation Functions
-def generate_code(query, language, model, client):
+def generate_code(query, language, model, client, complexity="Medium"):
+    complexity_levels = {
+        "Basic": "Generate simple code for",
+        "Medium": "Generate well-structured code with comments for",
+        "Advanced": "Generate production-ready code with error handling, tests, and documentation for"
+    }
+    
     try:
         completion = client.chat.completions.create(
             model=model,
             messages=[{
                 "role": "user",
-                "content": f"Generate {language} code for: {query}. Include comments and error handling."
+                "content": f"{complexity_levels[complexity]} {query} in {language}. Include comments."
             }],
-            temperature=0.6,
+            temperature=0.7 if complexity == "Advanced" else 0.5,
             max_tokens=4096,
             top_p=0.95
         )
@@ -60,45 +108,86 @@ def main():
     if not client:
         return
 
-    st.title("🔥 AI Code Generator 🚀")
-    st.subheader("Generate, Edit & Save Your Code Instantly!")
-    
-    col1, col2 = st.columns([3, 1])
-    
+    # Sidebar for settings
+    with st.sidebar:
+        st.title("⚙️ Settings")
+        selected_theme = st.selectbox("Theme", THEMES, index=0)
+        selected_language = st.selectbox("Programming Language", LANGUAGES, index=0)
+        complexity = st.select_slider("Code Complexity", ["Basic", "Medium", "Advanced"], value="Medium")
+        tags = st_tags(label="Add Keywords:", text="Press enter to add more", value=[], key="tags")
+        
+    inject_custom_css(selected_theme)
+
+    # Main content
+    st.title("✨ AI Code Generator Pro")
+    st.caption("Generate production-ready code in multiple languages with a single click")
+
+    col1, col2 = st.columns([4, 1])
     with col1:
-        query = st.text_input("Describe your coding requirement:")
-        language = st.selectbox("Select Programming Language:", ["Python", "JavaScript", "Java", "C++", "Go"])
+        query = st.text_area("Describe your coding requirement:", height=100, 
+                            placeholder="e.g., A function to calculate Fibonacci sequence")
     
     if 'generated_code' not in st.session_state:
         st.session_state.generated_code = None
-    
-    if col2.button("🔄 New Code"):
-        st.session_state.generated_code = None
-    
-    if query and not st.session_state.generated_code:
-        with st.spinner("Generating code..."):
-            code = generate_code(query, language, PRIMARY_MODEL, client)
-            if not code:
-                st.warning("Trying backup model...")
-                code = generate_code(query, language, BACKUP_MODEL, client)
-            
-            if code:
-                st.session_state.generated_code = code
-            else:
-                st.error("Failed to generate code. Please try again.")
-    
+    if 'alternative_code' not in st.session_state:
+        st.session_state.alternative_code = None
+
+    action_cols = st.columns([1, 1, 1, 1, 2])
+    with action_cols[0]:
+        if st.button("🚀 Generate Code", use_container_width=True):
+            with st.spinner(f"Generating {selected_language} code..."):
+                code = generate_code(query, selected_language, PRIMARY_MODEL, client, complexity)
+                if not code:
+                    st.warning("Trying backup model...")
+                    code = generate_code(query, selected_language, BACKUP_MODEL, client, complexity)
+                
+                if code:
+                    st.session_state.generated_code = code
+                    st.session_state.alternative_code = None
+                else:
+                    st.error("Failed to generate code. Please try again.")
+
+    with action_cols[1]:
+        if st.button("🔄 Alternative", use_container_width=True, disabled=not st.session_state.generated_code):
+            with st.spinner(f"Generating alternative {selected_language} solution..."):
+                alt_code = generate_code(f"Alternative approach for: {query}", selected_language, PRIMARY_MODEL, client, complexity)
+                if alt_code:
+                    st.session_state.alternative_code = alt_code
+
+    with action_cols[2]:
+        if st.button("🧹 Clear", use_container_width=True):
+            st.session_state.generated_code = None
+            st.session_state.alternative_code = None
+
+    # Display results
     if st.session_state.generated_code:
-        with st.expander("📜 Generated Code", expanded=True):
-            st.code(st.session_state.generated_code, language.lower())
-        
-        with st.expander("📖 Explanation", expanded=True):
-            st.write("This block will contain the explanation of the generated code.")
+        with st.container():
+            st.subheader(f"Generated {selected_language} Code")
+            st.markdown(f"""<div class="code-block"><pre><code class="language-{selected_language.lower()}">{st.session_state.generated_code}</code></pre></div>""", 
+                       unsafe_allow_html=True)
             
-        col3, col4 = st.columns([1, 1])
-        with col3:
-            st.download_button("💾 Download Code", st.session_state.generated_code, file_name=f"generated.{language.lower()}")
-        with col4:
-            st.button("📋 Copy Code", on_click=lambda: st.session_state.update({'clipboard': st.session_state.generated_code}))
+            # Explanation section
+            with st.expander("📝 Code Explanation", expanded=True):
+                if client:
+                    try:
+                        explanation = client.chat.completions.create(
+                            model=PRIMARY_MODEL,
+                            messages=[{
+                                "role": "user",
+                                "content": f"Explain this {selected_language} code in simple terms:\n\n{st.session_state.generated_code}"
+                            }],
+                            temperature=0.3,
+                            max_tokens=1024
+                        )
+                        st.write(explanation.choices[0].message.content)
+                    except Exception as e:
+                        st.error(f"Error generating explanation: {str(e)}")
+
+        if st.session_state.alternative_code:
+            with st.container():
+                st.subheader(f"Alternative {selected_language} Solution")
+                st.markdown(f"""<div class="code-block"><pre><code class="language-{selected_language.lower()}">{st.session_state.alternative_code}</code></pre></div>""", 
+                           unsafe_allow_html=True)
 
 if __name__ == "__main__":
-    main()
+    main()