TonieToolbox 0.4.2__py3-none-any.whl → 0.5.0a1__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/recursive_processor.py

@@ -290,20 +290,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