Update app.py

app.py

@@ -1,3 +1,4 @@
+
 import os
 import subprocess
 import random
@@ -7,10 +8,12 @@ from datetime import datetime
 import logging
 
 import gradio as gr
-from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline, huggingface_hub 
-import InferenceClient, cached_download, Repository, HfApi
+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
@@ -59,7 +62,7 @@ def 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_:
+    if selected_model:
         model = load_model(selected_model)
         if model:
             st.write(f"Model {selected_model} imported successfully!")
@@ -72,54 +75,65 @@ 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, cwdproject_path, stdout=subprocess.PIPE, stderr=subprocess.PIPE)        else:
+            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.decode("""utf-8""")
+            return f"Error: {error.decode('utf-8')}"
+        return output.decode('utf-8')
     except Exception as e:
-        return f"""Error executing command: {stre)}"""
-_project(project_name: str, project_path: str = DEFAULT_PROJECTPATH):
+        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 os.path.exists(project_path):
-            return f"""Error: Directory '{project_path}' already exists!"""
+    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 filesoptional, can customize this)        with open(path.join(_path, "README.md"), "w") as f: f.write(f {project_name}\n\nA new Face project.")
-        # Stage all changes        repo.git_add(pattern="*")
+        # 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}'"""
+        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(project_path: str = DEFAULT_PROJECT_PATH) -> str:
+        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 {str()}"""
-def read_file(filepath: str, project_path: str = DEFAULT_PROPATH) -> str """Reads and returns the content of a file in the project."""
+    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:
-_path = os.path.join(project_path, file_path)
+        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(file_: str, content str project_path str =PROJECT_PATH:
+        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, file_path)
-        with open(full_path, "") as f:
-            f.(
-        return"Successfully wrote to '{_path}'"
+        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)}"""
+        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
@@ -133,146 +147,166 @@ def preview(project_path: str = DEFAULT_PROJECT_PATH):
         else:
             return "No 'index.html' found for preview."
     except Exception as e:
-        return f """preview project: {str(e)}"""
+        return f"Error previewing project: {str(e)}"
+
 def main():
-  .Blocks() as demo:
-        gr.Markdown("## IDEvIII: Your Hugging No- App Builder")
-        --- Model Selection ---        with gr.Tab("Model"):            --- Model Drop with Categories ---
+    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"],
+                choices=["Text Generation", "Text Summarization", "Code Generation", "Translation", "Question Answering"],
                 label="Model Category",
-  value=" Generation" )
-           _name = gr.Dropdown(
-  choices=[], # Initially empty, will be pop based on category
-  label="Hugging Face Model Name",
+                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 pop model names category ---
- update_modeldropdown(category):
+
+            # --- 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 ==
-                        models.append(model.modelId)  return gr.Dropdown.update(choices=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_                inputs=model_categories,
+                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[modelname]
+                    return model_descriptions[model_name]
                 else:
-                    return "Model description available."
+                    return "Model description not available."
             model_name.change(
-               =display_model_description,
+                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!"""
+                    return f"Model '{model_name}' loaded successfully!"
                 else:
-                    return f"""Error loading model '{model_name}'"""
+                    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_copy_button, likeable)
-            message = gr.Textbox(Enter your message="Ask me anything!")
-            purpose = gr.Textbox(label="Purpose", placeholder="What is the of this interaction)",
-            agent_name = gr.(label="Ag=Generic Agent", value="Generic Agent", interactive=True)
-            prompt" = gr.Textboxlabel="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 max_newtokens =Slider(labelMax new tokens", value=MAX_TOKENS, minimum=0, maximum=1048 * 10, step=64, interactive=True, info="The maximum numbers of new tokens")
-            top_p = gr.Slider(label="Top-p (nucleus sampling)", valueTOP_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., maximum=2.0,=0.05, interactive=True, info="Penalize repeated tokens")
+        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([])
-            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,]], List[[str, str]]]:
+
+            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, repetition_penalty):
-                if not current_model:
-                    return "Please load a model first."
-                conversation = [{"role": "system", "content sys_pt}]
-                for message, response history:
-                    conversationappend({": "", "content": message})
-                    conversation.append({"": "assistant", "content": response})
-                conversation.append({"role": "user", "content": message})
-                response = currentmodel.generate(
- conversation,
- max_new_tokensmax_new_tokens,
- temperaturetemperature,
-                    top_p=top_p,
-                    repetition_penalty=petition_al
-               )
-                response.text.strip()
-            def create_project(project_name):
-                try:
-                    repo_name = get_full_repo_name(project_name, token=HfApi().token)
-                    repofFolder.create_repo(repo_name, exist_ok=True)
-                    repo.save_data("README.md", f"# {project_name
-                    return f"""'{project_name}' on Hugging Face Hub."""
-                except Exception as e:
-                    return"Error project: {str(e)}
-            def read_file(file_path):
-                if not os.path.exists(file_path):
-                    return f"""{File_path}' does exist."""
-                try
-                    with open(file, "r") as file:                        content = file()
-                 return content
-                as e:
-                    return f"""Error reading file '{file_path}': {str(e)}"""
-            def write_file(file_path, file_content):                try
-                    with open(file_ "w") as file:
-                        file.write(_content)
-                    f"""Wrote to file '{file_path}' successfully."""
-  except Exception as e:
-                    return f"""Error writing to file '{file_path}': {str(e)}"""
-            def run_command(command):
-                try:
-                    result =.run(command shell=True, capture_outputTrue,=True)
-                    if result.returncode == 0:
-                        return result.stdout else:
-                        return f"Command '{command failed with exit code {.}:\n{result.stderr}"
-                except Exception:
-                 return f"""Error running command '{command}': {str(e)}"""
-            def preview():
-                # Get the current working directory
-                cwd = os.getcwd()
-                # Create a temporary directory for the preview
-                temp_dir = tempfile.mkdtemp()
-                try:
-                    Copy the project files the temporary directory
-                    shutil.copytree(cwd, temp_dir, ignore=shutil.ignore_patterns("__py__", "*.pyc"))
-                    # Change to the temporary directory
-                    os.chdir(temp_dir)
-                    # Find the Python file (e.g., app.py, main.py)
-                    main_file = next((f for f in os.listdir(".") if f.endswith(".py")), None)
-                    if main_file:
-                        # Run the main Python file to generate the preview
-                        subprocess.run(["streamlit", "run", main_file], check)
-        # Get preview URL
-                        preview_url = components.get_url(_file)
-        # Change back to original working directory
-        os.chdir(cwd)
-        # Return the preview URL                        return preview_url
-                    else:
-                        return "No main found in the project."
-                except Exception as:
-                    return f"""Error generating preview: {str(e)}"""              finally:
-                 # Remove the directory
-                   .rmtree(tempdir)
-        # Custom server_ = "0.0.0. # Listen on available network interfaces
-        server_port 7606  # an available
-        sharegradio_link = True  # Share a public URL for the app
+                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, server_portserver_port, shareshare_gradio)
-if __name "__main__":
+        demo.launch(server_name=server_name, server_port=server_port, share=share_gradio_link)
+
+if __name__ == "__main__":
     main()