Rename app (22).py to app.py

app (22).py

@@ -1,270 +0,0 @@
-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()

app.py

@@ -0,0 +1,78 @@
+import gradio as gr
+import requests
+from bs4 import BeautifulSoup
+import re
+
+# Function to search YouTube videos using web scraping
+def youtube_search(query, max_results=50):
+    search_url = f"https://www.youtube.com/results?search_query={query}"
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3"
+    }
+
+    try:
+        # Make the HTTP request to YouTube search results page
+        response = requests.get(search_url, headers=headers)
+        response.raise_for_status()  # Raise an error for bad responses (4xx or 5xx)
+
+        # Parse the HTML content
+        soup = BeautifulSoup(response.text, "html.parser")
+        video_elements = soup.find_all("a", href=True, class_="yt-uix-tile-link")
+        
+        # Extract up to 'max_results' video details
+        gallery_items = []
+        for idx, video in enumerate(video_elements):
+            if idx >= max_results:
+                break
+
+            video_id = video['href'].split('=')[-1]
+            video_title = video.get_text(strip=True)
+            thumbnail_url = f"https://img.youtube.com/vi/{video_id}/mqdefault.jpg"
+
+            # Append tuple (thumbnail, video ID)
+            gallery_items.append((thumbnail_url, video_id))
+
+        return gallery_items
+
+    except requests.exceptions.RequestException as e:
+        # Print the error message to help debug issues
+        print(f"Error during YouTube web scraping request: {e}")
+        return []
+
+# Update Gradio-related parts
+with gr.Blocks() as demo:
+    gr.Markdown("## YouTube Video Search, Selection, and Playback")
+
+    with gr.Row():
+        with gr.Column(scale=3):
+            search_query_input = gr.Textbox(label="Search YouTube", placeholder="Enter your search query here")
+            search_button = gr.Button("Search")
+            search_output = gr.Gallery(label="Search Results", columns=5, height="1500px")
+        
+        with gr.Column(scale=2):
+            selected_video_link = gr.Textbox(label="Selected Video Link", interactive=False)
+            play_video_button = gr.Button("Play Video")
+            video_output = gr.HTML(label="Video Player")
+
+    # Define search button behavior
+    def update_search_results(query):
+        gallery_items = youtube_search(query)
+        return gallery_items
+
+    # Update the selected video link field when a video is clicked in the gallery
+    def on_video_select(evt: gr.SelectData):
+        # Extract the video ID from the event value, which is a dictionary containing details of the selected item
+        selected_video_id = evt.value["caption"]
+        video_url = f"https://www.youtube.com/watch?v={selected_video_id}"
+        return video_url
+
+    # Play the video when the Play Video button is clicked
+    def play_video(video_url):
+        return show_video(video_url)
+
+    search_button.click(update_search_results, inputs=search_query_input, outputs=search_output)
+    search_output.select(on_video_select, inputs=None, outputs=selected_video_link)
+    play_video_button.click(play_video, inputs=selected_video_link, outputs=video_output)
+
+# Launch the Gradio interface
+demo.launch()