Upload folder using huggingface_hub

app 22.py

@@ -0,0 +1,270 @@
+import os
+import git
+import shutil
+import zipfile
+from huggingface_hub import HfApi, create_repo
+import gradio as gr
+import requests
+
+# Initialize Hugging Face API
+api = HfApi()
+
+def clone_repo(repo_url, repo_type=None, auth_token=None):
+    try:
+        print(f"Cloning repository from URL: {repo_url}")
+        repo_name = repo_url.split('/')[-1]
+        if os.path.exists(repo_name):
+            print(f"Removing existing directory: {repo_name}")
+            shutil.rmtree(repo_name)
+
+        if "huggingface.co" in repo_url:
+            repo_id = "/".join(repo_url.split("/")[-2:])
+            if repo_type is None:
+                repo_type = 'model'
+            api.snapshot_download(repo_id=repo_id, repo_type=repo_type, token=auth_token, local_dir=repo_name)
+        else:
+            if auth_token:
+                repo_url = repo_url.replace("https://", f"https://{auth_token}@")
+            git.Repo.clone_from(repo_url, repo_name)
+
+        print(f"Repository cloned successfully: {repo_name}")
+        zip_file = f"{repo_name}.zip"
+        shutil.make_archive(repo_name, 'zip', repo_name)
+        print(f"Repository zipped successfully: {zip_file}")
+        return zip_file
+    except git.exc.GitCommandError as e:
+        if "could not read Username" in str(e):
+            return "Authentication error: Please provide a valid token for private repositories."
+        return f"Git error: {str(e)}"
+    except requests.exceptions.RequestException as e:
+        return "Network error: Unable to connect to the repository."
+    except Exception as e:
+        return f"An error occurred: {str(e)}"
+
+def zip_download_link(repo_type, repo_url, auth_token):
+    result = clone_repo(repo_url, repo_type, auth_token)
+    if isinstance(result, str) and result.endswith(".zip"):
+        return gr.update(value=result), ""
+    else:
+        return gr.update(value=None), result
+
+def push_to_huggingface(repo_type, repo_name, files_or_zip, hf_token):
+    try:
+        repo_name = repo_name.lstrip("/")
+        if not "/" in repo_name:
+            repo_name = f"{hf_token.split(':')[0]}/{repo_name}"
+        target_dir = f"./{repo_name}"
+        if os.path.exists(target_dir):
+            shutil.rmtree(target_dir)
+        os.makedirs(target_dir, exist_ok=True)
+
+        if isinstance(files_or_zip, list):
+            for file_obj in files_or_zip:
+                if file_obj.endswith(".zip"):
+                    with zipfile.ZipFile(file_obj, 'r') as zip_ref:
+                        zip_ref.extractall(target_dir)
+                else:
+                    shutil.copy(file_obj, os.path.join(target_dir, os.path.basename(file_obj)))
+        else:
+            if files_or_zip.endswith(".zip"):
+                with zipfile.ZipFile(files_or_zip, 'r') as zip_ref:
+                    zip_ref.extractall(target_dir)
+            else:
+                shutil.copy(files_or_zip, os.path.join(target_dir, os.path.basename(files_or_zip)))
+
+        if repo_type == "Space":
+            api.upload_folder(folder_path=target_dir, path_in_repo="", repo_id=repo_name, repo_type="space", token=hf_token)
+            return f"Files pushed to Hugging Face Space: {repo_name}"
+        else:
+            api.upload_folder(folder_path=target_dir, path_in_repo="", repo_id=repo_name, token=hf_token)
+            return f"Files pushed to Hugging Face repository: {repo_name}"
+    except Exception as e:
+        return f"An error occurred: {str(e)}"
+
+def create_huggingface_space(space_name, space_type, hardware, visibility, hf_token):
+    try:
+        if "/" not in space_name:
+            space_name = f"{hf_token.split(':')[0]}/{space_name}"
+
+        create_repo(repo_id=space_name, repo_type="space", space_sdk=space_type, token=hf_token, private=(visibility == "private"))
+        return f"Successfully created Hugging Face Space: {space_name}"
+    except Exception as e:
+        return f"An error occurred while creating the Space: {str(e)}"
+
+def remove_files_from_huggingface(repo_type, repo_name, file_paths, remove_all, hf_token):
+    try:
+        print(f"Removing files from {repo_type}: {repo_name}")
+        repo_name = repo_name.lstrip("/")
+        if not "/" in repo_name:
+            repo_name = f"{hf_token.split(':')[0]}/{repo_name}"
+
+        if remove_all:
+            try:
+                files = api.list_repo_files(repo_id=repo_name, repo_type=repo_type.lower(), token=hf_token)
+                if not files:
+                    return "No files found to remove."
+
+                successful_removals = []
+                failed_removals = []
+                for file_path in files:
+                    try:
+                        api.delete_file(path_in_repo=file_path, repo_id=repo_name, repo_type=repo_type.lower(), token=hf_token)
+                        successful_removals.append(file_path)
+                    except Exception as e:
+                        failed_removals.append((file_path, str(e)))
+
+                result = []
+                if successful_removals:
+                    result.append(f"Successfully removed files: {', '.join(successful_removals)}")
+                if failed_removals:
+                    result.append("Failed to remove the following files:")
+                    for path, error in failed_removals:
+                        result.append(f"- {path}: {error}")
+
+                return "\n".join(result)
+            except Exception as e:
+                return f"Error removing all files: {str(e)}"
+        else:
+            if isinstance(file_paths, str):
+                file_paths = [path.strip() for path in file_paths.split(',') if path.strip()]
+
+            if not file_paths:
+                return "Error: No valid file paths provided."
+
+            successful_removals = []
+            failed_removals = []
+            for file_path in file_paths:
+                try:
+                    api.delete_file(path_in_repo=file_path, repo_id=repo_name, repo_type=repo_type.lower(), token=hf_token)
+                    successful_removals.append(file_path)
+                except Exception as e:
+                    failed_removals.append((file_path, str(e)))
+
+            result = []
+            if successful_removals:
+                result.append(f"Successfully removed files: {', '.join(successful_removals)}")
+            if failed_removals:
+                result.append("Failed to remove the following files:")
+                for path, error in failed_removals:
+                    result.append(f"- {path}: {error}")
+
+            return "\n".join(result)
+    except Exception as e:
+        return f"An error occurred during file removal: {str(e)}"
+
+# Define the Gradio interface using Blocks API
+with gr.Blocks(css="footer {display:none;}.title {color: blue; font-size: 36px;}") as app:
+    gr.Markdown("""
+# 🚀 Hugging Face Repo & Space Manager
+
+Welcome to the next-gen tool for effortlessly managing your Hugging Face ecosystem! Whether you're a seasoned ML engineer or just getting started with AI, this all-in-one interface streamlines your workflow and boosts productivity.
+
+## 🌟 Key Features & Why Use This Tool?
+
+- **Seamless File Management**: Push, pull, and organize your files across Spaces and Repos with drag-and-drop simplicity.
+- **Git Integration**: Clone repositories from GitHub or Hugging Face with a single click, and download them as ready-to-use ZIP files.
+- **Smart File Removal**: Selectively clean up your Spaces and Repos, or perform a total reset with our bulk file removal option.
+- **Time-Saver**: Automate repetitive tasks and focus on what matters - your AI projects.
+- **User-Friendly**: No more command-line headaches. Our GUI makes complex operations a breeze.
+- **Versatile**: From creating Spaces to managing large datasets, handle it all in one place.
+- **Secure**: Built-in token management ensures your credentials stay safe while you work.
+
+## 🔧 How to Use This Tool
+
+1. **Create a New Space**: Start by creating a fresh Hugging Face Space for your project.
+2. **Manage Existing Spaces**: Remove Files" tab to clean up your Space or Repository.
+3. **Push Your Content**: Upload your files or a ZIP archive to your Space or Repository. 
+4. **Clone and Modify**: Modify the files locally, then push them back using the "Push to Hugging Face" feature.
+
+Embrace the future of AI project management. Let's innovate together! 🤗✨
+---
+Created with ❤️ by MoBenTa | Empowering AI enthusiasts worldwide
+    """)
+
+    with gr.Tabs():
+        with gr.Tab("🌟 Manage Hugging Face Space/Repo"):
+            with gr.Tabs():
+                with gr.TabItem("Create Space"):
+                    space_name = gr.Textbox(label="Space Name (format: username/space-name)")
+                    space_type = gr.Dropdown(["streamlit", "gradio", "static", "docker"], label="Space Type")
+                    hardware = gr.Textbox(label="Hardware (optional)")
+                    visibility = gr.Radio(choices=["public", "private"], label="Visibility")
+                    create_hf_token = gr.Textbox(label="Hugging Face Token", type="password")
+                    create_space_button = gr.Button("Create Space", variant="primary")
+                    create_space_output = gr.Textbox(label="Creation Result")
+
+                    create_space_button.click(
+                        fn=create_huggingface_space,
+                        inputs=[space_name, space_type, hardware, visibility, create_hf_token],
+                        outputs=create_space_output
+                    )
+
+                with gr.TabItem("Remove Files"):
+                    remove_type = gr.Dropdown(["Space", "Repository"], label="Remove from")
+                    remove_repo_name = gr.Textbox(label="Repository/Space Name")
+                    remove_all_checkbox = gr.Checkbox(label="Remove All Files", info="Warning: This will remove all files from the repository!")
+                    remove_file_paths = gr.Textbox(label="File Paths to Remove (comma-separated)", interactive=True)
+                    remove_hf_token = gr.Textbox(label="Hugging Face Token", type="password")
+                    remove_button = gr.Button("Remove Files", variant="primary")
+                    remove_output = gr.Textbox(label="Removal Result")
+
+                    def update_file_paths_interactivity(remove_all):
+                        return gr.update(interactive=not remove_all)
+
+                    remove_all_checkbox.change(
+                        fn=update_file_paths_interactivity,
+                        inputs=remove_all_checkbox,
+                        outputs=remove_file_paths
+                    )
+
+                    remove_button.click(
+                        fn=remove_files_from_huggingface,
+                        inputs=[remove_type, remove_repo_name, remove_file_paths, remove_all_checkbox, remove_hf_token],
+                        outputs=remove_output
+                    )
+
+        with gr.Tab("☁️ Push to Hugging Face"):
+            push_type = gr.Dropdown(["Space", "Repository"], label="Push to")
+            repo_name = gr.Textbox(label="Repository/Space Name")
+            files_upload = gr.File(label="Upload File(s) or Zip", file_count="multiple", type="filepath")
+            hf_token = gr.Textbox(label="Hugging Face Token", type="password")
+            push_button = gr.Button("Push to Hugging Face", variant="primary")
+            push_output = gr.Textbox(label="Push Result")
+
+            push_button.click(
+                fn=push_to_huggingface,
+                inputs=[push_type, repo_name, files_upload, hf_token],
+                outputs=push_output
+            )
+
+        with gr.Tab("🔍 Clone Repository"):
+            repo_type_input = gr.Radio(choices=["GitHub", "Hugging Face Model", "Hugging Face Dataset", "Hugging Face Space"], label="Repository Type")
+            repo_url_input = gr.Textbox(label="Repository URL")
+            auth_token_input = gr.Textbox(label="Authentication Token (optional)", type="password")
+            clone_button = gr.Button("Clone and Download", variant="primary")
+            output_zip = gr.File(label="Downloaded Repository")
+            clone_error_output = gr.Textbox(label="Cloning Result", visible=False)
+
+            def handle_clone_result(repo_type_input, repo_url, auth_token):
+                if repo_type_input == "GitHub":
+                    repo_type = None
+                elif repo_type_input == "Hugging Face Model":
+                    repo_type = "model"
+                elif repo_type_input == "Hugging Face Dataset":
+                    repo_type = "dataset"
+                elif repo_type_input == "Hugging Face Space":
+                    repo_type = "space"
+                else:
+                    repo_type = "model"
+
+                file_output, error_message = zip_download_link(repo_type, repo_url, auth_token)
+                return file_output, error_message, gr.update(visible=bool(error_message))
+
+            clone_button.click(
+                fn=handle_clone_result,
+                inputs=[repo_type_input, repo_url_input, auth_token_input],
+                outputs=[output_zip, clone_error_output, clone_error_output]
+            )
+
+if __name__ == "__main__":
+    app.launch()

requirements 17.txt

@@ -0,0 +1,3 @@
+gradio
+huggingface_hub
+gitpython