Spaces:
Sleeping
Sleeping
| 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 best 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. | |
| 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() |