Spaces:
Paused
Paused
| import os | |
| import subprocess | |
| import random | |
| import time | |
| from typing import Dict, List, Tuple | |
| from datetime import datetime | |
| import logging | |
| import gradio as gr | |
| from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline, HfApi | |
| 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 = 7860 # 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() |