app.py

import os
import subprocess
import random
import time
from typing import Dict, List, Tuple
from datetime import datetime
import logging
import huggingface_hub as hfApi
import gradio as gr
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
from huggingface_hub import InferenceClient, cached_download, Repository
from IPython.display import display, HTML
import streamlit.components.v1 as components
import tempfile
import shutil

# --- Configuration ---
VERBOSE = True
MAX_HISTORY = 5
MAX_TOKENS = 2048
TEMPERATURE = 0.7
TOP_P = 0.8
REPETITION_PENALTY = 1.5
DEFAULT_PROJECT_PATH = "./my-hf-project"  # Default project directory

# --- Logging Setup ---
logging.basicConfig(
    filename="app.log",
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
)

# --- Global Variables ---
current_model = None  # Store the currently loaded model
repo = None  # Store the Hugging Face Repository object
model_descriptions = {}  # Store model descriptions

# --- Functions ---
def load_model(model_name: str):
    """Loads a language model and fetches its description."""
    global current_model, model_descriptions
    try:
        tokenizer = AutoTokenizer.from_pretrained(model_name)
        current_model = pipeline(
            "text-generation",
            model=model_name,
            tokenizer=tokenizer,
            model_kwargs={"load_in_8bit": True}
        )

        # Fetch and store the model description
        api = HfApi()
        model_info = api.model_info(model_name)
        model_descriptions[model_name] = model_info.pipeline_tag
        return f"Successfully loaded model: {model_name}"
    except Exception as e:
        return f"Error loading model: {str(e)}"

def model_selection():
    st.title("Model Selection")
    st.write("Select a model to use for code generation:")
    models = ["distilbert", "t5", "codellama-7b", "geminai-1.5b"]
    selected_model = st.selectbox("Select a model:", models)
    if selected_model:
        model = load_model(selected_model)
        if model:
            st.write(f"Model {selected_model} imported successfully!")
            return model
        else:
            st.write(f"Error importing model {selected_model}.")
    return None

def run_command(command: str, project_path: str = None) -> str:
    """Executes a shell command and returns the output."""
    try:
        if project_path:
            process = subprocess.Popen(command, shell=True, cwd=project_path, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        else:
            process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        output, error = process.communicate()
        if error:
            return f"Error: {error.decode('utf-8')}"
        return output.decode('utf-8')
    except Exception as e:
        return f"Error executing command: {str(e)}"

def create_project(project_name: str, project_path: str = DEFAULT_PROJECT_PATH) -> str:
    """Creates a new Hugging Face project."""
    global repo
    try:
        if os.path.exists(project_path):
            return f"Error: Directory '{project_path}' already exists!"
        # Create the repository
        repo = Repository(local_dir=project_path, clone_from=None)
        repo.git_init()
        # Add basic files (optional, can customize this)
        with open(os.path.join(project_path, "README.md"), "w") as f:
            f.write(f"# {project_name}\n\nA new Hugging Face project.")
        # Stage all changes
        repo.git_add(pattern="*")
        repo.git_commit(commit_message="Initial commit")
        return f"Hugging Face project '{project_name}' created successfully at '{project_path}'"
    except Exception as e:
        return f"Error creating Hugging Face project: {str(e)}"

def list_files(project_path: str = DEFAULT_PROJECT_PATH) -> str:
    """Lists files in the project directory."""
    try:
        files = os.listdir(project_path)
        if not files:
            return "Project directory is empty."
        return "\n".join(files)
    except Exception as e:
        return f"Error listing project files: {str(e)}"

def read_file(filepath: str, project_path: str = DEFAULT_PROJECT_PATH) -> str:
    """Reads and returns the content of a file in the project."""
    try:
        full_path = os.path.join(project_path, filepath)
        with open(full_path, "r") as f:
            content = f.read()
        return content
    except Exception as e:
        return f"Error reading file: {str(e)}"

def write_file(filepath: str, content: str, project_path: str = DEFAULT_PROJECT_PATH) -> str:
    """Writes content to a file in the project."""
    try:
        full_path = os.path.join(project_path, filepath)
        with open(full_path, "w") as f:
            f.write(content)
        return f"Successfully wrote to '{full_path}'"
    except Exception as e:
        return f"Error writing to file: {str(e)}"

def preview(project_path: str = DEFAULT_PROJECT_PATH):
    """Provides a preview of the project, if applicable."""
    # Assuming a simple HTML preview for now
    try:
        index_html_path = os.path.join(project_path, "index.html")
        if os.path.exists(index_html_path):
            with open(index_html_path, "r") as f:
                html_content = f.read()
            display(HTML(html_content))
            return "Previewing 'index.html'"
        else:
            return "No 'index.html' found for preview."
    except Exception as e:
        return f"Error previewing project: {str(e)}"

def main():
    with gr.Blocks() as demo:
        gr.Markdown("## IDEvIII: Your Hugging Face No-Code App Builder")

        # --- Model Selection ---
        with gr.Tab("Model Selection"):
            # --- Model Dropdown with Categories ---
            model_categories = gr.Dropdown(
                choices=["Text Generation", "Text Summarization", "Code Generation", "Translation", "Question Answering"],
                label="Model Category",
                value="Text Generation"
            )
            model_name = gr.Dropdown(
                choices=[],  # Initially empty, will be populated based on category
                label="Hugging Face Model Name",
            )
            load_button = gr.Button("Load Model")
            load_output = gr.Textbox(label="Output")
            model_description = gr.Markdown(label="Model Description")

            # --- Function to populate model names based on category ---
            def update_model_dropdown(category):
                models = []
                api = HfApi()
                for model in api.list_models():
                    if model.pipeline_tag == category:
                        models.append(model.modelId)
                return gr.Dropdown.update(choices=models)

            # --- Event handler for category dropdown ---
            model_categories.change(
                fn=update_model_dropdown,
                inputs=model_categories,
                outputs=model_name,
            )

            # --- Event handler to display model description ---
            def display_model_description(model_name):
                global model_descriptions
                if model_name in model_descriptions:
                    return model_descriptions[model_name]
                else:
                    return "Model description not available."
            model_name.change(
                fn=display_model_description,
                inputs=model_name,
                outputs=model_description,
            )

            # --- Event handler to load the selected model ---
            def load_selected_model(model_name):
                global current_model
                load_output = load_model(model_name)
                if current_model:
                    return f"Model '{model_name}' loaded successfully!"
                else:
                    return f"Error loading model '{model_name}'"
            load_button.click(load_selected_model, inputs=model_name, outputs=load_output)

        # --- Chat Interface ---
        with gr.Tab("Chat"):
            chatbot = gr.Chatbot(show_label=False, show_share_button=False, show_copy_button=True, likeable=True)
            message = gr.Textbox(label="Enter your message", placeholder="Ask me anything!")
            purpose = gr.Textbox(label="Purpose", placeholder="What is the purpose of this interaction?")
            agent_name = gr.Textbox(label="Agent Name", value="Generic Agent", interactive=True)
            sys_prompt = gr.Textbox(label="System Prompt", max_lines=1, interactive=True)
            temperature = gr.Slider(label="Temperature", value=TEMPERATURE, minimum=0.0, maximum=1.0, step=0.05, interactive=True, info="Higher values produce more random results")
            max_new_tokens = gr.Slider(label="Max new tokens", value=MAX_TOKENS, minimum=0, maximum=1048 * 10, step=64, interactive=True, info="The maximum number of new tokens")
            top_p = gr.Slider(label="Top-p (nucleus sampling)", value=TOP_P, minimum=0, maximum=1, step=0.05, interactive=True, info="Higher values sample more low-probability tokens")
            repetition_penalty = gr.Slider(label="Repetition penalty", value=REPETITION_PENALTY, minimum=1.0, maximum=2.0, step=0.05, interactive=True, info="Penalize repeated tokens")
            submit_button = gr.Button(value="Send")
            history = gr.State([])

            def run_chat(purpose: str, message: str, agent_name: str, sys_prompt: str, temperature: float, max_new_tokens: int, top_p: float, repetition_penalty: float, history: List[Tuple[str, str]]) -> Tuple[List[Tuple[str, str]], List[Tuple[str, str]]]:
                if not current_model:
                    return [(history, history), "Please load a model first."]
                def generate_response(message, history, agent_name, sys_prompt, temperature, max_new_tokens, top_p, repetition_penalty):
                    if not current_model:
                        return "Please load a model first."
                    conversation = [{"role": "system", "content": sys_prompt}]
                    for message, response in history:
                        conversation.append({"role": "user", "content": message})
                        conversation.append({"role": "assistant", "content": response})
                    conversation.append({"role": "user", "content": message})
                    response = current_model.generate(
                        conversation,
                        max_new_tokens=max_new_tokens,
                        temperature=temperature,
                        top_p=top_p,
                        repetition_penalty=repetition_penalty
                    )
                    return response.text.strip()
                response_text = generate_response(message, history, agent_name, sys_prompt, temperature, max_new_tokens, top_p, repetition_penalty)
                history.append((message, response_text))
                return history, history

            submit_button.click(run_chat, inputs=[purpose, message, agent_name, sys_prompt, temperature, max_new_tokens, top_p, repetition_penalty, history], outputs=[chatbot, history])

        # --- Project Management ---
        with gr.Tab("Project Management"):
            project_name_input = gr.Textbox(label="Project Name", placeholder="Enter project name")
            create_project_button = gr.Button("Create Project")
            project_output = gr.Textbox(label="Output")

            def create_project_action(project_name):
                return create_project(project_name)

            create_project_button.click(create_project_action, inputs=project_name_input, outputs=project_output)

            list_files_button = gr.Button("List Files")
            list_files_output = gr.Textbox(label="Files")

            def list_files_action():
                return list_files()

            list_files_button.click(list_files_action, outputs=list_files_output)

            file_path_input = gr.Textbox(label="File Path", placeholder="Enter file path")
            read_file_button = gr.Button("Read File")
            read_file_output = gr.Textbox(label="File Content")

            def read_file_action(file_path):
                return read_file(file_path)

            read_file_button.click(read_file_action, inputs=file_path_input, outputs=read_file_output)

            write_file_button = gr.Button("Write File")
            file_content_input = gr.Textbox(label="File Content", placeholder="Enter file content")

            def write_file_action(file_path, file_content):
                return write_file(file_path, file_content)

            write_file_button.click(write_file_action, inputs=[file_path_input, file_content_input], outputs=project_output)

            run_command_input = gr.Textbox(label="Command", placeholder="Enter command")
            run_command_button = gr.Button("Run Command")
            run_command_output = gr.Textbox(label="Command Output")

            def run_command_action(command):
                return run_command(command)

            run_command_button.click(run_command_action, inputs=run_command_input, outputs=run_command_output)

            preview_button = gr.Button("Preview Project")
            preview_output = gr.Textbox(label="Preview URL")

            def preview_action():
                return preview()

            preview_button.click(preview_action, outputs=preview_output)

        # Custom server settings
        server_name = "0.0.0.0"  # Listen on all available network interfaces
        server_port = 8888  # Choose an available port
        share_gradio_link = True  # Share a public URL for the app

        # Launch the interface
        demo.launch(server_name=server_name, server_port=server_port, share=share_gradio_link)

if __name__ == "__main__":
    main()