Update app.py

app.py

@@ -12,11 +12,12 @@ def get_hf_api(token):
     """Initializes the HfApi client. Allows read-only operations if no token is provided."""
     return HfApi(token=token if token else None)
 
-# --- UI Functions (Original Tab) ---
+# --- UI Functions ---
 
 def handle_token_change(token):
     """
-    Called when the token is entered. Fetches user info and updates UI interactivity.
+    Called when the token is entered. Fetches user info, updates UI interactivity,
+    and auto-fills the author fields in both tabs.
     """
     if not token:
         # No token, disable write actions and clear user-specific info
@@ -25,24 +26,26 @@ def handle_token_change(token):
             delete_repo_btn: gr.update(interactive=False),
             commit_btn: gr.update(interactive=False),
             author_input: gr.update(value=""),
+            download_author_input: gr.update(value=""),
             whoami_output: gr.update(value=None, visible=False)
         }
-        return (None, "", *update_dict.values())
+        return (None, *update_dict.values())
 
     try:
         api = get_hf_api(token)
         user_info = api.whoami()
         username = user_info.get('name')
         
-        # Token is valid, enable write actions and set author
+        # Token is valid, enable write actions and set author everywhere
         update_dict = {
             manage_files_btn: gr.update(interactive=True),
             delete_repo_btn: gr.update(interactive=True),
             commit_btn: gr.update(interactive=True),
             author_input: gr.update(value=username),
+            download_author_input: gr.update(value=username),
             whoami_output: gr.update(value=user_info, visible=True)
         }
-        return (token, username, *update_dict.values())
+        return (token, *update_dict.values())
 
     except HfHubHTTPError as e:
         gr.Warning(f"Invalid Token: {e}. You can only perform read-only actions.")
@@ -52,81 +55,106 @@ def handle_token_change(token):
             commit_btn: gr.update(interactive=False),
             whoami_output: gr.update(value=None, visible=False)
         }
-        return (token, "", *update_dict.values())
+        return (token, *update_dict.values())
 
 
 def list_repos(token, author, repo_type):
-    """Lists repositories for a given author and type."""
+    """Lists repositories for a given author and type into a dropdown."""
     if not author:
         gr.Info("Please enter an author (username or organization) to list repositories.")
-        return gr.update(choices=[], value=None), gr.update(visible=False), gr.update(visible=False)
+        return gr.update(choices=[], value=None)
     try:
         api = get_hf_api(token)
-        # Use the dedicated list functions for clarity e.g. api.list_models, api.list_spaces
         list_fn = getattr(api, f"list_{repo_type}s")
         repos = list_fn(author=author)
         repo_ids = [repo.id for repo in repos]
-        return gr.update(choices=repo_ids, value=None), gr.update(visible=False), gr.update(visible=False)
+        gr.Info(f"Found {len(repo_ids)} {repo_type}s for '{author}'.")
+        return gr.update(choices=repo_ids, value=None)
     except HfHubHTTPError as e:
         gr.Error(f"Could not list repositories: {e}")
-        return gr.update(choices=[], value=None), gr.update(visible=False), gr.update(visible=False)
+        return gr.update(choices=[], value=None)
 
-def handle_repo_selection(repo_id):
-    """Called when a repo is selected. Makes action buttons visible."""
+def on_manage_repo_select(repo_id):
+    """Called when a repo is selected in the Manage tab. Makes action buttons visible."""
     if repo_id:
-        return gr.update(visible=True), gr.update(visible=False) # Show actions, hide editor
-    return gr.update(visible=False), gr.update(visible=False) # Hide everything
+        return gr.update(visible=True) # Show actions
+    return gr.update(visible=False) # Hide actions
 
 def delete_repo(token, repo_id, repo_type):
     """Deletes the selected repository."""
     if not token:
         gr.Error("A write-enabled Hugging Face token is required to delete a repository.")
-        return repo_id, gr.update(visible=True), gr.update(visible=False)
+        return repo_id
     if not repo_id:
         gr.Warning("No repository selected to delete.")
-        return repo_id, gr.update(visible=True), gr.update(visible=False)
+        return repo_id
     try:
         api = get_hf_api(token)
         api.delete_repo(repo_id=repo_id, repo_type=repo_type)
         gr.Info(f"Successfully deleted '{repo_id}'.")
-        return None, gr.update(visible=False), gr.update(visible=False)
+        # After deletion, hide panels and return None to clear selection
+        return None
     except HfHubHTTPError as e:
         gr.Error(f"Failed to delete repository: {e}")
-        return repo_id, gr.update(visible=True), gr.update(visible=False)
+        return repo_id # Keep repo selected on failure
 
-# --- File Editor Functions (Original Tab) ---
+# --- File Management Functions ---
 
-def show_file_manager(token, repo_id, repo_type):
+def show_files_and_load_first(token, repo_id, repo_type):
+    """Lists files and pre-loads the first file's content for editing."""
     if not repo_id:
         gr.Warning("No repository selected.")
-        return gr.update(visible=False), gr.update(), gr.update(), gr.update()
+        return gr.update(visible=False), gr.update(), gr.update()
     try:
         api = get_hf_api(token)
         repo_files = api.list_repo_files(repo_id=repo_id, repo_type=repo_type)
         filtered_files = [f for f in repo_files if not f.startswith('.')]
+
+        if not filtered_files:
+            return (
+                gr.update(visible=True),
+                gr.update(choices=[], value=None),
+                gr.update(value="## This repository is empty or contains only hidden files.", language='markdown')
+            )
+        
+        # Load the content of the first file automatically
+        first_file_path = filtered_files[0]
+        content, language = load_file_content_backend(token, repo_id, repo_type, first_file_path)
+
         return (
-            gr.update(visible=True), gr.update(choices=filtered_files, value=None),
-            gr.update(value="## Select a file to view or edit.", language='markdown'), ""
+            gr.update(visible=True),
+            gr.update(choices=filtered_files, value=first_file_path),
+            gr.update(value=content, language=language)
         )
     except Exception as e:
         gr.Error(f"Could not list files: {e}")
-        return gr.update(visible=False), gr.update(), gr.update(), gr.update()
+        return gr.update(visible=False), gr.update(), gr.update()
 
-def load_file_content(token, repo_id, repo_type, filepath):
+def load_file_content_backend(token, repo_id, repo_type, filepath):
+    """Backend logic to fetch and format file content. Returns content and language."""
     if not filepath:
-        return gr.update(value="## Select a file to view its content.", language='markdown')
+        return "## Select a file to view its content.", 'markdown'
     try:
         api = get_hf_api(token)
         local_path = api.hf_hub_download(repo_id=repo_id, repo_type=repo_type, filename=filepath, token=token)
-        with open(local_path, 'r', encoding='utf-8') as f: content = f.read()
+        with open(local_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        
         language = os.path.splitext(filepath)[1].lstrip('.').lower()
-        if language == 'py': language = 'python'
-        if language == 'js': language = 'javascript'
-        if language == 'md': language = 'markdown'
-        else: language = 'python'
-        return gr.update(value=content, language=language)
+        if language in ['py', 'python']: language = 'python'
+        elif language == 'js': language = 'javascript'
+        elif language == 'md': language = 'markdown'
+        else: language = 'plaintext' # Default
+            
+        return content, language
     except Exception as e:
-        return gr.update(value=f"Error loading file: {e}", language='plaintext')
+        return f"Error loading file: {e}", 'plaintext'
+
+def load_file_content_for_editor(token, repo_id, repo_type, filepath):
+    """Gradio wrapper to update the code editor when a new file is selected."""
+    content, language = load_file_content_backend(token, repo_id, repo_type, filepath)
+    return gr.update(value=content, language=language)
+
 
 def commit_file(token, repo_id, repo_type, filepath, content, commit_message):
     if not token: gr.Error("A write-enabled token is required."); return
@@ -144,94 +172,54 @@ def commit_file(token, repo_id, repo_type, filepath, content, commit_message):
 
 # --- Download Tab Functions ---
 
-def list_spaces_for_download(token, author):
-    """Lists spaces for a given author to populate the dropdown."""
-    if not author:
-        gr.Info("Please enter an author (username or organization) to list spaces.")
-        return gr.update(choices=[], value=None)
-    try:
-        api = get_hf_api(token)
-        spaces = api.list_spaces(author=author)
-        repo_ids = [space.id for space in spaces]
-        if not repo_ids:
-            gr.Warning(f"No Spaces found for author '{author}'.")
-        return gr.update(choices=repo_ids, value=None)
-    except RepositoryNotFoundError:
-        gr.Warning(f"Author '{author}' not found or has no public spaces.")
-        return gr.update(choices=[], value=None)
-    except HfHubHTTPError as e:
-        gr.Error(f"Could not list spaces: {e}")
-        return gr.update(choices=[], value=None)
-
-def download_spaces_as_zip(token, selected_space_ids, progress=gr.Progress()):
-    """Downloads selected spaces and zips them up."""
-    if not selected_space_ids:
-        gr.Warning("No spaces selected for download.")
+def download_repos_as_zip(token, selected_repo_ids, repo_type, progress=gr.Progress()):
+    """Downloads selected repos of a given type and zips them up."""
+    if not selected_repo_ids:
+        gr.Warning("No repositories selected for download.")
+        return gr.update(visible=False, value=None)
+    if not repo_type:
+        gr.Warning("Please list a repository type (Spaces, Models, etc.) before downloading.")
         return gr.update(visible=False, value=None)
 
-    # Create a temporary directory for all the downloaded content
     download_root_dir = tempfile.mkdtemp()
-    
     try:
-        total_spaces = len(selected_space_ids)
+        total_repos = len(selected_repo_ids)
         progress(0, desc="Starting download...")
 
-        # 1. Download each space into a dedicated subfolder within the temp directory
-        for i, repo_id in enumerate(selected_space_ids):
-            progress((i) / total_spaces, desc=f"Downloading {repo_id} ({i+1}/{total_spaces})")
-            
-            # Sanitize repo_id to create a valid folder name for the zip
+        for i, repo_id in enumerate(selected_repo_ids):
+            progress((i) / total_repos, desc=f"Downloading {repo_id} ({i+1}/{total_repos})")
             folder_name = repo_id.replace("/", "__")
             target_path = os.path.join(download_root_dir, folder_name)
 
             try:
-                # Use snapshot_download to get the entire repo efficiently
                 snapshot_download(
-                    repo_id=repo_id,
-                    repo_type="space",
-                    local_dir=target_path,
-                    token=token,
-                    local_dir_use_symlinks=False, # Crucial for zipping
-                    resume_download=True,
+                    repo_id=repo_id, repo_type=repo_type, local_dir=target_path,
+                    token=token, local_dir_use_symlinks=False, resume_download=True,
                 )
             except Exception as e:
-                # Log the error and skip this repo
                 gr.Error(f"Failed to download {repo_id}: {e}")
                 continue
 
-        # 2. Create the zip archive from the directory of downloaded spaces
-        progress(0.95, desc="All spaces downloaded. Creating ZIP file...")
-        
-        # We create the zip file outside the download dir so we can clean up easily
-        zip_base_name = os.path.join(tempfile.gettempdir(), f"hf_spaces_archive_{uuid.uuid4().hex}")
-        
-        # shutil.make_archive returns the full path to the created archive
-        zip_path = shutil.make_archive(
-            base_name=zip_base_name,
-            format='zip',
-            root_dir=download_root_dir # This becomes the root of the zip
-        )
+        progress(0.95, desc="All items downloaded. Creating ZIP file...")
+        zip_base_name = os.path.join(tempfile.gettempdir(), f"hf_{repo_type}s_archive_{uuid.uuid4().hex}")
+        zip_path = shutil.make_archive(base_name=zip_base_name, format='zip', root_dir=download_root_dir)
         
         progress(1, desc="Download ready!")
         gr.Info("ZIP file created successfully!")
-        
-        # Return the path to the zip file and make the component visible
         return gr.update(value=zip_path, visible=True)
-
     finally:
-        # 3. Clean up the large download directory, regardless of success or failure
         shutil.rmtree(download_root_dir, ignore_errors=True)
 
+
 # --- Gradio UI Layout ---
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="Hugging Face Hub Toolkit") as demo:
     # State management
     hf_token_state = gr.State(None)
-    author_state = gr.State("")
-    selected_repo_id = gr.State(None)
-    selected_repo_type = gr.State("space") # Default
+    manage_repo_type_state = gr.State(None)
+    download_repo_type_state = gr.State(None)
 
     gr.Markdown("# Hugging Face Hub Toolkit")
-    gr.Markdown("An intuitive interface to manage your Hugging Face repositories. **Enter a write-token for full access.**")
+    gr.Markdown("An intuitive interface to manage and download your Hugging Face repositories.")
 
     with gr.Sidebar():
         hf_token = gr.Textbox(label="Hugging Face API Token", type="password", placeholder="hf_...", scale=3)
@@ -239,98 +227,110 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="Hugging Face Hub
 
     with gr.Tabs():
         with gr.TabItem("Manage Repositories"):
-            with gr.Row(equal_height=False):
+            with gr.Row():
                 with gr.Column(scale=1):
-                    gr.Markdown("### 1. Select a Repository")
+                    gr.Markdown("### 1. Select Author & Repo Type")
                     author_input = gr.Textbox(label="Author (Username or Org)", interactive=True)
-                    repo_selector = gr.Radio(label="Select a Repository", interactive=True, value=None)
-                    with gr.Tabs() as repo_type_tabs:
+                    with gr.Row():
                         for repo_type, label in [("space", "Spaces"), ("model", "Models"), ("dataset", "Datasets")]:
-                            with gr.Tab(label, id=repo_type):
-                                btn = gr.Button(f"List {label}")
-                                btn.click(
-                                    fn=list_repos,
-                                    inputs=[hf_token_state, author_input, gr.State(repo_type)],
-                                    outputs=[repo_selector, gr.Column(), gr.Column()] # Dummy outputs for panels to hide them
-                                ).then(fn=lambda author: author, inputs=author_input, outputs=author_state)
-                
-                with gr.Column(scale=3):
+                            btn = gr.Button(f"List {label}")
+                            btn.click(
+                                fn=lambda rt: (rt, None, gr.update(visible=False), gr.update(visible=False)),
+                                inputs=gr.State(repo_type),
+                                outputs=[manage_repo_type_state, gr.Dropdown(), gr.Column(), gr.Column()] # Reset dropdown and hide panels
+                            ).then(
+                                fn=list_repos,
+                                inputs=[hf_token_state, author_input, gr.State(repo_type)],
+                                outputs=gr.Dropdown() # This is manage_repo_dropdown
+                            )
+
+                    gr.Markdown("### 2. Select Repository")
+                    manage_repo_dropdown = gr.Dropdown(label="Select a Repository", interactive=True)
+
+                with gr.Column(scale=2):
                     with gr.Column(visible=False) as action_panel:
-                        gr.Markdown("### 2. Choose an Action")
+                        gr.Markdown("### 3. Choose an Action")
                         with gr.Row():
-                            manage_files_btn = gr.Button("Manage Files", interactive=False, scale=1)
-                            delete_repo_btn = gr.Button("Delete This Repo", variant="stop", interactive=False, scale=1)
+                            manage_files_btn = gr.Button("Manage Files", interactive=False)
+                            delete_repo_btn = gr.Button("Delete This Repo", variant="stop", interactive=False)
                     
                     with gr.Column(visible=False) as editor_panel:
-                        gr.Markdown("### 3. Edit Files")
+                        gr.Markdown("### 4. Edit Files")
                         file_selector = gr.Dropdown(label="Select File", interactive=True)
                         code_editor = gr.Code(label="File Content", language="markdown", interactive=True)
                         commit_message_input = gr.Textbox(label="Commit Message", placeholder="e.g., Update README.md", interactive=True)
                         commit_btn = gr.Button("Commit Changes", variant="primary", interactive=False)
 
-        with gr.TabItem("Download Spaces (ZIP)"):
-            gr.Markdown("## Bulk Download Spaces as a ZIP Archive")
-            gr.Markdown("Select one or more Spaces from an author to download them as a single ZIP file. Each Space will be in its own folder inside the archive.")
+        with gr.TabItem("Bulk Download (ZIP)"):
+            gr.Markdown("## Bulk Download Repositories as a ZIP Archive")
+            gr.Markdown("Select one or more repositories from an author to download them as a single ZIP file.")
             
             with gr.Row():
-                download_author_input = gr.Textbox(
-                    label="Author (Username or Org)", 
-                    interactive=True, 
-                    placeholder="e.g., huggingface-projects or osanseviero"
-                )
-                list_spaces_btn = gr.Button("List Spaces", variant="secondary")
+                download_author_input = gr.Textbox(label="Author (Username or Org)", interactive=True)
+            with gr.Row():
+                 for repo_type, label in [("space", "Spaces"), ("model", "Models"), ("dataset", "Datasets")]:
+                    btn = gr.Button(f"List {label}")
+                    btn.click(
+                        fn=lambda rt: rt,
+                        inputs=gr.State(repo_type),
+                        outputs=download_repo_type_state
+                    ).then(
+                        fn=list_repos,
+                        inputs=[hf_token_state, download_author_input, gr.State(repo_type)],
+                        outputs=gr.Dropdown() # This is download_repo_dropdown
+                    )
 
-            spaces_dropdown = gr.Dropdown(label="Available Spaces", info="Select the spaces you want to download.", multiselect=True, interactive=True)
-            download_btn = gr.Button("Download Selected Spaces as ZIP", variant="primary")
+            download_repo_dropdown = gr.Dropdown(label="Available Repositories", info="Select the items you want to download.", multiselect=True, interactive=True)
+            download_btn = gr.Button("Download Selected as ZIP", variant="primary")
             download_output_file = gr.File(label="Your Downloaded ZIP File", visible=False)
-            
-            # --- Event Handlers for Download Tab ---
-            list_spaces_btn.click(
-                fn=list_spaces_for_download,
-                inputs=[hf_token_state, download_author_input],
-                outputs=[spaces_dropdown]
-            )
 
-            download_btn.click(
-                fn=download_spaces_as_zip,
-                inputs=[hf_token_state, spaces_dropdown],
-                outputs=[download_output_file]
-            )
-
-    # --- Event Handlers (Original Tab) ---
+    # --- Event Handlers ---
+    
+    # Token Authentication
     hf_token.change(
         fn=handle_token_change, inputs=hf_token,
-        outputs=[hf_token_state, author_state, manage_files_btn, delete_repo_btn, commit_btn, author_input, whoami_output]
+        outputs=[hf_token_state, manage_files_btn, delete_repo_btn, commit_btn, author_input, download_author_input, whoami_output]
     )
-    repo_type_tabs.select(
-        fn=lambda rt: (rt, None, gr.update(choices=[], value=None), gr.update(visible=False), gr.update(visible=False)),
-        inputs=repo_type_tabs,
-        outputs=[selected_repo_type, selected_repo_id, repo_selector, action_panel, editor_panel]
-    )
-    repo_selector.select(
-        fn=lambda repo_id: (repo_id, *handle_repo_selection(repo_id)),
-        inputs=repo_selector, outputs=[selected_repo_id, action_panel, editor_panel]
+
+    # --- Manage Tab Handlers ---
+    manage_repo_dropdown.select(
+        fn=on_manage_repo_select,
+        inputs=manage_repo_dropdown,
+        outputs=action_panel
     )
+    
     manage_files_btn.click(
-        fn=show_file_manager, inputs=[hf_token_state, selected_repo_id, selected_repo_type],
-        outputs=[editor_panel, file_selector, code_editor, commit_message_input]
+        fn=show_files_and_load_first,
+        inputs=[hf_token_state, manage_repo_dropdown, manage_repo_type_state],
+        outputs=[editor_panel, file_selector, code_editor]
     )
+
     delete_repo_btn.click(
-        fn=delete_repo, inputs=[hf_token_state, selected_repo_id, selected_repo_type],
-        outputs=[selected_repo_id, action_panel, editor_panel],
+        fn=delete_repo,
+        inputs=[hf_token_state, manage_repo_dropdown, manage_repo_type_state],
+        outputs=[manage_repo_dropdown],
         js="() => confirm('Are you sure you want to permanently delete this repository? This action cannot be undone.')"
-    ).then(
-        fn=list_repos,
-        inputs=[hf_token_state, author_state, selected_repo_type],
-        outputs=[repo_selector, action_panel, editor_panel]
+    ).then( # After deletion, hide panels
+        lambda: (gr.update(visible=False), gr.update(visible=False)),
+        outputs=[action_panel, editor_panel]
     )
+    
     file_selector.change(
-        fn=load_file_content, inputs=[hf_token_state, selected_repo_id, selected_repo_type, file_selector],
+        fn=load_file_content_for_editor,
+        inputs=[hf_token_state, manage_repo_dropdown, manage_repo_type_state, file_selector],
         outputs=code_editor
     )
+
     commit_btn.click(
         fn=commit_file,
-        inputs=[hf_token_state, selected_repo_id, selected_repo_type, file_selector, code_editor, commit_message_input]
+        inputs=[hf_token_state, manage_repo_dropdown, manage_repo_type_state, file_selector, code_editor, commit_message_input]
+    )
+
+    # --- Download Tab Handlers ---
+    download_btn.click(
+        fn=download_repos_as_zip,
+        inputs=[hf_token_state, download_repo_dropdown, download_repo_type_state],
+        outputs=[download_output_file]
     )
 
 if __name__ == "__main__":