Make requirment and support python file

chatbot.py

@@ -0,0 +1,132 @@
+import streamlit as st
+from groq import Groq
+from langchain_groq import ChatGroq
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+import edge_tts
+import asyncio
+import os
+from typing import Optional
+GROQ_API_KEY = "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"
+os.environ["GROQ_API_KEY"] = GROQ_API_KEY 
+
+
+class CodeAssistantBot:
+
+    def __init__(self):
+        self.client = Groq(api_key=GROQ_API_KEY)
+        self.model = ChatGroq(model="llama-3.3-70b-versatile", temperature=0.6)
+
+        # Initialize prompts
+        self.analysis_prompt = ChatPromptTemplate.from_messages([
+            ("system",
+             """You are an expert code assistant. Analyze the code and context provided,
+            then give clear, helpful responses. Keep responses concise and focused on the code."""
+             ),
+            ("user", """Code: {code}
+            Output: {output}
+            Error: {error}
+            Question: {question}""")
+        ])
+
+        self.summary_prompt = ChatPromptTemplate.from_messages([(
+            "system",
+            """Summarize the conversation focusing on key technical points and insights.
+            Keep it brief and clear."""
+        ), ("user", "Conversation: {conversation}")])
+
+    def analyze_code(self, code: str, output: str, error: str,
+                     question: str) -> str:
+        try:
+            parser = StrOutputParser()
+            chain = self.analysis_prompt | self.model | parser
+            return chain.invoke({
+                'code': code,
+                'output': output,
+                'error': error,
+                'question': question
+            })
+        except Exception as e:
+            return f"Sorry, I encountered an error: {str(e)}"
+
+    def summarize_conversation(self, conversation: list) -> str:
+        try:
+            parser = StrOutputParser()
+            chain = self.summary_prompt | self.model | parser
+            formatted_conv = "\n".join(
+                [f"Q: {q}\nA: {a}" for q, a in conversation])
+            return chain.invoke({'conversation': formatted_conv})
+        except Exception as e:
+            return f"Could not generate summary: {str(e)}"
+
+
+async def text_to_speech(text: str, filename: str):
+    voice = "en-US-AriaNeural"
+    communicate = edge_tts.Communicate(text, voice)
+    await communicate.save(filename)
+
+
+def render_chatbot(code: str, output: str, error: str):
+    """Render the chatbot UI as an integrated panel"""
+
+    # Initialize session state
+    if "conversation" not in st.session_state:
+        st.session_state.conversation = []
+    if "audio_count" not in st.session_state:
+        st.session_state.audio_count = 0
+
+    # Create bot instance
+    bot = CodeAssistantBot()
+
+    # Chat interface
+    st.markdown("""
+        <style>
+        .chat-message {
+            padding: 10px;
+            border-radius: 5px;
+            margin-bottom: 10px;
+        }
+        .user-message {
+            background-color: #e3f2fd;
+        }
+        .bot-message {
+            background-color: #f5f5f5;
+        }
+        </style>
+    """,
+                unsafe_allow_html=True)
+
+    # Chat history in a scrollable container
+    chat_container = st.container()
+    with chat_container:
+        for q, a in st.session_state.conversation:
+            st.markdown(
+                f'<div class="chat-message user-message">**You:** {q}</div>',
+                unsafe_allow_html=True)
+            st.markdown(
+                f'<div class="chat-message bot-message">**Assistant:** {a}</div>',
+                unsafe_allow_html=True)
+
+    # Input area
+    user_input = st.text_input("Ask about your code...",
+                               key="chat_input",
+                               placeholder="Type your question here...")
+
+    if user_input:
+        # Get response
+        response = bot.analyze_code(code, output, error, user_input)
+        st.session_state.conversation.append((user_input, response))
+
+        # Generate summary and speech if conversation is long enough
+        if len(st.session_state.conversation) > 3:
+            with st.spinner("Generating conversation summary..."):
+                summary = bot.summarize_conversation(
+                    st.session_state.conversation)
+                audio_file = f"summary_{st.session_state.audio_count}.wav"
+                asyncio.run(text_to_speech(summary, audio_file))
+                st.session_state.audio_count += 1
+
+                # Display summary in a collapsible section
+                with st.expander("📝 Conversation Summary", expanded=False):
+                    st.markdown(summary)
+                    st.audio(audio_file, format="audio/wav")

requirment.txt

@@ -0,0 +1,9 @@
+streamlit
+streamlit-ace
+groq
+langchain
+langchain-core
+langchain-groq
+edge-tts
+audio_recorder_streamlit
+python-dotenv

utils.py

@@ -0,0 +1,38 @@
+import sys
+from io import StringIO
+import contextlib
+import json
+from datetime import datetime
+
+@contextlib.contextmanager
+def capture_output():
+    """Capture stdout and stderr"""
+    stdout, stderr = StringIO(), StringIO()
+    old_out, old_err = sys.stdout, sys.stderr
+    try:
+        sys.stdout, sys.stderr = stdout, stderr
+        yield stdout, stderr
+    finally:
+        sys.stdout, sys.stderr = old_out, old_err
+
+def execute_code(code: str) -> tuple:
+    """
+    Execute the provided code and return stdout, stderr and any exceptions
+    """
+    with capture_output() as (stdout, stderr):
+        try:
+            exec(code)
+            return stdout.getvalue().strip(), stderr.getvalue().strip(), None
+        except Exception as e:
+            return stdout.getvalue().strip(), stderr.getvalue().strip(), str(e)
+
+def export_session(code: str, output: str, error: str) -> dict:
+    """
+    Create an exportable session object
+    """
+    return {
+        "timestamp": datetime.now().isoformat(),
+        "code": code,
+        "output": output,
+        "error": error
+    }