Updates

app/services/podcast_downloader.py

@@ -12,19 +12,38 @@ from app.models.settings import Settings
 # Set up logging
 logger = logging.getLogger(__name__)
 
-def download_episode(episode):
+def download_episode(episode_id, progress_callback=None):
     """
     Download a podcast episode.
 
     Args:
-        episode: Episode model instance.
+        episode_id: ID of the Episode to download.
+        progress_callback (callable, optional): Callback function for progress updates.
 
     Returns:
         str: Path to the downloaded file.
     """
+    from app.models.podcast import Episode, Podcast
+
+    if progress_callback:
+        progress_callback(2, "Loading episode data")
+
+    # Load the episode with its podcast relationship
+    episode = Episode.query.get(episode_id)
+    if not episode:
+        raise ValueError(f"Episode with ID {episode_id} not found")
+
+    # Explicitly load the podcast to avoid lazy loading issues
+    podcast = Podcast.query.get(episode.podcast_id)
+    if not podcast:
+        raise ValueError(f"Podcast with ID {episode.podcast_id} not found")
+
     if not episode.audio_url:
         raise ValueError("Episode has no audio URL")
 
+    if progress_callback:
+        progress_callback(5, "Getting settings")
+
     # Get settings
     settings = Settings.query.first()
     if not settings:
@@ -39,20 +58,28 @@ def download_episode(episode):
     download_path = settings.download_path
     os.makedirs(download_path, exist_ok=True)
 
+    if progress_callback:
+        progress_callback(10, "Formatting filename")
+
+    # Use podcast's naming format if available, otherwise use global settings
+    naming_format = podcast.naming_format or settings.naming_format
+
     # Format filename using the naming format
-    podcast = episode.podcast
-    filename = format_filename(settings.naming_format, podcast, episode)
+    filename = format_filename(naming_format, podcast, episode)
 
     # Ensure the directory exists
     file_dir = os.path.dirname(os.path.join(download_path, filename))
     os.makedirs(file_dir, exist_ok=True)
 
     # Add file extension based on content type
-    file_path = os.path.join(download_path, filename)
+    file_path = os.path.normpath(os.path.join(download_path, filename))
 
     # Download the file
     try:
-        response = requests.get(episode.audio_url, stream=True)
+        if progress_callback:
+            progress_callback(15, "Connecting to server")
+
+        response = requests.get(episode.audio_url, stream=True, timeout=30)
         response.raise_for_status()
 
         # Get content type and set appropriate extension
@@ -70,17 +97,37 @@ def download_episode(episode):
         else:
             file_path += '.mp3'  # Default to mp3
 
+        # Get file size if available
+        file_size = int(response.headers.get('Content-Length', 0))
+        episode.file_size = file_size
+
+        if progress_callback:
+            progress_callback(20, "Starting download")
+
         # Write the file
+        downloaded_bytes = 0
         with open(file_path, 'wb') as f:
             for chunk in response.iter_content(chunk_size=8192):
                 if chunk:
                     f.write(chunk)
+                    downloaded_bytes += len(chunk)
+
+                    # Update progress if file size is known
+                    if file_size > 0 and progress_callback:
+                        progress = 20 + int((downloaded_bytes / file_size) * 70)  # Scale to 20-90%
+                        progress_callback(min(progress, 90), f"Downloading: {downloaded_bytes/1024/1024:.1f}MB / {file_size/1024/1024:.1f}MB")
+
+        if progress_callback:
+            progress_callback(95, "Updating database")
 
         # Update episode in database
         episode.downloaded = True
         episode.file_path = file_path
         db.session.commit()
 
+        if progress_callback:
+            progress_callback(100, "Download complete")
+
         logger.info(f"Downloaded episode: {episode.title}")
         return file_path
 
@@ -100,22 +147,58 @@ def format_filename(format_string, podcast, episode):
     Returns:
         str: Formatted filename.
     """
+    # Calculate absolute number if needed
+    absolute_number = ''
+    if '{absolute_number}' in format_string:
+        from app.models.podcast import Episode
+        # Get all episodes for this podcast ordered by published date
+        episodes = Episode.query.filter_by(podcast_id=podcast.id).order_by(Episode.published_date.asc()).all()
+        # Find the position of the current episode in the ordered list
+        for i, ep in enumerate(episodes, 1):
+            if ep.id == episode.id:
+                absolute_number = str(i)
+                break
+
     # Create a dictionary with all available variables
     format_vars = {
         'podcast_title': sanitize_filename(podcast.title),
         'episode_title': sanitize_filename(episode.title),
         'episode_number': sanitize_filename(str(episode.episode_number)) if episode.episode_number else '',
+        'season': sanitize_filename(str(episode.season)) if episode.season else '',
+        # Format season_episode as S01E01, ensuring season is always included
+        'season_episode': (
+            # If we have season and episode_number is a digit, format as S01E01
+            f"S{episode.season:02d}E{int(episode.episode_number):02d}" 
+            if episode.season and episode.episode_number and episode.episode_number.isdigit() 
+            # If episode_number exists but is not a digit, format as S01E{episode_number}
+            else f"S{episode.season or 1:02d}E{episode.episode_number}" 
+            if episode.episode_number 
+            # Otherwise, return empty string
+            else ''
+        ),
         'published_date': episode.published_date.strftime('%Y-%m-%d') if episode.published_date else '',
-        'author': sanitize_filename(podcast.author) if podcast.author else ''
+        'author': sanitize_filename(podcast.author) if podcast.author else '',
+        'explicit': 'explicit' if episode.explicit else '',
+        'absolute_number': sanitize_filename(absolute_number)
     }
 
     # Format the string
     try:
-        return format_string.format(**format_vars)
+        formatted_path = format_string.format(**format_vars)
     except KeyError as e:
         logger.warning(f"Invalid format variable: {str(e)}")
         # Fall back to a simple format
-        return f"{format_vars['podcast_title']}/{format_vars['episode_title']}"
+        formatted_path = f"{format_vars['podcast_title']}/{format_vars['episode_title']}"
+
+    # Replace forward slashes with OS-specific path separator
+    formatted_path = formatted_path.replace('/', os.path.sep)
+
+    # Handle empty path segments by removing them
+    path_parts = formatted_path.split(os.path.sep)
+    path_parts = [part for part in path_parts if part.strip()]
+
+    # Rejoin the path with proper separators
+    return os.path.sep.join(path_parts)
 
 def sanitize_filename(filename):
     """
@@ -127,15 +210,28 @@ def sanitize_filename(filename):
     Returns:
         str: Sanitized filename.
     """
+    if not filename:
+        return ""
+
     # Replace invalid characters
     invalid_chars = ['<', '>', ':', '"', '/', '\\', '|', '?', '*']
     for char in invalid_chars:
         filename = filename.replace(char, '_')
 
+    # Remove leading and trailing whitespace and periods
+    filename = filename.strip().strip('.')
+
+    # Replace multiple spaces with a single space
+    filename = ' '.join(filename.split())
+
     # Limit length
     if len(filename) > 100:
         filename = filename[:97] + '...'
 
+    # If filename is empty after sanitization, provide a default
+    if not filename:
+        filename = "unnamed"
+
     return filename
 
 def delete_old_episodes(days=30):
@@ -177,3 +273,141 @@ def delete_old_episodes(days=30):
     db.session.commit()
     logger.info(f"Deleted {count} old episodes")
     return count
+
+def verify_downloaded_episodes(podcast_id=None, progress_callback=None):
+    """
+    Verify that downloaded episodes still exist on disk and update their status.
+
+    Args:
+        podcast_id (int, optional): ID of the podcast to check. If None, check all podcasts.
+        progress_callback (callable, optional): Callback function for progress updates.
+
+    Returns:
+        dict: Statistics about the verification process.
+    """
+    from app.models.podcast import Episode, Podcast
+
+    # Get episodes to check
+    query = Episode.query.filter(Episode.downloaded == True)
+    if podcast_id:
+        query = query.filter(Episode.podcast_id == podcast_id)
+
+    episodes = query.all()
+    total = len(episodes)
+
+    if progress_callback:
+        progress_callback(0, f"Verifying {total} downloaded episodes")
+
+    missing = 0
+    for i, episode in enumerate(episodes):
+        if progress_callback and total > 0:
+            progress = int((i / total) * 100)
+            progress_callback(progress, f"Verifying episode {i+1}/{total}")
+
+        if not episode.file_path or not os.path.exists(episode.file_path):
+            episode.downloaded = False
+            if episode.file_path:
+                logger.warning(f"Episode file not found: {episode.file_path}")
+            missing += 1
+
+    db.session.commit()
+
+    if progress_callback:
+        progress_callback(100, f"Verification complete. {missing} episodes marked as not downloaded.")
+
+    logger.info(f"Verified {total} episodes. {missing} were missing.")
+    return {
+        'total_checked': total,
+        'missing': missing
+    }
+
+def rename_episode(episode_id, new_format=None, progress_callback=None):
+    """
+    Rename a downloaded episode file using a new format.
+
+    Args:
+        episode_id: ID of the Episode to rename.
+        new_format (str, optional): New format string. If None, use the podcast's format or the global settings format.
+        progress_callback (callable, optional): Callback function for progress updates.
+
+    Returns:
+        str: New file path.
+    """
+    from app.models.podcast import Episode, Podcast
+
+    if progress_callback:
+        progress_callback(5, "Loading episode data")
+
+    # Load the episode with its podcast relationship
+    episode = Episode.query.get(episode_id)
+    if not episode:
+        raise ValueError(f"Episode with ID {episode_id} not found")
+
+    if not episode.downloaded or not episode.file_path or not os.path.exists(episode.file_path):
+        raise ValueError("Episode is not downloaded or file does not exist")
+
+    if progress_callback:
+        progress_callback(10, "Getting podcast and format settings")
+
+    # Explicitly load the podcast to avoid lazy loading issues
+    podcast = Podcast.query.get(episode.podcast_id)
+    if not podcast:
+        raise ValueError(f"Podcast with ID {episode.podcast_id} not found")
+
+    settings = Settings.query.first()
+    if not settings:
+        settings = Settings(
+            download_path=current_app.config['DOWNLOAD_PATH'],
+            naming_format="{podcast_title}/{episode_title}"
+        )
+        db.session.add(settings)
+        db.session.commit()
+
+    # Use provided format, podcast's format, or global settings format
+    format_string = new_format or podcast.naming_format or settings.naming_format
+
+    if progress_callback:
+        progress_callback(20, "Formatting new filename")
+
+    # Format new filename
+    new_filename = format_filename(format_string, podcast, episode)
+
+    # Get file extension from current file
+    _, ext = os.path.splitext(episode.file_path)
+
+    # Create full path for new file
+    download_path = settings.download_path
+    new_file_path = os.path.normpath(os.path.join(download_path, new_filename + ext))
+
+    # Ensure the directory exists
+    new_file_dir = os.path.dirname(new_file_path)
+    os.makedirs(new_file_dir, exist_ok=True)
+
+    if progress_callback:
+        progress_callback(50, f"Renaming file to {new_file_path}")
+
+    # Rename the file
+    try:
+        # Check if the new path is different
+        if os.path.normpath(episode.file_path) != os.path.normpath(new_file_path):
+            os.rename(episode.file_path, new_file_path)
+            episode.file_path = new_file_path
+            db.session.commit()
+
+            if progress_callback:
+                progress_callback(100, "File renamed successfully")
+
+            logger.info(f"Renamed episode file: {episode.title} to {new_file_path}")
+            return new_file_path
+        else:
+            if progress_callback:
+                progress_callback(100, "File already has the correct name")
+
+            logger.info(f"Episode file already has the correct name: {new_file_path}")
+            return episode.file_path
+    except Exception as e:
+        if progress_callback:
+            progress_callback(100, f"Error renaming file: {str(e)}")
+
+        logger.error(f"Error renaming episode file: {str(e)}")
+        raise