app.py

import gradio as gr
from huggingface_hub import HfApi, create_repo, upload_file
import os

# Global variable for storing the token (persistent while app runs)
hf_token = None

def save_token(token):
    global hf_token
    hf_token = token.strip()
    return f"Token saved! You can now manage your Spaces."

def manage_space(space_name, app_code, req_code):
    global hf_token
    if not hf_token:
        return "Please provide a valid Hugging Face token first."

    if not space_name.strip():
        return "Error: Space name is required."
    if not app_code.strip() or not req_code.strip():
        return "Error: Both `app.py` and `requirements.txt` code are required."

    api = HfApi()
    try:
        # Authenticate using the token
        user_info = api.whoami(token=hf_token)
        space_full_name = f"{user_info['name']}/{space_name.strip()}"

        # Check if Space exists or create a new one
        try:
            api.repo_info(repo_id=space_full_name, repo_type="space", token=hf_token)
            message = f"Space '{space_full_name}' exists. Updating files..."
        except:
            create_repo(repo_id=space_name.strip(), repo_type="space", space_sdk="streamlit", token=hf_token)
            message = f"Space '{space_full_name}' did not exist. Created a new Space."

        # Upload `app.py`
        with open("app.py", "w") as app_file:
            app_file.write(app_code.strip())
        upload_file(
            path_or_fileobj="app.py",
            path_in_repo="app.py",
            repo_id=space_full_name,
            repo_type="space",
            token=hf_token
        )

        # Upload `requirements.txt`
        with open("requirements.txt", "w") as req_file:
            req_file.write(req_code.strip())
        upload_file(
            path_or_fileobj="requirements.txt",
            path_in_repo="requirements.txt",
            repo_id=space_full_name,
            repo_type="space",
            token=hf_token
        )

        # Clean up temporary files
        os.remove("app.py")
        os.remove("requirements.txt")

        return f"{message}\nFiles successfully updated in Space '{space_full_name}'!"

    except Exception as e:
        return f"An error occurred: {e}"

# Gradio interface
token_input = gr.Textbox(label="Hugging Face Token", type="password", placeholder="Enter your token here")
save_token_button = gr.Button("Save Token")

space_name_input = gr.Textbox(label="Space Name", placeholder="Enter the name of your Space")
app_code_input = gr.Textbox(label="app.py Code", lines=15, placeholder="Paste your app.py code here")
req_code_input = gr.Textbox(label="requirements.txt Code", lines=5, placeholder="Paste your requirements.txt content here")
manage_button = gr.Button("Commit Changes")
output = gr.Textbox(label="Output", lines=5)

save_token_interface = gr.Interface(fn=save_token, inputs=token_input, outputs=output)
manage_space_interface = gr.Interface(
    fn=manage_space,
    inputs=[space_name_input, app_code_input, req_code_input],
    outputs=output
)

app = gr.Blocks()

with app:
    with gr.Row():  # Row instead of Box for layout
        gr.Markdown("# Hugging Face Helper")
    with gr.Column():  # Use Column for vertical alignment
        gr.Markdown("### Step 1: Save Your Hugging Face Token")
        token_input.render()
        save_token_button.render()
        save_token_interface.render()

    with gr.Column():  # Use Column for vertical alignment
        gr.Markdown("### Step 2: Manage Your Hugging Face Space")
        space_name_input.render()
        app_code_input.render()
        req_code_input.render()
        manage_button.render()
        manage_space_interface.render()

# Launch the Gradio app
app.launch()