Update app.py

app.py

@@ -1,327 +1,261 @@
-import argparse
-import os
-import re
-import subprocess
-import sys
-import zipfile
-import random
-import string
-import shutil
-import io
-import webbrowser
-from typing import List, Any, Dict, Union
-from concurrent.futures import ThreadPoolExecutor, as_completed
-import logging
-import aiohttp
-import asyncio
-import hashlib
 import gradio as gr
-from transformers import AutoTokenizer, pipeline
-
-# Configure logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-
-# Updated regex using lookahead assertion
-OPENAI_REGEX = re.compile(r'(?=import\s+)(?:openai|openai_.*)')
-GITIGNORE_CONTENT = '# Converted files will appear here\n'
-WEBAPP_DIRNAME = 'webapp'
-CACHE_DIR = './cache'
-
-class OpenAIWrapper:
-    # Implement OpenAI interaction methods here
-    pass
-
-async def download_file(url: str) -> bytes:
-    """Downloads a file asynchronously with retries and returns its content."""
-    logging.info(f"Downloading content from {url}...")
-    async with aiohttp.ClientSession() as session:
-        for attempt in range(3):
-            try:
-                async with session.get(url) as response:
-                    if response.status == 200:
-                        logging.info("Download complete!")
-                        return await response.read()
-                    else:
-                        logging.error(f"Failed to download content from {url} (status code: {response.status})")
-            except aiohttp.ClientError as e:
-                logging.error(f"Error downloading {url}: {e}")
-            await asyncio.sleep(2 ** attempt)  # Exponential backoff
-    return None
-
-def get_cache_path(url: str) -> str:
-    """Returns a unique cache path based on the URL."""
-    hash_digest = hashlib.md5(url.encode()).hexdigest()
-    return os.path.join(CACHE_DIR, hash_digest)
-
-class DownloadItemTask:
-    """Class responsible for fetching remote content"""
-
-    def __init__(self, url: str):
-        self.url = url
-
-    async def download(self) -> bytes:
-        """Attempts to download the file using the download_file function"""
-        cache_path = get_cache_path(self.url)
-        if os.path.exists(cache_path):
-            logging.info(f"Using cached file for {self.url}")
-            with open(cache_path, 'rb') as f:
-                return f.read()
-        data = await download_file(self.url)
-        if data:
-            os.makedirs(CACHE_DIR, exist_ok=True)
-            with open(cache_path, 'wb') as f:
-                f.write(data)
-        return data
-
-class UnarchiveTask:
-    """Utility class dealing with archives such as .zip or tarballs"""
-
-    def __init__(self, data: bytes):
-        self.data = data
-
-    def unarchive(self) -> str:
-        """Unpacks and returns root directory holding contents"""
-        logging.info("Unarchiving downloaded file...")
-        extracted_dir = os.path.join(CACHE_DIR, ''.join(random.choices(string.ascii_uppercase + string.digits, k=10)))
-        os.makedirs(extracted_dir, exist_ok=True)
-
-        try:
-            if sys.platform == 'darwin' or sys.platform.startswith('linux'):
-                with open(os.path.join(extracted_dir, 'archive.tar'), 'wb') as f:
-                    f.write(self.data)
-                subprocess.run(['tar', '-xf', 'archive.tar', '-C', extracted_dir], check=True)
-            else:
-                with zipfile.ZipFile(io.BytesIO(self.data), 'r') as zip_ref:
-                    zip_ref.extractall(extracted_dir)
-            logging.info("Unarchiving complete!")
-        except Exception as e:
-            logging.error(f"Error unarchiving file: {e}")
-            return None
+from transformers import pipeline
+from sentence_transformers import SentenceTransformer, util
+import os
+import requests
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+class InferenceClient:
+    def __init__(self):
+        pass
 
-        return extracted_dir
+    def create_endpoint(self, repo_id, handler_path, model_id, task, description, hyperparameters):
+        pass
 
-class DependencyFinderTask:
-    """Scans project structure searching for specific dependencies to be swapped"""
+    def update_endpoint(self, repo_id, handler_path, model_id, task, description, hyperparameters):
+        pass
 
-    DEPENDENCY_REGEXES = {
-        'openai': OPENAI_REGEX,
-    }
+    def delete_endpoint(self, repo_id, handler_path):
+        pass
 
-    def __init__(self):
-        self.found_paths = {'openai': set()}
-        self.has_openai_dep = False
+    def list_endpoints(self):
+        pass
 
-    def find_dependencies(self, dir_path: str):
-        """Recursively searches through directories looking for dependencies"""
-        logging.info("Searching for dependencies...")
+    def get_endpoint_status(self, repo_id, handler_path):
+        pass
 
-        for current_root, _, filenames in os.walk(dir_path):
-            for filename in filenames:
-                full_path = os.path.join(current_root, filename)
-                try:
-                    with open(full_path, mode='rt', encoding='utf-8') as f:
-                        content = f.read()
+    def get_endpoint_logs(self, repo_id, handler_path, num_lines):
+        pass
+
+    def get_endpoint_metrics(self, repo_id, handler_path):
+        pass
+
+
+from huggingface_hub import InferenceClient,HfApi
+
+
+client = InferenceClient("mistralai/Mixtral-8x7B-Instruct-v0.1")
+
+# Load the pre-trained model and tokenizer
+model_name = "mistralai/Mixtral-8x7B-Instruct-v0.1"
+model = AutoModelForCodeGeneration.from_pretrained(model_name)
+tokenizer = AutoTokenizerForCodeGeneration.from_pretrained(model_name)
+
+# Define input prompt
+input_prompt = "(input value = highest-level-quality code content invocation ; True)"
+
+# Tokenize the input prompt
+input_ids = tokenizer(input_prompt, return_tensors="pt", truncation=True)
+
+# Generate the code
+generated_code = model.generate(input_ids.to(model.device))
+
+# Decode the generated code
+generated_code_str = tokenizer.batch_decode(generated_code, skip_special_tokens=True)[0]
+
+# Print the generated code
+print(generated_code_str)
+# Constants for enhanced organization
+GITHUB_API_BASE_URL = "https://api.github.com/repos"
+DEFAULT_MODEL = "apple/OpenELM"
+MAX_RELATED_ISSUES = 3
 
-                        for dep, regex in self.DEPENDENCY_REGEXES.items():
-                            if regex.search(content):
-                                self.found_paths[dep].add(full_path)
-                                self.has_openai_dep = True
+# Load a pre-trained model for sentence similarity
+similarity_model = SentenceTransformer('all-mpnet-base-v2')
+
+def analyze_issues(issue_text: str, model_name: str, severity: str = None, programming_language: str = None) -> str:
+    """Analyzes issues and provides solutions using a specified language model."""
+    model = pipeline("text-generation", model=model_name)
+    response = model(
+        f"{system_message}\n{issue_text}\nAssistant: ",
+        max_length=max_tokens,
+        do_sample=True,
+        temperature=temperature,
+        top_k=top_p,
+    )
+    assistant_response = response[0]['generated_text'].strip()
+
+    # Extract severity and programming language from the response
+    if "Severity" in assistant_response:
+        severity = assistant_response.split(":")[1].strip()
+    if "Programming Language" in assistant_response:
+        programming_language = assistant_response.split(":")[1].strip()
+
+    return {
+        'assistant_response': assistant_response,
+        'severity': severity,
+        'programming_language': programming_language,
+    }
+
+def find_related_issues(issue_text: str, issues: list) -> list:
+    """Finds semantically related issues from a list of issues based on the input issue text."""
+    issue_embedding = similarity_model.encode(issue_text)
+    similarities = [util.cos_sim(issue_embedding, similarity_model.encode(issue['title'])) for issue in issues]
+    sorted_issues = sorted(enumerate(similarities), key=lambda x: x[1], reverse=True)
+    related_issues = [issues[i] for i, similarity in sorted_issues[:MAX_RELATED_ISSUES]]
+    return related_issues
+
+def fetch_github_issues(github_api_token: str, github_username: str, github_repository: str) -> list:
+    """Fetches issues from a specified GitHub repository using the GitHub API."""
+    headers = {'Authorization': f'token {github_api_token}'}
+    url = f"{GITHUB_API_BASE_URL}/{github_username}/{github_repository}/issues"
+    response = requests.get(url, headers=headers)
+    issues = response.json()
+    return issues
+
+def respond(
+    command,
+    history,
+    system_message,
+    max_tokens,
+    temperature,
+    top_p,
+    github_api_token,
+    github_username,
+    github_repository,
+    selected_model,
+    severity,
+    programming_language,
+    *args,
+    **kwargs,
+) -> dict:
+    """Handles user commands and generates responses using the selected language model."""
+    model = pipeline("text-generation", model="enricoros/big-agi")
+    response = model(
+        f"{system_message}\n{command}\n{history}\n{github_username}/{github_repository}\n{severity}\n{programming_language}\nAssistant: ",
+        max_length=max_tokens,
+        do_sample=True,
+        temperature=temperature,
+        top_k=top_p,
+    )
+    assistant_response = response[0]['generated_text'].strip()
+    return {
+        'assistant_response': assistant_response,
+        'severity': severity,
+        'programming_language': programming_language,
+    }
+
+class MyChatbot(gr.Chatbot):
+    """Custom Chatbot class for enhanced functionality."""
+    def __init__(self, fn, **kwargs):
+        super().__init__(fn, **kwargs)
+        self.issues = []  # Store fetched issues
+        self.current_issue = None  # Store the currently selected issue
+
+    def postprocess(self, y):
+        """Post-processes the response to handle commands and display results."""
+        # Extract the response from the dictionary
+        assistant_response = y['assistant_response']
+
+        # Handle commands
+        if y['command'] == "/github":
+            if not y['github_api_token']:
+                return "Please enter your GitHub API token first."
+            else:
+                try:
+                    self.issues = fetch_github_issues(y['github_api_token'], y['github_username'], y['github_repository'])
+                    issue_list = "\n".join([f"{i+1}. {issue['title']}" for i, issue in enumerate(self.issues)])
+                    return f"Available GitHub Issues:\n{issue_list}\n\nEnter the issue number to analyze:"
                 except Exception as e:
-                    logging.error(f"Error reading file {full_path}: {e}")
-
-        logging.info("Dependency search complete!")
-        return self
-
-class DependencyReplacerTask:
-    """
-    Replaces specified dependencies with their corresponding wrapper methods
-    Also, provides a method to save and load the dependency mapping to improve efficiency
-    """
-
-    def __init__(self, finder: DependencyFinderTask, pipeline: Any, wrapper: Any):
-        self.finder = finder
-        self.pipeline = pipeline
-        self.wrapper = wrapper
-        self.num_changed_files = 0
-
-    def replace(self):
-        """Replaces the dependencies in the specified files"""
-        logging.info("Replacing dependencies...")
-
-        for dep, paths in self.finder.found_paths.items():
-            if dep == 'openai':
-                for path in paths:
-                    try:
-                        with open(path, mode='rt', encoding='utf-8') as f:
-                            content = f.read()
-
-                        replaced_content = content.replace('openai.', 'self.pipeline.')
-                        with open(path, mode='wt', encoding='utf-8') as f:
-                            f.write(replaced_content)
-
-                        self.num_changed_files += 1
-                    except Exception as e:
-                        logging.error(f"Error replacing dependency in file {path}: {e}")
-
-        logging.info("Dependency replacement complete!")
-        return self
-
-    def save_mapping(self, mapping_file: str):
-        """Saves the dependency mapping to a file for future use"""
-        with open(mapping_file, 'w') as f:
-            for dep, paths in self.finder.found_paths.items():
-                f.write(f"{dep}: {','.join(paths)}\n")
-
-    def load_mapping(self, mapping_file: str):
-        """Loads the dependency mapping from a file for future use"""
-        with open(mapping_file, 'r') as f:
-            lines = f.readlines()
-
-        for line in lines:
-            dep, paths = line.strip().split(': ')
-            self.finder.found_paths[dep] = {path.strip() for path in paths.split(',')}
-
-class WebAppCreatorTask:
-    """Creates a web app directory and copies converted files to it"""
-
-    def __init__(self, webapp_dirname: str, unarchived_dir: str):
-        self.webapp_dirname = webapp_dirname
-        self.unarchived_dir = unarchived_dir
-
-    def create(self) -> bool:
-        """Creates a web app directory and copies converted files to it"""
-        logging.info("Creating web app directory...")
-
-        webapp_dir = os.path.join(self.unarchived_dir, self.webapp_dirname)
-        os.makedirs(webapp_dir, exist_ok=True)
-
-        try:
-            for root, _, files in os.walk(self.unarchived_dir):
-                for file in files:
-                    if not file.endswith('.html'):
-                        continue
-
-                    src_path = os.path.join(root, file)
-                    dest_path = os.path.join(webapp_dir, file)
-                    shutil.copy2(src_path, dest_path)
-            logging.info("Web app directory creation complete!")
-        except Exception as e:
-            logging.error(f"Error creating web app directory: {e}")
-            return False
-
-        return os.path.exists(webapp_dir)
-
-class DeploymentTask:
-    """Class responsible for deploying the web application"""
-
-    def __init__(self, webapp_dir: str, api_key: str):
-        self.webapp_dir = webapp_dir
-        self.api_key = api_key
-        self.success = False
-
-    def deploy(self):
-        """Deploys the web application using the specified API key"""
-        logging.info("Deploying web application...")
-
-        try:
-            # Deployment logic here
-            self.success = True
-            logging.info("Deployment complete!")
-        except Exception as e:
-            logging.error(f"Error during deployment: {e}")
-            self.success = False
-        return self
-
-def process_file(file_path: str, api_key: str, action: str, dependency_mapping: Dict[str, List[str]]):
-    logging.info(f'\nProcessing local file: {file_path}')
-
-    with open(file_path, 'rb') as f:
-        downloaded_file = f.read()
-
-    unarchived_dir = UnarchiveTask(downloaded_file).unarchive()
-    if not unarchived_dir:
-        logging.error("Unarchiving failed! Proceeding to next URL...")
-        return
-    os.chdir(unarchived_dir)
-
-    tokenizer = AutoTokenizer.from_pretrained('ELECTRA-base-discriminator')
-    pipe = pipeline('text-generation', model='ELECTRA-base-discriminator', tokenizer=tokenizer)
-
-    finder = DependencyFinderTask().find_dependencies(os.curdir)
-
-    # Load dependency mapping if provided
-    if dependency_mapping:
-        finder.load_mapping(dependency_mapping)
-
-    if finder.has_openai_dep:
-        replacer = DependencyReplacerTask(finder, pipe, OpenAIWrapper()).replace()
-        replacer.save_mapping(dependency_mapping)
-
-    created_webapp = WebAppCreatorTask(WEBAPP_DIRNAME, unarchived_dir).create()
-    os.chdir('..')
-
-    if action == 'upload':
-        deploy_task = DeploymentTask(created_webapp, api_key).deploy()
-        if not deploy_task.success:
-            logging.error("Deployment failed! Continuing to next URL...")
-
-    logging.info(f"Successfully processed local file: {file_path}")
-
-def process_urls(urls: List[str], api_key: str, action: str, dependency_mapping: Dict[str, List[str]]):
-    async def process_url_task(url: str):
-        file_data = await DownloadItemTask(url).download()
-        if file_data:
-            unarchived_dir = UnarchiveTask(file_data).unarchive()
-            if unarchived_dir:
-                process_file(unarchived_dir, api_key, action, dependency_mapping)
-                os.chdir('..')
-
-    with ThreadPoolExecutor() as executor:
-        futures = {executor.submit(process_url_task, url) for url in urls}
-        for future in as_completed(futures):
-            future.result()
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--api-key', '-a', type=str, help='Hugging Face API Key')
-    parser.add_argument('--action', '-t', type=str, choices=['convert', 'upload'], help='Action to perform')
-    parser.add_argument('--dependency-mapping', '-d', type=str, help='Dependency mapping file path')
-
-    args = parser.parse_args()
-
-    if not args.api_key:
-        print("Please provide an API key using --api-key flag.")
-        sys.exit(1)
-
-    if not args.action:
-        print("Please provide an action to perform using --action flag.")
-        sys.exit(1)
-
-    dependency_mapping = {}
-    if args.dependency_mapping:
-        if not os.path.exists(args.dependency_mapping):
-            print(f"Dependency mapping file '{args.dependency_mapping}' does not exist.")
-            sys.exit(1)
-
-        with open(args.dependency_mapping, 'r') as f:
-            for line in f:
-                dep, paths = line.strip().split(': ')
-                dependency_mapping[dep] = [path.strip() for path in paths.split(',')]
-
-    iface = gr.Interface(
-        fn=lambda x: None,
-        inputs=gr.inputs.Textbox(label="URLs (comma-separated)"),
-        outputs="text",
-        title="Project Converter and Uploader",
-        description="Convert and upload projects to Hugging Face Spaces."
+                    return f"Error fetching GitHub issues: {e}"
+        elif y['command'] == "/help":
+            return """Available commands:
+                - `/github`: Analyze a GitHub issue
+                - `/help`: Show this help message
+                - `/generate_code [code description]`: Generate code based on the description
+                - `/explain_concept [concept]`: Explain a concept
+                - `/write_documentation [topic]`: Write documentation for a given topic
+                - `/translate_code [code] to [target language]`: Translate code to another language"""
+        elif y['command'].isdigit() and self.issues:
+            try:
+                issue_number = int(y['command']) - 1
+                self.current_issue = self.issues[issue_number]  # Store the selected issue
+                issue_text = self.current_issue['title'] + "\n\n" + self.current_issue['body']
+                resolution = analyze_issues(issue_text, y['selected_model'], y['severity'], y['programming_language'])
+                related_issues = find_related_issues(issue_text, self.issues)
+                related_issue_text = "\n".join(
+                    [f"- {issue['title']} (Similarity: {similarity:.2f})" for issue, similarity in related_issues]
+                )
+                return f"Resolution for Issue '{self.current_issue['title']}':\n{resolution['assistant_response']}\n\nRelated Issues:\n{related_issue_text}"
+            except Exception as e:
+                return f"Error analyzing issue: {e}"
+        elif y['command'].startswith("/"):
+            # Handle commands like `/generate_code`, `/explain_concept`, etc.
+            if self.current_issue:
+                # Use the current issue's context for these commands
+                issue_text = self.current_issue['title'] + "\n\n" + self.current_issue['body']
+                return analyze_issues(issue_text, y['selected_model'], y['severity'], y['programming_language'])['assistant_response']
+            else:
+                return "Please select an issue first using `/github`."
+        else:
+            # For free-form text, simply display the assistant's response
+            return assistant_response
+
+with gr.Blocks() as demo:
+    with gr.Row():
+        github_api_token = gr.Textbox(label="GitHub API Token", type="password")
+        github_username = gr.Textbox(label="GitHub Username")
+        github_repository = gr.Textbox(label="GitHub Repository")
+
+    system_message = gr.Textbox(
+        value="You are GitBot, the Github project guardian angel. You resolve issues and propose implementation of feature requests",
+        label="System message",
     )
 
-    def process_urls_and_open_browser(urls: str):
-        urls_list = [url.strip() for url in urls.split(',')]
-        process_urls(urls_list, args.api_key, args.action, dependency_mapping)
-        webbrowser.open("http://localhost:7860")
+    model_dropdown = gr.Dropdown(
+        choices=[
+            "mistralai/Mixtral-8x7B-Instruct-v0.1",
+            "Gabriel/Swe-review-setfit-model",
+            "OpenBMB/multilingual-codeparrot"
+        ],
+        label="Select Model for Issue Resolution",
+        value=DEFAULT_MODEL,
+    )
 
-    iface.launch(process_urls_and_open_browser)
+    severity_dropdown = gr.Dropdown(
+        choices=["Critical", "Major", "Minor", "Trivial"],
+        label="Severity",
+        value=None,
+    )
+
+    programming_language_textbox = gr.Textbox(label="Programming Language")
+
+    chatbot = MyChatbot(
+        respond,
+        additional_inputs=[
+            system_message,
+            gr.Slider(minimum=1, maximum=8192, value=2048, step=1, label="Max new tokens"),
+            gr.Slider(minimum=0.1, maximum=4.0, value=0.71, step=0.1, label="Temperature"),
+            gr.Slider(
+                minimum=0.1,
+                maximum=1.0,
+                value=0.95,
+                step=0.01,
+                label="Top-p (nucleus sampling)",
+            ),
+            github_api_token,
+            github_username,
+            github_repository,
+            model_dropdown,
+            severity_dropdown,
+            programming_language_textbox,
+        ],
+    )
+
+    # Add a button to fetch GitHub issues
+    fetch_issues_button = gr.Button(label="Fetch Issues")
+    fetch_issues_button.click(fn=lambda github_api_token, github_username, github_repository: chatbot.issues, inputs=[github_api_token, github_username, github_repository], outputs=[chatbot])
+
+    # Add a dropdown to select an issue
+    issue_dropdown = gr.Dropdown(label="Select Issue", choices=[], interactive=True)
+    issue_dropdown.change(fn=lambda issue_number, chatbot: chatbot.postprocess(issue_number), inputs=[issue_dropdown, chatbot], outputs=[chatbot])
+
+    # Connect the chatbot input to the issue dropdown
+    chatbot.input.change(fn=lambda chatbot, github_api_token, github_username, github_repository: chatbot.postprocess("/github"), inputs=[chatbot, github_api_token, github_username, github_repository], outputs=[chatbot])
 
 if __name__ == "__main__":
-    main()
+    demo.queue().launch(
+        share=True,
+        server_name="0.0.0.0",
+        server_port=7860
+    )