Upload 2 files

app.py

@@ -1,227 +1,147 @@
-from dotenv import load_dotenv
-import os
-from docx import Document
-from llama_index.llms.together import TogetherLLM
-from llama_index.core.llms import ChatMessage, MessageRole
-from Bio import Entrez
-import ssl
-from transformers import AutoModelForSequenceClassification, AutoTokenizer
 import streamlit as st
-from googleapiclient.discovery import build
-from typing import List, Optional
-
-load_dotenv()
-# 995d5f1a8de125c5b39bb48c2613e85f57d53c0e498a87d1ff33f0ec89a26ec7
-os.environ["TOGETHER_API"] = os.getenv("TOGETHER_API")
-os.environ["GOOGLE_SEARCH_API_KEY"] = os.getenv("GOOGLE_SEARCH_API_KEY")
-
-def search_pubmed(query: str) -> Optional[List[str]]:
-    """
-    Searches PubMed for a given query and returns a list of formatted results
-    (or None if no results are found).
-    """
-    Entrez.email = "[email protected]"  # Replace with your email
-
-    try:
-        ssl._create_default_https_context = ssl._create_unverified_context
-
-        handle = Entrez.esearch(db="pubmed", term=query, retmax=3)
-        record = Entrez.read(handle)
-        id_list = record["IdList"]
-
-        if not id_list:
-            return None
-
-        handle = Entrez.efetch(db="pubmed", id=id_list, retmode="xml")
-        articles = Entrez.read(handle)
-
-        results = []
-        for article in articles['PubmedArticle']:
-            try:
-                medline_citation = article['MedlineCitation']
-                article_data = medline_citation['Article']
-                title = article_data['ArticleTitle']
-                abstract = article_data.get('Abstract', {}).get('AbstractText', [""])[0]
-
-                result = f"**Title:** {title}\n**Abstract:** {abstract}\n"
-                result += f"**Link:** https://pubmed.ncbi.nlm.nih.gov/{medline_citation['PMID']} \n\n"
-                results.append(result)
-            except KeyError as e:
-                print(f"Error parsing article: {article}, Error: {e}")
-
-        return results
-
-    except Exception as e:
-        print(f"Error accessing PubMed: {e}")
-        return None
-
-def chat_with_pubmed(article_text, article_link):
-    """
-    Engages in a chat-like interaction with a PubMed article using TogetherLLM.
-    """
-    try:
-        llm = TogetherLLM(model="QWEN/QWEN1.5-14B-CHAT", api_key=os.environ['TOGETHER_API'])
-        messages = [
-            ChatMessage(role=MessageRole.SYSTEM, content="You are a helpful AI assistant summarizing and answering questions about the following medical research article: " + article_link),
-            ChatMessage(role=MessageRole.USER, content=article_text)
-        ]
-        response = llm.chat(messages)
-        return str(response) if response else "I'm sorry, I couldn't generate a summary for this article."
-    except Exception as e:
-        print(f"Error in chat_with_pubmed: {e}")
-        return "An error occurred while generating a summary."
-
-def search_web(query: str, num_results: int = 3) -> Optional[List[str]]:
-    """
-    Searches the web using the Google Search API and returns a list of formatted results
-    (or None if no results are found).
-    """
-    try:
-        service = build("customsearch", "v1", developerKey=os.environ["GOOGLE_SEARCH_API_KEY"])
-
-        # Execute the search request
-        res = service.cse().list(q=query, cx="e31a5857f45ef4d2a", num=num_results).execute()
-
-        if "items" not in res:
-            return None
-
-        results = []
-        for item in res["items"]:
-            title = item["title"]
-            link = item["link"]
-            snippet = item["snippet"]
-            result = f"**Title:** {title}\n**Link:** {link} \n**Snippet:** {snippet}\n\n"
-            results.append(result)
-
-        return results
-
-    except Exception as e:
-        print(f"Error performing web search: {e}")
-        return None
-
-
-from together import Together
-def medmind_chatbot(user_input, chat_history=None):
-    """
-    Processes user input, interacts with various resources, and generates a response.
-    Handles potential errors, maintains chat history,
-    """
-    if chat_history is None:
-        chat_history = []
-
-    response_parts = []  # Collect responses from different sources
-    final_response = "";
-
-    try:
-        # PubMed Search and Chat
-        pubmed_results = search_pubmed(user_input)
-        if pubmed_results:
-            for article_text in pubmed_results:
-                title, abstract, link = article_text.split("\n")[:3]
-                # print(article_text)
-                response_parts.append(f"{title}\n{abstract}\n{link}\n")
-        else:
-            response_parts.append("No relevant PubMed articles found.")
-
-        # Web Search
-        web_results = search_web(user_input)
-        if web_results:
-            response_parts.append("\n\n**Web Search Results:**")
-            response_parts.extend(web_results)
-        else:
-            response_parts.append("No relevant web search results found.")
-
-        # Combine response parts into a single string
-        response_text = "\n\n".join(response_parts)
-
-        prompt = f"""You are a Health Assistant AI designed to provide detailed responses to health-related questions.
-        Based on the information retrieved from the PubMed and Web Search below, answer the user's query appropriately.
-
-        - If the user's query is health-related, provide a detailed and helpful response based on the retrieved information. Or if there is
-        some previous conversation then answer the health by seeing the previous conversation also.
-        - If the query is a general greeting (e.g., 'Hello', 'Hi'), respond as a friendly assistant.
-        - If the query is irrelevant or unrelated to health, respond with: 'I am a health assistant. Please ask only health-related questions.'
-        - Don't mention in response that where you reterived the information.
-        Previous Conversation:
-        {chat_history}
-
-        User's Query: {user_input}
-
-        Information retrieved from PubMed and Web Search:
-        {response_text}
-
-        Your response:"""
-
-        client = Together(api_key=os.environ.get('TOGETHER_API'))
-
-        response = client.chat.completions.create(
-            model="meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
-            messages=[{"role": "user", "content": prompt}],
-        )
-
-        final_response = response.choices[0].message.content
-
-    except Exception as e:
-        print(f"Error in chatbot: {e}")
-        response_text = "An error occurred. Please try again later."
-
-    chat_history.append((user_input, final_response))
-    return final_response, chat_history
-
-medmind_chatbot("What are the symptoms of COVID-19?")
-
-import gradio as gr
-
-def show_info_popup():
-    info = """
-    **HealthHive is an AI-powered chatbot designed to assist with medical information.**
-    ...
-    """
-    return info
+from openai_client import (
+    get_code_review_response,
+    refactor_code,
+    code_feedback,
+    suggest_best_practices,
+    remove_code_errors,
+)
 
 
 def main():
-    # Initialize Gradio Interface
-    with gr.Blocks() as demo:
-        gr.Markdown("# HealthHive Chatbot")
-        gr.Markdown("Ask your medical questions and get reliable information!")
-
-        # Example Questions (Sidebar)
-        gr.Markdown("### Example Questions")
-        example_questions = [
-            "What are the symptoms of COVID-19?",
-            "How can I manage my diabetes?",
-            "What are the potential side effects of ibuprofen?",
-            "What lifestyle changes can help prevent heart disease?"
-        ]
-        for question in example_questions:
-            gr.Markdown(f"- {question}")
-
-        # Chat History and User Input
-        with gr.Row():
-            user_input = gr.Textbox(label="You:", placeholder="Type your medical question here...", lines=2)
-            chat_history = gr.State([])
-
-        # Output Container
-        with gr.Row():
-            response = gr.Textbox(label="HealthHive:", placeholder="Response will appear here...", interactive=False, lines=10)
-        def clear_chat():
-            return "", ""
-
-        # Define function to update chat history and response
-        def on_submit(user_input, chat_history):
-            result, updated_history = medmind_chatbot(user_input, chat_history)
-            info = show_info_popup()
-            return result, updated_history, info
-
-        # Link the submit button to the chatbot function
-        gr.Button("Submit").click(on_submit, inputs=[user_input, chat_history], outputs=[response, chat_history])
-        # gr.Button("Start New Chat").click(lambda: [], outputs=[chat_history])
-        gr.Button("Start New Chat").click(clear_chat, outputs=[user_input, response])
-
-
-    demo.launch()
+    st.title("CodeMentor - (AI-Enhanced Code Collaboration Tool)")
+    st.subheader("Collaborate, Refactor, and Optimize with AI.")
+    st.write(
+        "A smart tool for distributed teams to automate code reviews, refactor efficiently, and get real-time AI-driven feedback."
+    )
+
+    # Instructions
+    st.write(
+        "Upload a file or paste your code below to get an AI-generated code review."
+    )
+
+    # Input Methods: File Upload or Text Area
+    uploaded_file = st.file_uploader(
+        "Upload a code file (Max 500 lines)", type=["py", "js", "txt"]
+    )
+    code_input = st.text_area("Or paste your code here (Max 1000 words)", height=300)
+
+    # Limit input size for code
+    if uploaded_file:
+        code = uploaded_file.read().decode("utf-8")
+        if len(code.splitlines()) > 500:
+            st.error(
+                "File is too large! Please upload a file with a maximum of 500 lines."
+            )
+            code = None  # Reset code if it's too large
+        else:
+            st.success(f"File uploaded: {uploaded_file.name}")
+    elif code_input:
+        code = code_input
+        if len(code.split()) > 1000:
+            st.error("Code exceeds 1000 words! Please shorten your code.")
+            code = None  # Reset code if it's too large
+    else:
+        code = None
+
+    # Button to trigger code review
+    if st.button("Get Code Review") and code:
+        with st.spinner("Processing..."):
+            # Call the OpenAI API to get code review
+            review = get_code_review_response(code)
+            st.subheader("Code Review Results:")
+            st.write(review)
+
+            # Provide download option
+            st.download_button(
+                label="Download Code Review",
+                data=review,
+                file_name="code_review.txt",
+                mime="text/plain",
+            )
+            st.success("You can download the code review as code_review.txt")
+
+        # Button to trigger code refactoring
+    if st.button("Refactor Code") and code:
+        with st.spinner("Refactoring your code..."):
+            refactored_code = refactor_code(code)
+            st.subheader("Refactored Code:")
+            st.write(refactored_code)
+
+            # Provide download option for refactored code
+            st.download_button(
+                label="Download Refactored Code",
+                data=refactored_code,
+                file_name="refactored_code.txt",
+                mime="text/plain",
+            )
+            st.success("You can download the refactored code as refactored_code.txt")
+
+    # Button to trigger code feedback
+    if st.button("Get Code Feedback") and code:
+        with st.spinner("Getting feedback on your code..."):
+            feedback = code_feedback(code)
+            st.subheader("Code Feedback:")
+            st.write(feedback)
+
+            # Ensure feedback is a string for download
+            feedback_text = feedback if isinstance(feedback, str) else str(feedback)
+
+            # Provide download option for code feedback
+            st.download_button(
+                label="Download Code Feedback",
+                data=feedback_text,  # Use the extracted string here
+                file_name="code_feedback.txt",
+                mime="text/plain",
+            )
+            st.success("You can download the code feedback as code_feedback.txt")
+
+    # Add button to suggest best practices
+    if st.button("Suggest Best Practices") and code:
+        with st.spinner("Getting best practices..."):
+            best_practices = suggest_best_practices(code)
+            st.subheader("Best Practices Suggestions:")
+            st.write(best_practices)
+
+            # Provide download option for best practices suggestions
+            best_practices_text = (
+                best_practices
+                if isinstance(best_practices, str)
+                else str(best_practices)
+            )
+            st.download_button(
+                label="Download Best Practices Suggestions",
+                data=best_practices_text,
+                file_name="best_practices.txt",
+                mime="text/plain",
+            )
+            st.success(
+                "You can download the best practices suggestions as best_practices.txt"
+            )
+
+    # Button to trigger error removal
+    if st.button("Remove Code Errors") and code:
+        with st.spinner("Removing errors from your code..."):
+            error_removal_suggestions = remove_code_errors(code)
+            st.subheader("Error Removal Suggestions:")
+            st.write(error_removal_suggestions)
+
+            # Provide download option for error removal suggestions
+            error_removal_text = (
+                error_removal_suggestions
+                if isinstance(error_removal_suggestions, str)
+                else str(error_removal_suggestions)
+            )
+            st.download_button(
+                label="Download Error Removal Suggestions",
+                data=error_removal_text,
+                file_name="error_removal_suggestions.txt",
+                mime="text/plain",
+            )
+            st.success(
+                "You can download the error removal suggestions as error_removal_suggestions.txt"
+            )
+
 
 if __name__ == "__main__":
     main()
-

openai_client.py

@@ -0,0 +1,148 @@
+import os
+from dotenv import load_dotenv
+from openai import OpenAI
+import anthropic
+
+# Load environment variables from .env file
+load_dotenv()
+
+client = OpenAI(
+    api_key=os.getenv("OPENAI_API_KEY"),
+    base_url=os.getenv("OPENAI_API_BASE"),  # Uncomment if using a custom base URL
+)
+
+
+# Function to get GPT-4o Mini response
+def get_code_review_response(prompt, max_tokens=1000):
+    try:
+        response = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {
+                    "role": "system",
+                    "content": "You are an AI assistant who helps users in code reviews by deep thinking in points max 5-6 point shortly.",
+                },
+                {"role": "user", "content": prompt},
+            ],
+            max_tokens=max_tokens,
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        return "Sorry, an error occurred while generating your idea. Please try again later."
+
+
+# Function to refactor code
+def refactor_code(code_snippet):
+    try:
+        response = client.chat.completions.create(
+            model="gpt-4o-2024-08-06",
+            messages=[
+                {
+                    "role": "system",
+                    "content": "You are an expert code refactoring assistant.",
+                },
+                {
+                    "role": "user",
+                    "content": f"Refactor the following code. Do not provide any explanation or comments, just return the refactored code.\n{code_snippet}",
+                },
+            ],
+        )
+        refactored_code = response.choices[0].message.content
+        return refactored_code
+    except Exception as e:
+        return "Sorry, an error occurred while refactoring your code. Please try again later."
+
+
+# Initialize the Anthropic client
+anthropic_client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
+
+
+# Function to get feedback on code using Anthropic
+def code_feedback(code_snippet):
+    try:
+        response = anthropic_client.messages.create(
+            model="claude-3-5-sonnet-20240620",
+            max_tokens=1024,
+            messages=[
+                {
+                    "role": "user",
+                    "content": f"Please provide feedback on the given code, don't refactor the code:\n{code_snippet}",
+                },
+            ],
+        )
+
+        # Extract feedback text from the response
+        feedback = response.text if hasattr(response, "text") else str(response)
+
+        # Check if feedback is a Message object and extract text if necessary
+        if hasattr(response, "content") and isinstance(response.content, list):
+            feedback = "\n\n".join(
+                [
+                    text_block.text
+                    for text_block in response.content
+                    if hasattr(text_block, "text")
+                ]
+            )
+
+        return feedback
+
+    except Exception as e:
+        return "Sorry, an error occurred while getting feedback on your code. Please try again later."
+
+
+# Function to suggest best coding practices based on given code
+def suggest_best_practices(code_snippet):
+    try:
+        response = anthropic_client.messages.create(
+            model="claude-3-5-sonnet-20240620",
+            max_tokens=1024,
+            messages=[
+                {
+                    "role": "user",
+                    "content": (
+                        f"Based on the following code, suggest best practices max 5-6 point shortly"
+                        f"for coding patterns that align with industry standards: \n{code_snippet}"
+                    ),
+                },
+            ],
+        )
+
+        # Extract suggestions from the response
+        best_practices = response.text if hasattr(response, "text") else str(response)
+
+        # Check if the feedback is a Message object and extract text if necessary
+        if hasattr(response, "content") and isinstance(response.content, list):
+            best_practices = "\n\n".join(
+                [
+                    text_block.text
+                    for text_block in response.content
+                    if hasattr(text_block, "text")
+                ]
+            )
+
+        return best_practices
+
+    except Exception as e:
+        return "Sorry, an error occurred while suggesting best practices. Please try again later."
+
+
+# Function to remove code errors
+def remove_code_errors(code_snippet):
+    try:
+        response = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {
+                    "role": "system",
+                    "content": "You are an expert in debugging code. Provide concise suggestions to remove errors from the following code snippet.",
+                },
+                {
+                    "role": "user",
+                    "content": f"Identify and suggest fixes for errors in the following code:\n{code_snippet}",
+                },
+            ],
+        )
+        error_removal_suggestions = response.choices[0].message.content
+        return error_removal_suggestions
+    except Exception as e:
+        return "Sorry, an error occurred while removing code errors. Please try again later."