chore: Remove YouTube uploader (not working in cloud Docker)

modules/shared/__init__.py

@@ -1,23 +1,3 @@
 """
 Shared utilities and services for NCAkit modules
 """
-
-import logging
-from fastapi import FastAPI
-
-logger = logging.getLogger(__name__)
-
-# Module metadata
-MODULE_NAME = "shared"
-MODULE_PREFIX = "/api/utils"
-MODULE_DESCRIPTION = "Shared utilities including YouTube to HF uploader"
-
-
-def register(app: FastAPI, config=None):
-    """Register the shared module with FastAPI."""
-    from .router import router
-    
-    # Include router
-    app.include_router(router)
-    
-    logger.info("shared module registered (utilities endpoints available)")

modules/shared/router.py

@@ -1,117 +0,0 @@
-"""
-Shared Utilities Router.
-Provides common API endpoints for media management.
-"""
-
-import logging
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel, Field
-from typing import Optional, List
-
-from .services.youtube_uploader import get_uploader
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(prefix="/api/utils", tags=["Utilities"])
-
-
-# ============================================
-# SCHEMAS
-# ============================================
-
-class FolderCreateRequest(BaseModel):
-    """Request to create a new folder."""
-    name: str = Field(..., min_length=1, max_length=50, description="Folder name")
-
-
-class YouTubeUploadRequest(BaseModel):
-    """Request to download and upload YouTube content."""
-    url: str = Field(..., description="YouTube video or playlist URL")
-    folder: str = Field(..., description="Target folder in HF Dataset")
-    format: str = Field(default="mp4", description="Format: mp4 (video) or mp3 (audio)")
-    category: Optional[str] = Field(
-        default=None, 
-        description="Category name for audio files (e.g., 'emotional', 'energetic')"
-    )
-
-
-# ============================================
-# ENDPOINTS
-# ============================================
-
-@router.get("/hf-folders", summary="List HF Dataset folders")
-async def list_hf_folders():
-    """Get all folders in HuggingFace Dataset."""
-    uploader = get_uploader()
-    
-    if not uploader.enabled:
-        raise HTTPException(
-            status_code=503, 
-            detail="Uploader not available. Check HF_REPO and HF_TOKEN."
-        )
-    
-    folders = uploader.list_folders()
-    return {"folders": folders}
-
-
-@router.post("/hf-folders", summary="Create new folder")
-async def create_hf_folder(request: FolderCreateRequest):
-    """Create a new folder in HuggingFace Dataset."""
-    uploader = get_uploader()
-    
-    if not uploader.enabled:
-        raise HTTPException(status_code=503, detail="Uploader not available")
-    
-    success = uploader.create_folder(request.name)
-    
-    if not success:
-        raise HTTPException(status_code=500, detail="Failed to create folder")
-    
-    return {"success": True, "folder": request.name}
-
-
-@router.post("/youtube-upload", summary="Upload YouTube content to HF")
-async def upload_youtube_content(request: YouTubeUploadRequest):
-    """
-    Download YouTube video/playlist and upload to HF Dataset.
-    
-    - **url**: YouTube video or playlist URL
-    - **folder**: Target folder (e.g., 'gameplay_backgrounds', 'music')
-    - **format**: 'mp4' for video, 'mp3' for audio
-    - **category**: For audio, category name like 'emotional', 'energetic'
-    """
-    uploader = get_uploader()
-    
-    if not uploader.enabled:
-        raise HTTPException(status_code=503, detail="Uploader not available")
-    
-    if request.format == "mp3":
-        # Audio mode
-        category = request.category or "music"
-        result = uploader.download_audio(
-            url=request.url,
-            folder=request.folder,
-            category=category
-        )
-    else:
-        # Video mode
-        result = uploader.download_video(
-            url=request.url,
-            folder=request.folder
-        )
-    
-    if not result.get("success", False):
-        raise HTTPException(status_code=500, detail=result.get("error", "Upload failed"))
-    
-    return result
-
-
-@router.get("/health", summary="Check uploader status")
-async def uploader_health():
-    """Check if YouTube uploader is available."""
-    uploader = get_uploader()
-    
-    return {
-        "enabled": uploader.enabled,
-        "repo_id": uploader.repo_id if uploader.enabled else None
-    }

modules/shared/services/youtube_uploader.py

@@ -1,340 +0,0 @@
-"""
-YouTube to HuggingFace Media Uploader.
-Downloads YouTube videos/playlists and uploads to HF Dataset.
-No local storage - temp files deleted immediately.
-"""
-
-import os
-import logging
-import tempfile
-import shutil
-from typing import List, Optional, Dict
-from pathlib import Path
-
-logger = logging.getLogger(__name__)
-
-# Try to import dependencies
-try:
-    import yt_dlp
-    YTDLP_AVAILABLE = True
-except ImportError:
-    YTDLP_AVAILABLE = False
-    logger.warning("yt-dlp not installed. YouTube uploads disabled.")
-
-try:
-    from huggingface_hub import HfApi, list_repo_files
-    HF_HUB_AVAILABLE = True
-except ImportError:
-    HF_HUB_AVAILABLE = False
-    logger.warning("huggingface_hub not installed.")
-
-
-class YouTubeToHFUploader:
-    """
-    Downloads YouTube videos/audio and uploads to HuggingFace Dataset.
-    
-    Features:
-    - Single video or playlist download
-    - MP4 (video) or MP3 (audio) format
-    - Custom category naming for audio
-    - Direct upload to HF, no local storage
-    """
-    
-    def __init__(self, repo_id: str = None, token: str = None):
-        """
-        Initialize uploader.
-        
-        Args:
-            repo_id: HF repo ID (e.g., "username/dataset")
-            token: HF token with write access
-        """
-        self.repo_id = repo_id or os.getenv("HF_REPO", "")
-        self.token = token or os.getenv("HF_TOKEN", "")
-        self.api = None
-        
-        if not self.repo_id or not self.token:
-            logger.warning("YouTubeUploader: HF_REPO or HF_TOKEN not set")
-            self.enabled = False
-            return
-        
-        if not YTDLP_AVAILABLE or not HF_HUB_AVAILABLE:
-            self.enabled = False
-            return
-        
-        self.enabled = True
-        self.api = HfApi(token=self.token)
-        logger.info(f"YouTubeUploader: Initialized for {self.repo_id}")
-    
-    def list_folders(self) -> List[str]:
-        """List all folders in HF Dataset."""
-        if not self.enabled:
-            return []
-        
-        try:
-            all_files = list_repo_files(
-                repo_id=self.repo_id,
-                repo_type="dataset"
-            )
-            
-            # Extract unique folder names
-            folders = set()
-            for f in all_files:
-                if "/" in f:
-                    folder = f.split("/")[0]
-                    folders.add(folder)
-            
-            return sorted(list(folders))
-            
-        except Exception as e:
-            logger.error(f"Failed to list folders: {e}")
-            return []
-    
-    def create_folder(self, folder_name: str) -> bool:
-        """
-        Create a new folder in HF Dataset.
-        
-        Args:
-            folder_name: Name of folder to create
-            
-        Returns:
-            True if successful
-        """
-        if not self.enabled:
-            return False
-        
-        try:
-            # Create placeholder file to create folder
-            placeholder = f"# {folder_name}\n\nFolder for media files."
-            
-            with tempfile.NamedTemporaryFile(mode='w', suffix='.md', delete=False) as f:
-                f.write(placeholder)
-                temp_path = f.name
-            
-            self.api.upload_file(
-                path_or_fileobj=temp_path,
-                path_in_repo=f"{folder_name}/README.md",
-                repo_id=self.repo_id,
-                repo_type="dataset"
-            )
-            
-            os.remove(temp_path)
-            logger.info(f"Created folder: {folder_name}")
-            return True
-            
-        except Exception as e:
-            logger.error(f"Failed to create folder: {e}")
-            return False
-    
-    def _get_next_index(self, folder: str, category: str) -> int:
-        """Get next available index for category files."""
-        try:
-            all_files = list_repo_files(
-                repo_id=self.repo_id,
-                repo_type="dataset"
-            )
-            
-            # Find existing files with this category
-            existing = [
-                f for f in all_files 
-                if f.startswith(f"{folder}/{category}_") and f.endswith(".mp3")
-            ]
-            
-            if not existing:
-                return 1
-            
-            # Extract highest index
-            indices = []
-            for f in existing:
-                try:
-                    # Extract number from filename like "emotional_003.mp3"
-                    name = f.split("/")[-1]
-                    num = int(name.replace(f"{category}_", "").replace(".mp3", ""))
-                    indices.append(num)
-                except:
-                    pass
-            
-            return max(indices) + 1 if indices else 1
-            
-        except:
-            return 1
-    
-    def download_video(self, url: str, folder: str) -> Dict:
-        """
-        Download YouTube video and upload to HF.
-        
-        Args:
-            url: YouTube video or playlist URL
-            folder: Target folder in HF Dataset
-            
-        Returns:
-            Dict with results
-        """
-        if not self.enabled:
-            return {"success": False, "error": "Uploader not enabled"}
-        
-        temp_dir = tempfile.mkdtemp(prefix="yt_video_")
-        results = {"success": True, "uploaded": [], "errors": []}
-        
-        try:
-            ydl_opts = {
-                'format': 'best[height<=720][ext=mp4]/best[height<=720]/best',
-                'outtmpl': os.path.join(temp_dir, '%(id)s.%(ext)s'),
-                'quiet': True,
-                'no_warnings': True,
-            }
-            
-            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                # Get video info
-                info = ydl.extract_info(url, download=True)
-                
-                # Handle playlist
-                entries = info.get('entries', [info])
-                
-                for entry in entries:
-                    if not entry:
-                        continue
-                    
-                    video_id = entry.get('id', 'unknown')
-                    
-                    # Find downloaded file
-                    for ext in ['mp4', 'webm', 'mkv']:
-                        local_path = os.path.join(temp_dir, f"{video_id}.{ext}")
-                        if os.path.exists(local_path):
-                            break
-                    else:
-                        results["errors"].append(f"File not found for {video_id}")
-                        continue
-                    
-                    # Upload to HF
-                    try:
-                        path_in_repo = f"{folder}/{video_id}.mp4"
-                        self.api.upload_file(
-                            path_or_fileobj=local_path,
-                            path_in_repo=path_in_repo,
-                            repo_id=self.repo_id,
-                            repo_type="dataset"
-                        )
-                        
-                        cloud_url = f"https://huggingface.co/datasets/{self.repo_id}/resolve/main/{path_in_repo}"
-                        results["uploaded"].append({
-                            "id": video_id,
-                            "title": entry.get('title', video_id),
-                            "url": cloud_url
-                        })
-                        
-                        # Delete local file immediately
-                        os.remove(local_path)
-                        logger.info(f"Uploaded: {video_id}")
-                        
-                    except Exception as e:
-                        results["errors"].append(f"{video_id}: {str(e)}")
-            
-        except Exception as e:
-            results["success"] = False
-            results["error"] = str(e)
-            logger.error(f"Download failed: {e}")
-        
-        finally:
-            # Cleanup temp directory
-            shutil.rmtree(temp_dir, ignore_errors=True)
-        
-        return results
-    
-    def download_audio(self, url: str, folder: str, category: str = "music") -> Dict:
-        """
-        Download YouTube audio as MP3 and upload to HF.
-        
-        Args:
-            url: YouTube video or playlist URL
-            folder: Target folder in HF Dataset
-            category: Category name for files (e.g., "emotional", "energetic")
-            
-        Returns:
-            Dict with results
-        """
-        if not self.enabled:
-            return {"success": False, "error": "Uploader not enabled"}
-        
-        temp_dir = tempfile.mkdtemp(prefix="yt_audio_")
-        results = {"success": True, "uploaded": [], "errors": []}
-        
-        try:
-            ydl_opts = {
-                'format': 'bestaudio/best',
-                'outtmpl': os.path.join(temp_dir, '%(id)s.%(ext)s'),
-                'quiet': True,
-                'no_warnings': True,
-                'postprocessors': [{
-                    'key': 'FFmpegExtractAudio',
-                    'preferredcodec': 'mp3',
-                    'preferredquality': '192',
-                }],
-            }
-            
-            # Get starting index for category
-            next_index = self._get_next_index(folder, category)
-            
-            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                info = ydl.extract_info(url, download=True)
-                entries = info.get('entries', [info])
-                
-                for entry in entries:
-                    if not entry:
-                        continue
-                    
-                    video_id = entry.get('id', 'unknown')
-                    local_path = os.path.join(temp_dir, f"{video_id}.mp3")
-                    
-                    if not os.path.exists(local_path):
-                        results["errors"].append(f"MP3 not found for {video_id}")
-                        continue
-                    
-                    # Upload with category naming
-                    try:
-                        filename = f"{category}_{next_index:03d}.mp3"
-                        path_in_repo = f"{folder}/{filename}"
-                        
-                        self.api.upload_file(
-                            path_or_fileobj=local_path,
-                            path_in_repo=path_in_repo,
-                            repo_id=self.repo_id,
-                            repo_type="dataset"
-                        )
-                        
-                        cloud_url = f"https://huggingface.co/datasets/{self.repo_id}/resolve/main/{path_in_repo}"
-                        results["uploaded"].append({
-                            "id": video_id,
-                            "title": entry.get('title', video_id),
-                            "filename": filename,
-                            "url": cloud_url
-                        })
-                        
-                        # Delete local file immediately
-                        os.remove(local_path)
-                        logger.info(f"Uploaded: {filename}")
-                        next_index += 1
-                        
-                    except Exception as e:
-                        results["errors"].append(f"{video_id}: {str(e)}")
-            
-        except Exception as e:
-            results["success"] = False
-            results["error"] = str(e)
-            logger.error(f"Audio download failed: {e}")
-        
-        finally:
-            shutil.rmtree(temp_dir, ignore_errors=True)
-        
-        return results
-
-
-# Singleton instance
-_uploader: Optional[YouTubeToHFUploader] = None
-
-
-def get_uploader() -> YouTubeToHFUploader:
-    """Get or create uploader instance."""
-    global _uploader
-    if _uploader is None:
-        _uploader = YouTubeToHFUploader()
-    return _uploader

requirements.txt

@@ -29,6 +29,3 @@ imageio-ffmpeg>=0.4.9
 # Trends Analysis
 pytrends
 pandas
-
-# YouTube Downloads
-yt-dlp