Update app.py

app.py

@@ -8,7 +8,7 @@ import logging
 
 import gradio as gr
 from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
-from huggingface_hub import InferenceClient, cached_download, Repository, HfApi
+ huggingface_hub import InferenceClient, cached_download, Repository, HfApi
 from IPython.display import display, HTML
 import streamlit.components.v1 as components
 
@@ -48,7 +48,7 @@ def load_model(model_name: str):
 
         # Fetch and store the model description
         api = HfApi()
-        model_info = api.model_info(model_name)
+        model_info =.model_info(model_name)
         model_descriptions[model_name] = model_info.pipeline_tag
         return f"Successfully loaded model: {model_name}"
     except Exception as e:
@@ -59,7 +59,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_model:
+    if selected_:
         model = load_model(selected_model)
         if model:
             st.write(f"Model {selected_model} imported successfully!")
@@ -72,65 +72,56 @@ 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, cwdproject_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")
+        return.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):
+        return f"Error executing command: {stre)}"
+_project(project_name: str, project_path: str = DEFAULT_PROJECTPATH):
     """Creates a new Hugging Face project."""
     global repo
-    try:
-        if os.path.exists(project_path):
+    try 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, you 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.")
+        # 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="*")
+        # 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_"
     except Exception as e:
         return f"Error creating Hugging Face project: {str(e)}"
 
-def list_files(project_path: str = DEFAULT_PROJECT_PATH) -> str:
+def list(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)}"
+ except Exception as e:        return f"Error listing project {str()}"
 
-def read_file(file_path: str, project_path: str = DEFAULT_PROJECT_PATH) -> str:
-    """Reads and returns the content of a file in the project."""
+def read_file(filepath: str, project_path: str = DEFAULT_PROPATH) -> str """Reads and returns the content of a file in the project."""
     try:
-        full_path = os.path.join(project_path, file_path)
+_path = os.path.join(project_path, file_path)
         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_path: str, content: str, project_path: str = DEFAULT_PROJECT_PATH) -> str:
+def write_file(file_: str, content str project_path str =PROJECT_PATH:
     """Writes content to a file in the project."""
     try:
-        full_path = os.path.join(project_path, file_path)
-        with open(full_path, "w") as f:
-            f.write(content)
-        return f"Successfully wrote to '{file_path}'"
+        full_path = os.path.join(project, file_path)
+        with open(full_path, "") as f:
+            f.(
+        return"Successfully wrote to '{_path}'"
     except Exception as e:
         return f"Error writing to file: {str(e)}"
 
@@ -147,54 +138,47 @@ def preview(project_path: str = DEFAULT_PROJECT_PATH):
         else:
             return "No 'index.html' found for preview."
     except Exception as e:
-        return f"Error previewing project: {str(e)}"
+        return f preview 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"):
-            # --- Model Dropdown with Categories ---
+   .Blocks() as demo:
+        gr.Markdown("## IDEvIII: Your Hugging No- App Builder")
+        --- Model Selection ---        with gr.Tab("Model"):            --- Model Drop 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="Text Generation"
-            )
-            model_name = gr.Dropdown(
-                choices=[],  # Initially empty, will be populated based on category
-                label="Hugging Face Model Name",
+  value=" Generation" )
+           _name = gr.Dropdown(
+  choices=[], # Initially empty, will be pop 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):
+            # --- Function to pop model names category ---
+ update_modeldropdown(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)
+                    if model.pipeline_tag ==
+                        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,
+                fn=update_model_                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]
+                    return model_descriptions[modelname]
                 else:
-                    return "Model description not available."
+                    return "Model description available."
 
             model_name.change(
-                fn=display_model_description,
+               =display_model_description,
                 inputs=model_name,
                 outputs=model_description,
             )
@@ -211,126 +195,114 @@ def main():
             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.Dropdown(label="Agents", choices=["Generic Agent"], 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 diverse outputs")
-            max_new_tokens = gr.Slider(label="Max 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)", value=TOP_P, minimum=0.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")
+        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")
             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]]]:
+            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]]]:
                 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()
-
-def create_project(project_name):
-    try:
-        repo_name = get_full_repo_name(project_name, token=HfApi().token)
-        repo = HfFolder.create_repo(repo_name, exist_ok=True)
-        repo.save_data("README.md", f"# {project_name}")
-        return f"Created project '{project_name}' on Hugging Face Hub."
-    except Exception as e:
-        return f"Error creating project: {str(e)}"
-
-def read_file(file_path):
-    if not os.path.exists(file_path):
-        return f"File '{file_path}' does not exist."
-
-    try:
-        with open(file_path, "r") as file:
-            content = file.read()
-        return content
-    except Exception as e:
-        return f"Error reading file '{file_path}': {str(e)}"
-
-def write_file(file_path, file_content):
-    try:
-        with open(file_path, "w") as file:
-            file.write(file_content)
-        return 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 = subprocess.run(command, shell=True, capture_output=True, text=True)
-        if result.returncode == 0:
-            return result.stdout
-        else:
-            return f"Command '{command}' failed with exit code {result.returncode}:\n{result.stderr}"
-    except Exception as e:
-        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 to the temporary directory
-        shutil.copytree(cwd, temp_dir, ignore=shutil.ignore_patterns("__pycache__", "*.pyc"))
-
-        # Change to the temporary directory
-        os.chdir(temp_dir)
-
-        # Find the main 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=True)
-
-            # Get the preview URL
-            preview_url = components.get_url(main_file)
-
-            # Change back to the original working directory
-            os.chdir(cwd)
-
-            # Return the preview URL
-            return preview_url
-        else:
-            return "No main Python file found in the project."
-    except Exception as e:
-        return f"Error generating preview: {str(e)}"
-    finally:
-        # Remove the temporary directory
-        shutil.rmtree(temp_dir)
-
-    # Customize the launch 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__":
+            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 760  # an available
+        sharegradio_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__":
     main()