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()