Update app.py

app.py

@@ -1,21 +1,12 @@
 import streamlit as st
 import os
 import subprocess
+import random
+import string
+from huggingface_hub import cached_download, hf_hub_url
 from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
 import black
-from pylint import lint
-from io import StringIO
-import sys
-
-PROJECT_ROOT = "projects"
-
-# Global state to manage communication between Tool Box and Workspace Chat App
-if 'chat_history' not in st.session_state:
-    st.session_state.chat_history = []
-if 'terminal_history' not in st.session_state:
-    st.session_state.terminal_history = []
-if 'workspace_projects' not in st.session_state:
-    st.session_state.workspace_projects = {}
+import pylint
 
 # Define functions for each feature
 
@@ -29,36 +20,22 @@ def chat_interface(input_text):
     Returns:
         The chatbot's response.
     """
-    # Load the GPT-2 model which is compatible with AutoModelForCausalLM
-    model_name = "gpt2"
-    try:
-        model = AutoModelForCausalLM.from_pretrained(model_name)
-        tokenizer = AutoTokenizer.from_pretrained(model_name)
-        generator = pipeline("text-generation", model=model, tokenizer=tokenizer)
-    except EnvironmentError as e:
-        return f"Error loading model: {e}"
-
-    # Truncate input text to avoid exceeding the model's maximum length
-    max_input_length = 900
-    input_ids = tokenizer.encode(input_text, return_tensors="pt")
-    if input_ids.shape[1] > max_input_length:
-        input_ids = input_ids[:, :max_input_length]
+    # Load the appropriate language model from Hugging Face
+    model_name = 'google/flan-t5-xl'  # Choose a suitable model
+    model_url = hf_hub_url(repo_id=model_name, revision='main', filename='config.json')
+    model_path = cached_download(model_url)
+    generator = pipeline('text-generation', model=model_path)
 
     # Generate chatbot response
-    outputs = model.generate(
-        input_ids, max_new_tokens=50, num_return_sequences=1, do_sample=True
-    )
-    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    response = generator(input_text, max_length=50, num_return_sequences=1, do_sample=True)[0]['generated_text']
     return response
 
-
 # 2. Terminal
-def terminal_interface(command, project_name=None):
+def terminal_interface(command):
     """Executes commands in the terminal.
 
     Args:
         command: User's command.
-        project_name: Name of the project workspace to add installed packages.
 
     Returns:
         The terminal output.
@@ -67,18 +44,10 @@ def terminal_interface(command, project_name=None):
     try:
         process = subprocess.run(command.split(), capture_output=True, text=True)
         output = process.stdout
-
-        # If the command is to install a package, update the workspace
-        if "install" in command and project_name:
-            requirements_path = os.path.join(PROJECT_ROOT, project_name, "requirements.txt")
-            with open(requirements_path, "a") as req_file:
-                package_name = command.split()[-1]
-                req_file.write(f"{package_name}\n")
     except Exception as e:
-        output = f"Error: {e}"
+        output = f'Error: {e}'
     return output
 
-
 # 3. Code Editor
 def code_editor_interface(code):
     """Provides code completion, formatting, and linting in the code editor.
@@ -97,19 +66,14 @@ def code_editor_interface(code):
 
     # Lint code using pylint
     try:
-        pylint_output = StringIO()
-        sys.stdout = pylint_output
-        sys.stderr = pylint_output
-        lint.Run(['--from-stdin'], stdin=StringIO(formatted_code))
-        sys.stdout = sys.__stdout__
-        sys.stderr = sys.__stderr__
-        lint_message = pylint_output.getvalue()
+        pylint_output = pylint.run(formatted_code, output=None)
+        lint_results = pylint_output.linter.stats.get('global_note', 0)
+        lint_message = f"Pylint score: {lint_results:.2f}"
     except Exception as e:
         lint_message = f"Pylint error: {e}"
 
     return formatted_code, lint_message
 
-
 # 4. Workspace
 def workspace_interface(project_name):
     """Manages projects, files, and resources in the workspace.
@@ -120,43 +84,14 @@ def workspace_interface(project_name):
     Returns:
         Project creation status.
     """
-    project_path = os.path.join(PROJECT_ROOT, project_name)
     # Create project directory
     try:
-        os.makedirs(project_path)
-        requirements_path = os.path.join(project_path, "requirements.txt")
-        with open(requirements_path, "w") as req_file:
-            req_file.write("")  # Initialize an empty requirements.txt file
-        status = f'Project "{project_name}" created successfully.'
-        st.session_state.workspace_projects[project_name] = {'files': []}
+        os.makedirs(os.path.join('projects', project_name))
+        status = f'Project \"{project_name}\" created successfully.'
     except FileExistsError:
-        status = f'Project "{project_name}" already exists.'
-    return status
-
-def add_code_to_workspace(project_name, code, file_name):
-    """Adds selected code files to the workspace.
-
-    Args:
-        project_name: Name of the project.
-        code: Code to be added.
-        file_name: Name of the file to be created.
-
-    Returns:
-        File creation status.
-    """
-    project_path = os.path.join(PROJECT_ROOT, project_name)
-    file_path = os.path.join(project_path, file_name)
-
-    try:
-        with open(file_path, "w") as code_file:
-            code_file.write(code)
-        status = f'File "{file_name}" added to project "{project_name}" successfully.'
-        st.session_state.workspace_projects[project_name]['files'].append(file_name)
-    except Exception as e:
-        status = f"Error: {e}"
+        status = f'Project \"{project_name}\" already exists.'
     return status
 
-
 # 5. AI-Infused Tools
 
 # Define custom AI-powered tools using Hugging Face models
@@ -171,72 +106,13 @@ def summarize_text(text):
     Returns:
         Summarized text.
     """
-    # Load the summarization model
-    model_name = "facebook/bart-large-cnn"
-    try:
-        summarizer = pipeline("summarization", model=model_name)
-    except EnvironmentError as e:
-        return f"Error loading model: {e}"
-
-    # Truncate input text to avoid exceeding the model's maximum length
-    max_input_length = 1024
-    inputs = text
-    if len(text) > max_input_length:
-        inputs = text[:max_input_length]
-
-    # Generate summary
-    summary = summarizer(inputs, max_length=100, min_length=30, do_sample=False)[0][
-        "summary_text"
-    ]
+    summarizer = pipeline('summarization', model='facebook/bart-large-cnn')
+    summary = summarizer(text, max_length=100, min_length=30)[0]['summary_text']
     return summary
 
-# Example: Sentiment analysis tool
-def sentiment_analysis(text):
-    """Performs sentiment analysis on a given text using a Hugging Face model.
-
-    Args:
-        text: Text to be analyzed.
-
-    Returns:
-        Sentiment analysis result.
-    """
-    # Load the sentiment analysis model
-    model_name = "distilbert-base-uncased-finetuned-sst-2-english"
-    try:
-        analyzer = pipeline("sentiment-analysis", model=model_name)
-    except EnvironmentError as e:
-        return f"Error loading model: {e}"
-
-    # Perform sentiment analysis
-    result = analyzer(text)[0]
-    return result
-
-# Example: Text translation tool
-def translate_text(text, target_language="fr"):
-    """Translates a given text to the target language using a Hugging Face model.
-
-    Args:
-        text: Text to be translated.
-        target_language: The language to translate the text to.
-
-    Returns:
-        Translated text.
-    """
-    # Load the translation model
-    model_name = f"Helsinki-NLP/opus-mt-en-{target_language}"
-    try:
-        translator = pipeline("translation", model=model_name)
-    except EnvironmentError as e:
-        return f"Error loading model: {e}"
-
-    # Translate text
-    translated_text = translator(text)[0]["translation_text"]
-    return translated_text
-
-
 # 6. Code Generation
 def generate_code(idea):
-    """Generates code based on a given idea using the EleutherAI/gpt-neo-2.7B model.
+    """Generates code based on a given idea using the bigscience/T0_3B model.
 
     Args:
         idea: The idea for the code to be generated.
@@ -246,12 +122,9 @@ def generate_code(idea):
     """
 
     # Load the code generation model
-    model_name = "EleutherAI/gpt-neo-2.7B"
-    try:
-        model = AutoModelForCausalLM.from_pretrained(model_name)
-        tokenizer = AutoTokenizer.from_pretrained(model_name)
-    except EnvironmentError as e:
-        return f"Error loading model: {e}"
+    model_name = 'bigscience/T0_3B'  # Choose your model
+    model = AutoModelForCausalLM.from_pretrained(model_name)
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
 
     # Generate the code
     input_text = f"""
@@ -275,120 +148,63 @@ def generate_code(idea):
 
     return generated_code
 
-
 # Streamlit App
 st.title("CodeCraft: Your AI-Powered Development Toolkit")
 
-# Sidebar navigation
-st.sidebar.title("Navigation")
-app_mode = st.sidebar.selectbox("Choose the app mode", ["Tool Box", "Workspace Chat App"])
-
-if app_mode == "Tool Box":
-    # Tool Box
-    st.header("AI-Powered Tools")
-
-    # Chat Interface
-    st.subheader("Chat with CodeCraft")
-    chat_input = st.text_area("Enter your message:")
-    if st.button("Send"):
-        chat_response = chat_interface(chat_input)
-        st.session_state.chat_history.append((chat_input, chat_response))
-        st.write(f"CodeCraft: {chat_response}")
-
-    # Terminal Interface
-    st.subheader("Terminal")
-    terminal_input = st.text_input("Enter a command:")
-    if st.button("Run"):
-        terminal_output = terminal_interface(terminal_input)
-        st.session_state.terminal_history.append((terminal_input, terminal_output))
-        st.code(terminal_output, language="bash")
-
-    # Code Editor Interface
-    st.subheader("Code Editor")
-    code_editor = st.text_area("Write your code:", height=300)
-    if st.button("Format & Lint"):
-        formatted_code, lint_message = code_editor_interface(code_editor)
-        st.code(formatted_code, language="python")
-        st.info(lint_message)
-
-    # Text Summarization Tool
-    st.subheader("Summarize Text")
-    text_to_summarize = st.text_area("Enter text to summarize:")
-    if st.button("Summarize"):
-        summary = summarize_text(text_to_summarize)
-        st.write(f"Summary: {summary}")
-
-    # Sentiment Analysis Tool
-    st.subheader("Sentiment Analysis")
-    sentiment_text = st.text_area("Enter text for sentiment analysis:")
-    if st.button("Analyze Sentiment"):
-        sentiment = sentiment_analysis(sentiment_text)
-        st.write(f"Sentiment: {sentiment}")
-
-    # Text Translation Tool
-    st.subheader("Translate Text")
-    translation_text = st.text_area("Enter text to translate:")
-    target_language = st.text_input("Enter target language code (e.g., 'fr' for French):")
-    if st.button("Translate"):
-        translated_text = translate_text(translation_text, target_language)
-        st.write(f"Translated Text: {translated_text}")
-
-    # Code Generation
-    st.subheader("Code Generation")
-    code_idea = st.text_input("Enter your code idea:")
-    if st.button("Generate Code"):
+# Workspace Selection
+st.header("Select Workspace")
+project_name = st.selectbox("Choose a project", os.listdir('projects'))
+
+# Chat Interface
+st.header("Chat with CodeCraft")
+chat_input = st.text_area("Enter your message:")
+if st.button("Send"):
+    chat_response = chat_interface(chat_input)
+    st.write(f"CodeCraft: {chat_response}")
+
+# Terminal Interface
+st.header("Terminal")
+terminal_input = st.text_input("Enter a command:")
+if st.button("Run"):
+    terminal_output = terminal_interface(terminal_input)
+    st.code(terminal_output, language="bash")
+
+# Code Editor Interface
+st.header("Code Editor")
+code_editor = st.text_area("Write your code:", language="python", height=300)
+if st.button("Format & Lint"):
+    formatted_code, lint_message = code_editor_interface(code_editor)
+    st.code(formatted_code, language="python")
+    st.info(lint_message)
+
+# AI-Infused Tools
+st.header("AI-Powered Tools")
+text_to_summarize = st.text_area("Enter text to summarize:")
+if st.button("Summarize"):
+    summary = summarize_text(text_to_summarize)
+    st.write(f"Summary: {summary}")
+
+# Code Generation
+st.header("Code Generation")
+code_idea = st.text_input("Enter your code idea:")
+if st.button("Generate Code"):
+    try:
         generated_code = generate_code(code_idea)
         st.code(generated_code, language="python")
+    except Exception as e:
+        st.error(f"Error generating code: {e}")
 
-elif app_mode == "Workspace Chat App":
-    # Workspace Chat App
-    st.header("Workspace Chat App")
-
-    # Project Workspace Creation
-    st.subheader("Create a New Project")
-    project_name = st.text_input("Enter project name:")
-    if st.button("Create Project"):
-        workspace_status = workspace_interface(project_name)
-        st.success(workspace_status)
-
-    # Add Code to Workspace
-    st.subheader("Add Code to Workspace")
-    code_to_add = st.text_area("Enter code to add to workspace:")
-    file_name = st.text_input("Enter file name (e.g., 'app.py'):")
-    if st.button("Add Code"):
-        add_code_status = add_code_to_workspace(project_name, code_to_add, file_name)
-        st.success(add_code_status)
-
-    # Terminal Interface with Project Context
-    st.subheader("Terminal (Workspace Context)")
-    terminal_input = st.text_input("Enter a command within the workspace:")
-    if st.button("Run Command"):
-        terminal_output = terminal_interface(terminal_input, project_name)
-        st.code(terminal_output, language="bash")
-
-    # Chat Interface for Guidance
-    st.subheader("Chat with CodeCraft for Guidance")
-    chat_input = st.text_area("Enter your message for guidance:")
-    if st.button("Get Guidance"):
-        chat_response = chat_interface(chat_input)
-        st.session_state.chat_history.append((chat_input, chat_response))
-        st.write(f"CodeCraft: {chat_response}")
-
-    # Display Chat History
-    st.subheader("Chat History")
-    for user_input, response in st.session_state.chat_history:
-        st.write(f"User: {user_input}")
-        st.write(f"CodeCraft: {response}")
-
-    # Display Terminal History
-    st.subheader("Terminal History")
-    for command, output in st.session_state.terminal_history:
-        st.write(f"Command: {command}")
-        st.code(output, language="bash")
-
-    # Display Projects and Files
-    st.subheader("Workspace Projects")
-    for project, details in st.session_state.workspace_projects.items():
-        st.write(f"Project: {project}")
-        for file in details['files']:
-            st.write(f"  - {file}")
+# Launch Chat App
+if st.button("Launch Chat App"):
+    # Get the current working directory
+    cwd = os.getcwd()
+
+    # Construct the command to launch the chat app
+    command = f"cd projects/{project_name} && streamlit run chat_app.py"
+
+    # Execute the command
+    try:
+        process = subprocess.run(command.split(), capture_output=True, text=True)
+        st.write(f"Chat app launched successfully!")
+    except Exception as e:
+        st.error(f"Error launching chat app: {e}")