Update app.py

app.py

@@ -1,311 +1,99 @@
 import os
-import subprocess
-import random
+import sys
 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
+import huggingface_hub
 
-# --- Logging Setup ---
-logging.basicConfig(
-    filename="app.log",
-    level=logging.INFO,
-    format="%(asctime)s - %(levelname)s - %(message)s",
-)
+from huggingface_hub.commands import HfFolder
 
-# --- Global Variables ---
-current_model = None  # Store the currently loaded model
-repo = None  # Store the Hugging Face Repository object
-model_descriptions = {}  # Store model descriptions
+import transformers
 
-# --- 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}
-        )
+from transformers import pipeline
 
-        # 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)}"
+import gradio as gr
 
-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
+import tempfile
 
-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)}"
+from huggingface_hub import HfFolder
 
-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 main():
+    # Get the user's idea
+    idea = input("What is your idea for an application? ")
 
-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)}"
+    # Generate the code for the application
+    code = gemmacode.generate(idea)
 
-def read_file(filepath: str, project_path: str = DEFAULT_PROJECT_PATH) -> str:
-    """Reads and returns the content of a file in the project."""
+    # Test the code
     try:
-        full_path = os.path.join(project_path, filepath)
-        with open(full_path, "r") as f:
-            content = f.read()
-        return content
+        transformers.pipeline("text-generation")(code)
     except Exception as e:
-        return f"Error reading file: {str(e)}"
+        print("The code failed to run:", e)
+        return
 
-def write_file(filepath: str, content: str, project_path: str = DEFAULT_PROJECT_PATH) -> str:
-    """Writes content to a file in the project."""
+    # Ensure the functionality of the application
     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}'"
+        gr.Interface(fn=transformers.pipeline("text-generation"), inputs=gr.Textbox(), outputs=gr.Textbox()).launch()
     except Exception as e:
-        return f"Error writing to file: {str(e)}"
+        print("The application failed to run:", e)
+        return
 
-def preview(project_path: str = DEFAULT_PROJECT_PATH):
-    """Provides a preview of the project, if applicable."""
-    # Assuming a simple HTML preview for now
+    # Provide an embedded webapp demo of the user's idea implementation
     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."
+        hf_folder = HfFolder(path=tempfile.mkdtemp())
+        hf_folder.save(code)
+        hf_folder.push_to_hub(repo_id="acecalisto3/gemmacode-demo", commit_message="Initial commit")
+        print(f"The demo is available at: https://huggingface.co/acecalisto3/gemmacode-demo")
     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)
+        print("The demo failed to launch:", e)
+        return
+
+    # Offer the option to rebuild or deploy
+    while True:
+        choice = input("Do you want to rebuild or deploy the application? (r/d/q) ")
+        if choice == "r":
+            # Rebuild the code
+            code = gemmacode.generate(idea)
+
+            # Test the code
+            try:
+                transformers.pipeline("text-generation")(code)
+            except Exception as e:
+                print("The code failed to run:", e)
+                return
+
+            # Ensure the functionality of the application
+            try:
+                gr.Interface(fn=transformers.pipeline("text-generation"), inputs=gr.Textbox(), outputs=gr.Textbox()).launch()
+            except Exception as e:
+                print("The application failed to run:", e)
+                return
+
+            # Provide an embedded webapp demo of the user's idea implementation
+            try:
+                hf_folder = HfFolder(path=tempfile.mkdtemp())
+                hf_folder.save(code)
+                hf_folder.push_to_hub(repo_id="acecalisto3/gemmacode-demo", commit_message="Initial commit")
+                print(f"The demo is available at: https://huggingface.co/acecalisto3/gemmacode-demo")
+            except Exception as e:
+                print("The demo failed to launch:", e)
+                return
+        elif choice == "d":
+            # Deploy the application
+            try:
+                api_token = os.environ["HF_TOKEN"]
+                hub = huggingface_hub.HfApi(api_token=api_token)
+                hub.create_repo(name="my-app", organization="my-org")
+                hf_folder = HfFolder(path=tempfile.mkdtemp())
+                hf_folder.save(code)
+                hf_folder.push_to_hub(repo_id="my-org/my-app", commit_message="Initial commit")
+                print("The application has been deployed to: https://huggingface.co/my-org/my-app")
+            except Exception as e:
+                print("The application failed to deploy:", e)
+                return
+        elif choice == "q":
+            break
+        else:
+            print("Invalid choice")
 
 if __name__ == "__main__":
     main()