TonieToolbox 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

TonieToolbox/artwork.py

@@ -0,0 +1,105 @@
+#!/usr/bin/python3
+"""
+Artwork handling functionality for TonieToolbox.
+"""
+
+import os
+import tempfile
+import shutil
+from typing import List, Optional, Tuple
+
+from .logger import get_logger
+from .teddycloud import TeddyCloudClient
+from .media_tags import extract_artwork, find_cover_image
+
+
+def upload_artwork(client: TeddyCloudClient, taf_filename, source_path, audio_files) -> Tuple[bool, Optional[str]]:
+    """
+    Find and upload artwork for a Tonie file.
+    
+    Args:
+        client: TeddyCloudClient instance to use for API communication
+        taf_filename: The filename of the Tonie file (.taf)
+        source_path: Source directory to look for artwork
+        audio_files: List of audio files to extract artwork from if needed        
+    Returns:
+        tuple: (success, artwork_url) where success is a boolean and artwork_url is the URL of the uploaded artwork
+    """
+    logger = get_logger('artwork')
+    logger.info("Looking for artwork for Tonie file: %s", taf_filename)
+    taf_basename = os.path.basename(taf_filename)
+    taf_name = os.path.splitext(taf_basename)[0]
+    artwork_path = None
+    temp_artwork = None
+    artwork_path = find_cover_image(source_path)
+    if not artwork_path and audio_files and len(audio_files) > 0:
+        logger.info("No cover image found, trying to extract from audio files")
+        temp_artwork = extract_artwork(audio_files[0])
+        if temp_artwork:
+            artwork_path = temp_artwork
+            logger.info("Extracted artwork from audio file: %s", temp_artwork)
+    
+    if not artwork_path:
+        logger.warning("No artwork found for %s", source_path)
+        return False, None
+        
+    logger.info("Found artwork: %s", artwork_path)
+    artwork_upload_path = "/custom_img"
+    artwork_ext = os.path.splitext(artwork_path)[1]
+    renamed_artwork_path = None
+    upload_success = False
+    artwork_url = None
+    
+    try:
+        renamed_artwork_path = os.path.join(os.path.dirname(artwork_path), 
+                                          f"{taf_name}{artwork_ext}")
+        
+        if renamed_artwork_path != artwork_path:
+            shutil.copy(artwork_path, renamed_artwork_path)
+            logger.debug("Created renamed artwork copy: %s", renamed_artwork_path)
+        
+        logger.info("Uploading artwork to path: %s as %s%s", 
+                  artwork_upload_path, taf_name, artwork_ext)
+        try:
+            response = client.upload_file(
+                file_path=renamed_artwork_path,                
+                destination_path=artwork_upload_path,
+                special="library"
+            )
+            upload_success = response.get('success', False)
+                
+            if not upload_success:
+                logger.error("Failed to upload %s to TeddyCloud", renamed_artwork_path)
+            else:
+                logger.info("Successfully uploaded %s to TeddyCloud", renamed_artwork_path)
+            logger.debug("Upload response: %s", response)
+        except Exception as e:
+            logger.error("Error uploading artwork: %s", e)
+            upload_success = False
+        
+        if upload_success:
+            if not artwork_upload_path.endswith('/'):
+                artwork_upload_path += '/'                
+            artwork_url = f"{artwork_upload_path}{taf_name}{artwork_ext}"
+            logger.debug("Artwork URL: %s", artwork_url)
+    
+    except Exception as e:
+        logger.error("Error during artwork handling: %s", e)
+        upload_success = False
+        
+    finally:
+        if renamed_artwork_path != artwork_path and renamed_artwork_path and os.path.exists(renamed_artwork_path):
+            try:
+                os.unlink(renamed_artwork_path)
+                logger.debug("Removed temporary renamed artwork file: %s", renamed_artwork_path)
+            except Exception as e:
+                logger.debug("Failed to remove temporary renamed artwork file: %s", e)
+        if temp_artwork and os.path.exists(temp_artwork):
+            try:
+                if temp_artwork.startswith(tempfile.gettempdir()):
+                    os.unlink(temp_artwork)
+                    logger.debug("Removed temporary extracted artwork file: %s", temp_artwork)
+            except Exception as e:
+                logger.debug("Failed to remove temporary artwork file: %s", e)
+    
+    return upload_success, artwork_url

TonieToolbox/audio_conversion.py

@@ -12,7 +12,7 @@ from .logger import get_logger
 logger = get_logger('audio_conversion')
 
 
-def get_opus_tempfile(ffmpeg_binary=None, opus_binary=None, filename=None, bitrate=48, vbr=True, keep_temp=False, auto_download=False):
+def get_opus_tempfile(ffmpeg_binary=None, opus_binary=None, filename=None, bitrate=48, vbr=True, keep_temp=False, auto_download=False, no_mono_conversion=False):
     """
     Convert an audio file to Opus format and return a temporary file handle.
     
@@ -24,12 +24,13 @@ def get_opus_tempfile(ffmpeg_binary=None, opus_binary=None, filename=None, bitra
         vbr: Whether to use variable bitrate encoding
         keep_temp: Whether to keep the temporary files for testing
         auto_download: Whether to automatically download dependencies if not found
+        no_mono_conversion: Whether to skip mono to stereo conversion
         
     Returns:
         tuple: (file handle, temp_file_path) or (file handle, None) if keep_temp is False
     """
-    logger.trace("Entering get_opus_tempfile(ffmpeg_binary=%s, opus_binary=%s, filename=%s, bitrate=%d, vbr=%s, keep_temp=%s, auto_download=%s)",
-                ffmpeg_binary, opus_binary, filename, bitrate, vbr, keep_temp, auto_download)
+    logger.trace("Entering get_opus_tempfile(ffmpeg_binary=%s, opus_binary=%s, filename=%s, bitrate=%d, vbr=%s, keep_temp=%s, auto_download=%s, no_mono_conversion=%s)",
+                ffmpeg_binary, opus_binary, filename, bitrate, vbr, keep_temp, auto_download, no_mono_conversion)
     
     logger.debug("Converting %s to Opus format (bitrate: %d kbps, vbr: %s)", filename, bitrate, vbr)
     
@@ -52,6 +53,38 @@ def get_opus_tempfile(ffmpeg_binary=None, opus_binary=None, filename=None, bitra
     vbr_parameter = "--vbr" if vbr else "--hard-cbr"
     logger.debug("Using encoding parameter: %s", vbr_parameter)
 
+    is_mono = False
+    ffprobe_path = None
+    ffmpeg_dir, ffmpeg_file = os.path.split(ffmpeg_binary)
+    ffprobe_candidates = [
+        os.path.join(ffmpeg_dir, 'ffprobe'),
+        os.path.join(ffmpeg_dir, 'ffprobe.exe'),
+        'ffprobe',
+        'ffprobe.exe',
+    ]
+    for candidate in ffprobe_candidates:
+        if os.path.exists(candidate):
+            ffprobe_path = candidate
+            break
+    if ffprobe_path:
+        try:
+            probe_cmd = [ffprobe_path, '-v', 'error', '-select_streams', 'a:0', '-show_entries', 'stream=channels', '-of', 'default=noprint_wrappers=1:nokey=1', filename]
+            logger.debug(f"Probing audio channels with: {' '.join(probe_cmd)}")
+            result = subprocess.run(probe_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+            if result.returncode == 0:
+                channels = result.stdout.strip()
+                logger.debug(f"Detected channels: {channels}")
+                if channels == '1':
+                    is_mono = True
+            else:
+                logger.warning(f"ffprobe failed to detect channels: {result.stderr}")
+        except Exception as e:
+            logger.warning(f"Mono detection failed: {e}")
+    else:
+        logger.warning("ffprobe not found, will always force stereo conversion for non-Opus input.")
+        is_mono = True  # Always force stereo if we can't check
+    logger.info(f"Mono detected: {is_mono}, no_mono_conversion: {no_mono_conversion}")
+
     temp_path = None
     if keep_temp:
         temp_dir = os.path.join(tempfile.gettempdir(), "tonie_toolbox_temp")
@@ -62,7 +95,12 @@ def get_opus_tempfile(ffmpeg_binary=None, opus_binary=None, filename=None, bitra
         
         logger.debug("Starting FFmpeg process")
         try:
-            ffmpeg_cmd = [ffmpeg_binary, "-hide_banner", "-loglevel", "warning", "-i", filename, "-f", "wav", "-ar", "48000", "-"]
+            if is_mono and not no_mono_conversion:
+                ffmpeg_cmd = [ffmpeg_binary, "-hide_banner", "-loglevel", "warning", "-i", filename, "-f", "wav", "-ar", "48000", "-ac", "2", "-"]
+                logger.info(f"Forcing stereo conversion for mono input: {' '.join(ffmpeg_cmd)}")
+            else:
+                ffmpeg_cmd = [ffmpeg_binary, "-hide_banner", "-loglevel", "warning", "-i", filename, "-f", "wav", "-ar", "48000", "-"]
+                logger.info(f"FFmpeg command: {' '.join(ffmpeg_cmd)}")
             logger.trace("FFmpeg command: %s", ffmpeg_cmd)
             ffmpeg_process = subprocess.Popen(ffmpeg_cmd, stdout=subprocess.PIPE)
         except FileNotFoundError:
@@ -106,7 +144,12 @@ def get_opus_tempfile(ffmpeg_binary=None, opus_binary=None, filename=None, bitra
         
         logger.debug("Starting FFmpeg process")
         try:
-            ffmpeg_cmd = [ffmpeg_binary, "-hide_banner", "-loglevel", "warning", "-i", filename, "-f", "wav", "-ar", "48000", "-"]
+            if is_mono and not no_mono_conversion:
+                ffmpeg_cmd = [ffmpeg_binary, "-hide_banner", "-loglevel", "warning", "-i", filename, "-f", "wav", "-ar", "48000", "-ac", "2", "-"]
+                logger.info(f"Forcing stereo conversion for mono input: {' '.join(ffmpeg_cmd)}")
+            else:
+                ffmpeg_cmd = [ffmpeg_binary, "-hide_banner", "-loglevel", "warning", "-i", filename, "-f", "wav", "-ar", "48000", "-"]
+                logger.info(f"FFmpeg command: {' '.join(ffmpeg_cmd)}")
             logger.trace("FFmpeg command: %s", ffmpeg_cmd)
             ffmpeg_process = subprocess.Popen(ffmpeg_cmd, stdout=subprocess.PIPE)
         except FileNotFoundError:

TonieToolbox/media_tags.py

@@ -267,6 +267,7 @@ def get_file_tags(file_path: str) -> Dict[str, Any]:
                         tags[TAG_MAPPING[tag_key_lower]] = normalize_tag_value(tag_value_str)
                         
         logger.debug("Successfully read %d tags from file", len(tags))
+        logger.debug("Tags: %s", str(tags))
         return tags
     except Exception as e:
         logger.error("Error reading tags from file %s: %s", file_path, str(e))
@@ -330,12 +331,12 @@ def extract_album_info(folder_path: str) -> Dict[str, str]:
     if not all_tags:
         logger.debug("Could not read tags from any files in folder")
         return {}
-    
-    # Try to find consistent album information
     result = {}
-    key_tags = ['album', 'albumartist', 'artist', 'date', 'genre']
+    all_tag_names = set()
+    for tags in all_tags:
+        all_tag_names.update(tags.keys())
     
-    for tag_name in key_tags:
+    for tag_name in all_tag_names:
         # Count occurrences of each value
         value_counts = {}
         for tags in all_tags:

TonieToolbox/recursive_processor.py

@@ -217,14 +217,10 @@ def get_folder_name_from_metadata(folder_path: str, use_media_tags: bool = False
     Returns:
         String with cleaned output name
     """
-    # Start with folder name metadata
     folder_meta = extract_folder_meta(folder_path)
-    output_name = None
-    
-    # Try to get metadata from audio files if requested
+    output_name = None    
     if use_media_tags:
         try:
-            # Import here to avoid circular imports
             from .media_tags import extract_album_info, format_metadata_filename, is_available, normalize_tag_value
             
             if is_available():
@@ -247,12 +243,15 @@ def get_folder_name_from_metadata(folder_path: str, use_media_tags: bool = False
                         if 'album' not in album_info or not album_info['album']:
                             album_info['album'] = normalize_tag_value(folder_meta['title'])
                     
-                    # Use template or default format
-                    format_template = template or "{album}"
-                    if 'artist' in album_info and album_info['artist']:
-                        format_template = format_template + " - {artist}"
-                    if 'number' in folder_meta and folder_meta['number']:
-                        format_template = "{tracknumber} - " + format_template
+                    if template:
+                        format_template = template
+                        logger.debug("Using provided name template: %s", format_template)
+                    else:                    
+                        format_template = "{album}"
+                        if 'artist' in album_info and album_info['artist']:
+                            format_template = format_template + " - {artist}"
+                        if 'number' in folder_meta and folder_meta['number']:
+                            format_template = "{tracknumber} - " + format_template
                     
                     formatted_name = format_metadata_filename(album_info, format_template)
                     
@@ -290,20 +289,26 @@ def get_folder_name_from_metadata(folder_path: str, use_media_tags: bool = False
     return output_name
 
 
-def process_recursive_folders(root_path: str, use_media_tags: bool = False, 
-                            name_template: str = None) -> List[Tuple[str, str, List[str]]]:
+def process_recursive_folders(root_path, use_media_tags=False, name_template=None):
     """
-    Process folders recursively and prepare data for conversion.
+    Process folders recursively for audio files to create Tonie files.
     
     Args:
-        root_path: Root directory to start processing from
-        use_media_tags: Whether to use media tags from audio files for naming
-        name_template: Optional template for formatting output names using media tags
-        
+        root_path (str): The root path to start processing from
+        use_media_tags (bool): Whether to use media tags for naming
+        name_template (str): Template for naming files using media tags
+    
     Returns:
-        List of tuples: (output_filename, folder_path, list_of_audio_files)
+        list: A list of tuples (output_name, folder_path, audio_files)
     """
+    logger = get_logger("recursive_processor")
     logger.info("Processing folders recursively: %s", root_path)
+    # Make sure the path exists
+    if not os.path.exists(root_path):
+        logger.error("Path does not exist: %s", root_path)
+        return []
+    
+    logger.info("Finding folders with audio files in: %s", root_path)
     
     # Get folder info with hierarchy details
     all_folders = find_audio_folders(root_path)

TonieToolbox/tags.py

@@ -0,0 +1,74 @@
+#!/usr/bin/python3
+"""
+TonieToolbox - Tags handling functionality.
+This module provides functionality to retrieve and display tags from a TeddyCloud instance.
+"""
+from .logger import get_logger
+from .teddycloud import TeddyCloudClient
+import json
+from typing import Optional, Union
+
+logger = get_logger('tags')
+
+def get_tags(client: TeddyCloudClient) -> bool:
+    """
+    Get and display tags from a TeddyCloud instance.
+    
+    Args:
+        client: TeddyCloudClient instance to use for API communication
+        
+    Returns:
+        True if tags were retrieved successfully, False otherwise
+    """
+    logger.info("Getting tags from TeddyCloud using provided client")
+    
+    response = client.get_tag_index()
+    
+    if not response:
+        logger.error("Failed to retrieve tags from TeddyCloud")
+        return False
+    if isinstance(response, dict) and 'tags' in response:
+        tags = response['tags']
+        logger.info("Successfully retrieved %d tags from TeddyCloud", len(tags))
+        
+        print("\nAvailable Tags from TeddyCloud:")
+        print("-" * 60)
+        
+        sorted_tags = sorted(tags, key=lambda x: (x.get('type', ''), x.get('uid', '')))
+        
+        for tag in sorted_tags:
+            uid = tag.get('uid', 'Unknown UID')
+            tag_type = tag.get('type', 'Unknown')
+            valid = "✓" if tag.get('valid', False) else "✗"
+            series = tag.get('tonieInfo', {}).get('series', '')
+            episode = tag.get('tonieInfo', {}).get('episode', '')
+            source = tag.get('source', '')
+            print(f"UID: {uid} ({tag_type}) - Valid: {valid}")
+            if series:
+                print(f"Series: {series}")
+            if episode:
+                print(f"Episode: {episode}")
+            if source:
+                print(f"Source: {source}")
+            tracks = tag.get('tonieInfo', {}).get('tracks', [])
+            if tracks:
+                print("Tracks:")
+                for i, track in enumerate(tracks, 1):
+                    print(f"  {i}. {track}")
+            track_seconds = tag.get('trackSeconds', [])
+            if track_seconds and len(track_seconds) > 1:
+                total_seconds = track_seconds[-1]
+                minutes = total_seconds // 60
+                seconds = total_seconds % 60
+                print(f"Duration: {minutes}:{seconds:02d} ({len(track_seconds)-1} tracks)")
+            
+            print("-" * 60)
+    else:
+        logger.info("Successfully retrieved tag data from TeddyCloud")
+        print("\nTag data from TeddyCloud:")
+        print("-" * 60)        
+        print(json.dumps(response, indent=2))
+        
+        print("-" * 60)
+    
+    return True