app.py

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, huggingface_hub 
import InferenceClient, cached_download, Repository, HfApi
from IPython.display import display, HTML
import streamlit.components.v1 as components

# --- 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 = 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, 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.decode("""utf-8""")
    except Exception as e:
        return f"""Error executing command: {stre)}"""
_project(project_name: str, project_path: str = DEFAULT_PROJECTPATH):
    """Creates a new Hugging Face project."""
    global repo
    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 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="*")
        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(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."""
    try:
_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_: str, content str project_path str =PROJECT_PATH:
    """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}'"
    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 """preview 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 ---
            model_categories = gr.Dropdown(
                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",
            )
            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):
                models = []
                api = HfApi()
                for model in api.list_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_                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]
                else:
                    return "Model description available."
            model_name.change(
               =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_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([])
            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, 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
        # Launch the interface
        demo.launch(server_name=server, server_portserver_port, shareshare_gradio)
if __name "__main__":
    main()