karaoke-gen 0.90.1__py3-none-any.whl → 0.96.0__py3-none-any.whl

backend/services/discord_service.py

@@ -0,0 +1,172 @@
+"""
+Discord Notification Service.
+
+Provides Discord webhook notification functionality, extracted from KaraokeFinalise
+for use by both the cloud backend (video_worker) and local CLI.
+
+This service handles:
+- Posting messages to Discord webhooks
+- Video upload notifications
+- Validation of webhook URLs
+"""
+
+import logging
+import re
+from typing import Optional
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+
+class DiscordNotificationService:
+    """
+    Service for sending Discord webhook notifications.
+
+    Supports posting messages to Discord channels via webhooks,
+    commonly used to notify when new karaoke videos are uploaded.
+    """
+
+    # Discord webhook URL pattern
+    WEBHOOK_URL_PATTERN = re.compile(
+        r"^https://discord\.com/api/webhooks/\d+/[a-zA-Z0-9_-]+$"
+    )
+
+    def __init__(
+        self,
+        webhook_url: Optional[str] = None,
+        dry_run: bool = False,
+        logger: Optional[logging.Logger] = None,
+    ):
+        """
+        Initialize the Discord notification service.
+
+        Args:
+            webhook_url: Discord webhook URL for posting notifications
+            dry_run: If True, log actions without performing them
+            logger: Optional logger instance
+        """
+        self.webhook_url = webhook_url
+        self.dry_run = dry_run
+        self.logger = logger or logging.getLogger(__name__)
+
+        # Validate webhook URL if provided
+        if webhook_url:
+            self._validate_webhook_url(webhook_url)
+
+    def _validate_webhook_url(self, url: str) -> None:
+        """
+        Validate that the webhook URL is a valid Discord webhook URL.
+
+        Args:
+            url: URL to validate
+
+        Raises:
+            ValueError: If URL is not a valid Discord webhook URL
+        """
+        url = url.strip()
+        if not url.startswith("https://discord.com/api/webhooks/"):
+            raise ValueError(
+                f"Invalid Discord webhook URL: {url}. "
+                "URL must start with 'https://discord.com/api/webhooks/'"
+            )
+
+    def post_message(
+        self,
+        message: str,
+        webhook_url: Optional[str] = None,
+    ) -> bool:
+        """
+        Post a message to a Discord channel via webhook.
+
+        Args:
+            message: The message content to post
+            webhook_url: Optional webhook URL (uses instance URL if not provided)
+
+        Returns:
+            True if message was posted successfully, False otherwise
+
+        Raises:
+            ValueError: If no webhook URL is available
+            requests.HTTPError: If the webhook request fails
+        """
+        url = webhook_url or self.webhook_url
+        if not url:
+            raise ValueError("No Discord webhook URL provided")
+
+        url = url.strip()
+        self._validate_webhook_url(url)
+
+        if self.dry_run:
+            self.logger.info(
+                f"DRY RUN: Would post Discord message: '{message}' to {url}"
+            )
+            return True
+
+        self.logger.info(f"Posting message to Discord webhook...")
+        data = {"content": message}
+        response = requests.post(url, json=data, timeout=30)
+        response.raise_for_status()
+        self.logger.info("Message posted to Discord successfully")
+        return True
+
+    def post_video_notification(
+        self,
+        youtube_url: str,
+        webhook_url: Optional[str] = None,
+    ) -> bool:
+        """
+        Post a notification about a new video upload.
+
+        Args:
+            youtube_url: The YouTube URL of the uploaded video
+            webhook_url: Optional webhook URL (uses instance URL if not provided)
+
+        Returns:
+            True if notification was posted successfully, False otherwise
+        """
+        if not youtube_url:
+            self.logger.info("Skipping Discord notification - no YouTube URL available")
+            return False
+
+        message = f"New upload: {youtube_url}"
+        return self.post_message(message, webhook_url)
+
+    def is_enabled(self) -> bool:
+        """
+        Check if Discord notifications are enabled.
+
+        Returns:
+            True if a valid webhook URL is configured
+        """
+        return bool(self.webhook_url)
+
+
+# Singleton instance and factory function (following existing service pattern)
+_discord_notification_service: Optional[DiscordNotificationService] = None
+
+
+def get_discord_notification_service(
+    webhook_url: Optional[str] = None,
+    **kwargs
+) -> DiscordNotificationService:
+    """
+    Get a Discord notification service instance.
+
+    Args:
+        webhook_url: Discord webhook URL for notifications
+        **kwargs: Additional arguments passed to DiscordNotificationService
+
+    Returns:
+        DiscordNotificationService instance
+    """
+    global _discord_notification_service
+
+    # Create new instance if webhook URL changed or not yet created
+    if _discord_notification_service is None or webhook_url:
+        _discord_notification_service = DiscordNotificationService(
+            webhook_url=webhook_url,
+            **kwargs
+        )
+
+    return _discord_notification_service

backend/services/dropbox_service.py

@@ -0,0 +1,301 @@
+"""Native Dropbox API service for cloud backend.
+
+This service provides Dropbox operations using the native Python SDK,
+replacing rclone for server-side operations. It handles:
+- Folder listing for brand code calculation
+- File and folder uploads
+- Shared link generation
+
+Credentials are loaded from Google Cloud Secret Manager.
+"""
+import json
+import logging
+import os
+import re
+from typing import Optional
+
+from google.cloud import secretmanager
+
+logger = logging.getLogger(__name__)
+
+
+class DropboxService:
+    """Dropbox operations using native Python SDK."""
+
+    def __init__(self):
+        self._client = None
+        self._is_configured = False
+
+    def _load_credentials(self) -> Optional[dict]:
+        """Load OAuth credentials from Secret Manager."""
+        try:
+            client = secretmanager.SecretManagerServiceClient()
+            # Try to get the project ID from environment or use default
+            project_id = os.environ.get("GOOGLE_CLOUD_PROJECT", "karaoke-gen")
+            name = f"projects/{project_id}/secrets/dropbox-oauth-credentials/versions/latest"
+            response = client.access_secret_version(request={"name": name})
+            return json.loads(response.payload.data.decode("UTF-8"))
+        except Exception as e:
+            logger.warning(f"Failed to load Dropbox credentials from Secret Manager: {e}")
+            return None
+
+    @property
+    def is_configured(self) -> bool:
+        """Check if Dropbox credentials are available."""
+        if self._is_configured:
+            return True
+        creds = self._load_credentials()
+        self._is_configured = creds is not None and "access_token" in creds
+        return self._is_configured
+
+    @property
+    def client(self):
+        """Get or create Dropbox client."""
+        if self._client is None:
+            # Import here to avoid import errors if dropbox is not installed
+            try:
+                from dropbox import Dropbox
+            except ImportError:
+                raise ImportError(
+                    "dropbox package is not installed. "
+                    "Install it with: pip install dropbox"
+                )
+
+            creds = self._load_credentials()
+            if not creds:
+                raise RuntimeError("Dropbox credentials not configured in Secret Manager")
+
+            self._client = Dropbox(
+                oauth2_access_token=creds["access_token"],
+                oauth2_refresh_token=creds.get("refresh_token"),
+                app_key=creds.get("app_key"),
+                app_secret=creds.get("app_secret"),
+            )
+        return self._client
+
+    def list_folders(self, path: str) -> list[str]:
+        """
+        List folder names at path for brand code calculation.
+
+        Args:
+            path: Dropbox path to list (e.g., "/Karaoke/Tracks-Organized")
+
+        Returns:
+            List of folder names in the path
+        """
+        from dropbox.files import FolderMetadata
+
+        # Ensure path starts with /
+        if not path.startswith("/"):
+            path = f"/{path}"
+
+        logger.info(f"Listing folders at Dropbox path: {path}")
+
+        result = self.client.files_list_folder(path)
+        folders = []
+
+        # Get all entries (handling pagination)
+        while True:
+            for entry in result.entries:
+                if isinstance(entry, FolderMetadata):
+                    folders.append(entry.name)
+
+            if not result.has_more:
+                break
+            result = self.client.files_list_folder_continue(result.cursor)
+
+        logger.info(f"Found {len(folders)} folders in {path}")
+        return folders
+
+    def get_next_brand_code(self, path: str, brand_prefix: str) -> str:
+        """
+        Calculate next brand code from existing folders.
+
+        Scans the folder for existing brand codes like "NOMAD-0001" and
+        returns the next sequential code.
+
+        Args:
+            path: Dropbox path containing organized folders
+            brand_prefix: Brand prefix (e.g., "NOMAD")
+
+        Returns:
+            Next brand code (e.g., "NOMAD-1164")
+        """
+        folders = self.list_folders(path)
+        pattern = re.compile(rf"^{re.escape(brand_prefix)}-(\d{{4}})")
+
+        max_num = 0
+        for folder in folders:
+            match = pattern.match(folder)
+            if match:
+                num = int(match.group(1))
+                max_num = max(max_num, num)
+
+        next_code = f"{brand_prefix}-{max_num + 1:04d}"
+        logger.info(f"Next brand code for {brand_prefix}: {next_code} (max existing: {max_num})")
+        return next_code
+
+    def upload_file(self, local_path: str, remote_path: str) -> None:
+        """
+        Upload a single file to Dropbox.
+
+        Args:
+            local_path: Local file path
+            remote_path: Dropbox destination path (must start with /)
+        """
+        from dropbox.files import WriteMode
+
+        # Ensure remote path starts with /
+        if not remote_path.startswith("/"):
+            remote_path = f"/{remote_path}"
+
+        file_size = os.path.getsize(local_path)
+        logger.info(f"Uploading {local_path} ({file_size / 1024 / 1024:.1f} MB) to {remote_path}")
+
+        # For large files (>150MB), use upload sessions
+        CHUNK_SIZE = 150 * 1024 * 1024  # 150 MB
+
+        with open(local_path, "rb") as f:
+            if file_size <= CHUNK_SIZE:
+                # Simple upload for smaller files
+                self.client.files_upload(f.read(), remote_path, mode=WriteMode.overwrite)
+            else:
+                # Chunked upload for large files
+                self._upload_large_file(f, remote_path, file_size)
+
+        logger.info(f"Successfully uploaded to {remote_path}")
+
+    def _upload_large_file(self, file_obj, remote_path: str, file_size: int) -> None:
+        """Upload a large file using upload sessions."""
+        from dropbox.files import CommitInfo, UploadSessionCursor, WriteMode
+
+        CHUNK_SIZE = 150 * 1024 * 1024  # 150 MB
+
+        # Start upload session
+        session_start = self.client.files_upload_session_start(file_obj.read(CHUNK_SIZE))
+        cursor = UploadSessionCursor(
+            session_id=session_start.session_id,
+            offset=file_obj.tell(),
+        )
+        commit = CommitInfo(path=remote_path, mode=WriteMode.overwrite)
+
+        # Upload remaining chunks
+        while file_obj.tell() < file_size:
+            remaining = file_size - file_obj.tell()
+            if remaining <= CHUNK_SIZE:
+                # Final chunk
+                self.client.files_upload_session_finish(
+                    file_obj.read(CHUNK_SIZE),
+                    cursor,
+                    commit,
+                )
+            else:
+                # Intermediate chunk
+                self.client.files_upload_session_append_v2(
+                    file_obj.read(CHUNK_SIZE),
+                    cursor,
+                )
+                cursor.offset = file_obj.tell()
+
+    def upload_folder(self, local_dir: str, remote_path: str) -> None:
+        """
+        Recursively upload all files and subdirectories to Dropbox folder.
+
+        Args:
+            local_dir: Local directory to upload
+            remote_path: Dropbox destination folder path
+        """
+        # Ensure remote path starts with /
+        if not remote_path.startswith("/"):
+            remote_path = f"/{remote_path}"
+
+        logger.info(f"Uploading folder {local_dir} to {remote_path}")
+
+        uploaded_count = 0
+        for root, _dirs, files in os.walk(local_dir):
+            # Calculate the relative path from local_dir to current root
+            rel_root = os.path.relpath(root, local_dir)
+            if rel_root == ".":
+                current_remote = remote_path
+            else:
+                current_remote = f"{remote_path}/{rel_root}"
+
+            for filename in files:
+                local_file = os.path.join(root, filename)
+                remote_file = f"{current_remote}/{filename}"
+                self.upload_file(local_file, remote_file)
+                uploaded_count += 1
+
+        logger.info(f"Uploaded {uploaded_count} files to {remote_path}")
+
+    def create_shared_link(self, path: str) -> str:
+        """
+        Create and return a shared link for the path.
+
+        Args:
+            path: Dropbox path to share
+
+        Returns:
+            Shared link URL
+        """
+        from dropbox.exceptions import ApiError
+        from dropbox.sharing import SharedLinkSettings
+
+        # Ensure path starts with /
+        if not path.startswith("/"):
+            path = f"/{path}"
+
+        logger.info(f"Creating shared link for: {path}")
+
+        try:
+            # Try to create a new shared link
+            settings = SharedLinkSettings(requested_visibility=None)
+            link = self.client.sharing_create_shared_link_with_settings(path, settings)
+            logger.info(f"Created new shared link: {link.url}")
+            return link.url
+        except ApiError as e:
+            # Link may already exist - try to get existing link
+            if e.error.is_shared_link_already_exists():
+                logger.info("Shared link already exists, retrieving existing link")
+                links = self.client.sharing_list_shared_links(path=path, direct_only=True)
+                if links.links:
+                    logger.info(f"Found existing shared link: {links.links[0].url}")
+                    return links.links[0].url
+            raise
+
+    def delete_folder(self, path: str) -> bool:
+        """
+        Delete a folder and all its contents from Dropbox.
+
+        Args:
+            path: Dropbox path to delete (e.g., "/Karaoke/Tracks-Organized/NOMAD-1234 - Artist - Title")
+
+        Returns:
+            True if deleted successfully, False otherwise
+        """
+        from dropbox.exceptions import ApiError
+
+        # Ensure path starts with /
+        if not path.startswith("/"):
+            path = f"/{path}"
+
+        logger.info(f"Deleting Dropbox folder: {path}")
+
+        try:
+            self.client.files_delete_v2(path)
+            logger.info(f"Successfully deleted: {path}")
+            return True
+        except ApiError as e:
+            if e.error.is_path_lookup() and e.error.get_path_lookup().is_not_found():
+                logger.warning(f"Folder not found (already deleted?): {path}")
+                return True  # Consider it success if already gone
+            logger.error(f"Failed to delete Dropbox folder: {e}")
+            return False
+        except Exception as e:
+            logger.error(f"Error deleting Dropbox folder: {e}")
+            return False
+
+
+def get_dropbox_service() -> DropboxService:
+    """Factory function to get a DropboxService instance."""
+    return DropboxService()