Update app.py

app.py

@@ -1,100 +1,137 @@
 import gradio as gr
-import requests
 from huggingface_hub import InferenceClient
-
-# Initialize Hugging Face client
-HF_MODEL = "mistralai/Mixtral-8x7B-Instruct-v0.1"
-HF_TOKEN = "your_hugging_face_api_token"  # Replace with your token
-client = InferenceClient(model=HF_MODEL, token=HF_TOKEN)
-
-# Persistent bot knowledge state
-bot_knowledge = {"dataset": None}
-
-def load_model(hf_token):
-    """Loads the model and tokenizer using the provided Hugging Face token."""
-    global model, tokenizer
-
-    # Set the token for Hugging Face authentication
-    HfFolder.save_token(hf_token, 'huggingface')
-
-    # Load the model
+import os
+import asyncio
+import aiohttp
+import json
+import logging
+import hashlib
+from typing import List, Dict, Tuple
+from transformers import pipeline
+from sentence_transformers import SentenceTransformer, util
+from pydantic import BaseModel, SecretStr
+
+# Enable detailed logging
+logging.basicConfig(level=logging.INFO)
+
+# Hugging Face Inference Client
+client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
+
+# Load a pre-trained model for sentence similarity
+similarity_model = SentenceTransformer('all-mpnet-base-v2')
+
+class GitHubConfig(BaseModel):
+    username: str
+    repository: str
+    api_token: SecretStr
+
+class GitHubIntegration:
+    def __init__(self, config: GitHubConfig):
+        self.config = config
+        self.headers = {
+            "Authorization": f"Bearer {self.config.api_token.get_secret_value()}",
+            "Accept": "application/vnd.github.v3+json"
+        }
+        self.url = "https://api.github.com"
+
+    async def fetch_issues(self) -> List[Dict]:
+        cache_key = hashlib.md5(f"{self.config.username}/{self.config.repository}".encode()).hexdigest()
+        cached_data = await self._load_cache(cache_key)
+        if cached_data:
+            return cached_data
+
+        url = f"{self.url}/repos/{self.config.username}/{self.config.repository}/issues"
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, headers=self.headers) as response:
+                    response.raise_for_status()
+                    issues = await response.json()
+                    await self._save_cache(cache_key, issues)
+                    return issues
+        except Exception as e:
+            logging.error(f"GitHub API error: {str(e)}")
+            return []
+
+    async def _load_cache(self, key: str) -> List[Dict] | None:
+        cache_file = f"cache_{key}.json"
+        if os.path.exists(cache_file):
+            async with aiohttp.ClientSession() as session:
+                async with session.get(f"file://{cache_file}") as f:
+                    return json.loads(await f.text())
+        return None
+
+    async def _save_cache(self, key: str, data: List[Dict]):
+        cache_file = f"cache_{key}.json"
+        with open(cache_file, "w") as f:
+            json.dump(data, f)
+
+async def analyze_issues(issue_text: str, model_name: str) -> str:
+    """
+    Analyze issues and provide solutions.
+    """
+    logging.info(f"Analyzing issue with model: {model_name}")
+    prompt = f"""
+    Issue: {issue_text}
+    Please provide a comprehensive resolution in the following format:
+    ## Problem Summary:
+    ## Root Cause Analysis:
+    ## Solution Options:
+    ## Recommended Solution:
+    ## Implementation Steps:
+    ## Verification Steps:
+    """
     try:
-        with gr.Progress() as progress:
-            progress(0, "Loading model...")
-            model = AutoModelForCausalLM.from_pretrained(DEFAULT_MODEL)
-            tokenizer = AutoTokenizer.from_pretrained(DEFAULT_MODEL)
-            progress(100, "Model loaded successfully!")
-        return "Model loaded successfully!"
+        nlp = pipeline("text-generation", model=model_name, max_length=1000)
+        result = nlp(prompt)
+        return result[0]['generated_text']
     except Exception as e:
-        return f"Error loading model: {str(e)}"
-
-# Train chatbot by setting the dataset
-def train_chatbot(dataset):
-    bot_knowledge["dataset"] = dataset
-    return "Chatbot trained successfully!"
-
-
-# Chat function to process user input and generate bot responses
-def chat_with_bot(history, user_input):
-    if not bot_knowledge["dataset"]:
-        return history + [{"role": "bot", "content": "No dataset loaded. Please train the bot first."}]
-
-    # Append user input to the chat history
-    history.append({"role": "user", "content": user_input})
-
-    # Generate bot response
-    prompt = f"{bot_knowledge['dataset']} {user_input}"
-    try:
-        response = client.text_generation(prompt=prompt, max_new_tokens=128)
-        bot_response = response.get("generated_text", "Sorry, I couldn't generate a response.")
-    except Exception as e:
-        bot_response = f"Error generating response: {e}"
-
-    # Append bot response to the history
-    history.append({"role": "bot", "content": bot_response})
-    return history
-
-
-# Gradio Interface
-with gr.Blocks(theme="default") as app:
-    gr.Markdown("# **Intelligent Chatbot with Knowledge Training**")
-    gr.Markdown(
-        """
-        Train a chatbot with custom datasets and interact with it dynamically. 
-        The bot will persist knowledge from the dataset and answer questions accordingly.
-        """
-    )
-
-    # Train chatbot section
-    with gr.Row():
-        chat_dataset = gr.Textbox(
-            label="Dataset for Training",
-            placeholder="Paste a dataset here to train the chatbot.",
-            lines=5,
-        )
-        train_button = gr.Button("Train Chatbot")
-
-    train_status = gr.Textbox(label="Training Status", interactive=False)
-
-    # Chat section
-    with gr.Row():
-        chatbot = gr.Chatbot(
-            label="Chat with Trained Bot",
-            type="messages",
-            
-        )
-        user_input = gr.Textbox(
-            label="Your Message",
-            placeholder="Type your message and press Enter...",
-            lines=1,
-        )
-
-    # Train chatbot logic
-    train_button.click(train_chatbot, inputs=[chat_dataset], outputs=[train_status])
-
-    # Chat interaction logic
-    user_input.submit(chat_with_bot, inputs=[chatbot, user_input], outputs=chatbot)
-
-# Launch app
-if __name__ == "__main__":
-    app.launch(server_name="0.0.0.0", server_port=7860)
+        logging.error(f"Error analyzing issue: {e}")
+        return "Error analyzing issue."
+
+async def find_related_issues(issue_text: str, issues: list) -> list:
+    """
+    Find related issues using similarity model.
+    """
+    issue_embedding = similarity_model.encode(issue_text)
+    related_issues = [
+        (issue, util.cos_sim(issue_embedding, similarity_model.encode(issue['title']))[0][0])
+        for issue in issues
+    ]
+    return sorted(related_issues, key=lambda x: x[1], reverse=True)[:3]
+
+def respond(command: str, github_api_token: str, github_username: str, github_repository: str, selected_model: str) -> str:
+    """
+    Handle chat responses.
+    """
+    if command.startswith("/github"):
+        parts = command.split(maxsplit=2)
+        if len(parts) < 3:
+            return "❌ Format: /github <username> <repo> <token>"
+        github_client = GitHubIntegration(GitHubConfig(username=parts[0], repository=parts[1], api_token=SecretStr(parts[2])))
+        issues = asyncio.run(github_client.fetch_issues())
+        return "✅ GitHub configured successfully."
+    elif command.startswith("/analyze"):
+        issue_text = command.replace("/analyze", "").strip()
+        return asyncio.run(analyze_issues(issue_text, selected_model))
+    elif command.startswith("/list_issues"):
+        github_client = GitHubIntegration(GitHubConfig(username=github_username, repository=github_repository, api_token=SecretStr(github_api_token)))
+        issues = asyncio.run(github_client.fetch_issues())
+        return "\n".join([f"- {issue['title']} (Issue #{issue['number']})" for issue in issues])
+    else:
+        return "Unknown command. Use /help for instructions."
+
+iface = gr.Interface(
+    fn=respond,
+    inputs=[
+        gr.Textbox(label="Command"),
+        gr.Textbox(label="GitHub API Token", placeholder="Enter your GitHub API token"),
+        gr.Textbox(label="GitHub Username", placeholder="Enter your GitHub username"),
+        gr.Textbox(label="GitHub Repository", placeholder="Enter your GitHub repository"),
+        gr.Dropdown(label="Model", choices=["text-davinci-003", "text-curie-001"], value="text-davinci-003"),
+    ],
+    outputs=gr.Textbox(label="Response"),
+    title="AI GitHub Assistant",
+    description="Interact with GitHub and analyze issues with AI.",
+)
+
+iface.launch(share=True)