TonieToolbox 0.5.0a1__py3-none-any.whl → 0.5.1__py3-none-any.whl

TonieToolbox/__init__.py

@@ -2,4 +2,4 @@
 TonieToolbox - Convert audio files to Tonie box compatible format
 """
 
-__version__ = '0.5.0a1'
+__version__ = '0.5.1'

TonieToolbox/__main__.py

@@ -10,19 +10,18 @@ import logging
 from . import __version__
 from .audio_conversion import get_input_files, append_to_filename
 from .tonie_file import create_tonie_file
-from .tonie_analysis import check_tonie_file, check_tonie_file_cli, split_to_opus_files
+from .tonie_analysis import check_tonie_file, check_tonie_file_cli, split_to_opus_files, compare_taf_files
 from .dependency_manager import get_ffmpeg_binary, get_opus_binary
-from .logger import setup_logging, get_logger
+from .logger import TRACE, setup_logging, get_logger
 from .filename_generator import guess_output_filename
 from .version_handler import check_for_updates, clear_version_cache
 from .recursive_processor import process_recursive_folders
-from .media_tags import is_available as is_media_tags_available, ensure_mutagen, extract_album_info, format_metadata_filename
+from .media_tags import is_available as is_media_tags_available, ensure_mutagen, extract_album_info, format_metadata_filename, get_file_tags
 from .teddycloud import TeddyCloudClient
 from .tags import get_tags
-from .tonies_json import fetch_and_update_tonies_json
+from .tonies_json import fetch_and_update_tonies_json_v1, fetch_and_update_tonies_json_v2
 from .artwork import upload_artwork
 
-
 def main():
     """Entry point for the TonieToolbox application."""
     parser = argparse.ArgumentParser(description='Create Tonie compatible file from Ogg opus file(s).')
@@ -52,6 +51,8 @@ def main():
                        help='Delay between retry attempts in seconds (default: 5)')
     teddycloud_group.add_argument('--create-custom-json', action='store_true',
                        help='Fetch and update custom Tonies JSON data')
+    teddycloud_group.add_argument('--version-2', action='store_true',
+                       help='Use version 2 of the Tonies JSON format (default: version 1)')
     # ------------- Parser - Authentication options for TeddyCloud -------------
     teddycloud_group.add_argument('--username', action='store', metavar='USERNAME',
                        help='Username for basic authentication')
@@ -87,6 +88,8 @@ def main():
                         help='Save output files in the source directory instead of output directory')
     parser.add_argument('-fc', '--force-creation', action='store_true', default=False,
                         help='Force creation of Tonie file even if it already exists')
+    parser.add_argument('--no-mono-conversion', action='store_true',
+                        help='Do not convert mono audio to stereo (default: convert mono to stereo)')
     # ------------- Parser - Debug TAFs -------------
     parser.add_argument('-k', '--keep-temp', action='store_true', 
                        help='Keep temporary opus files in a temp folder for testing')
@@ -129,7 +132,6 @@ def main():
 
     # ------------- Logging -------------
     if args.trace:
-        from .logger import TRACE
         log_level = TRACE
     elif args.debug:
         log_level = logging.DEBUG
@@ -203,27 +205,39 @@ def main():
             success = get_tags(client)
             logger.debug( "Exiting with code %d", 0 if success else 1)
             sys.exit(0 if success else 1)
-            
-    # ------------- Direct Upload -------------
-        if args.upload and not args.recursive:
-            logger.debug("Upload to TeddyCloud requested: %s", teddycloud_url)
-            logger.trace("TeddyCloud upload parameters: path=%s, special_folder=%s, ignore_ssl=%s", 
-                      args.path, args.special_folder, args.ignore_ssl_verify)
+    
+    # ------------- Show Media Tags -------------
+    if args.show_tags:
+        files = get_input_files(args.input_filename)
+        logger.debug("Found %d files to process", len(files))
+        if len(files) == 0:
+            logger.error("No files found for pattern %s", args.input_filename)
+            sys.exit(1)
+        for file_index, file_path in enumerate(files):
+            tags = get_file_tags(file_path)
+            if tags:
+                print(f"\nFile {file_index + 1}: {os.path.basename(file_path)}")
+                print("-" * 40)
+                for tag_name, tag_value in sorted(tags.items()):
+                    print(f"{tag_name}: {tag_value}")
+            else:
+                print(f"\nFile {file_index + 1}: {os.path.basename(file_path)} - No tags found")
+        sys.exit(0)
+    # ------------- Direct Upload -------------    
+        if os.path.exists(args.input_filename) and os.path.isfile(args.input_filename):
+            file_path = args.input_filename
+            file_size = os.path.getsize(file_path)
+            file_ext = os.path.splitext(file_path)[1].lower()    
+    
+            if args.upload and not args.recursive and file_ext == '.taf':
+                logger.debug("Upload to TeddyCloud requested: %s", teddycloud_url)
+                logger.trace("TeddyCloud upload parameters: path=%s, special_folder=%s, ignore_ssl=%s", 
+                          args.path, args.special_folder, args.ignore_ssl_verify)
 
-            if not args.input_filename:
-                logger.error("Missing input file for --upload. Provide a file path as SOURCE argument.")
-                logger.trace("Exiting with code 1 due to missing input file")
-                sys.exit(1)
 
-            if os.path.exists(args.input_filename) and os.path.isfile(args.input_filename):
-                file_path = args.input_filename
-                file_size = os.path.getsize(file_path)
-                file_ext = os.path.splitext(file_path)[1].lower()
-                
                 logger.debug("File to upload: %s (size: %d bytes, type: %s)", 
                           file_path, file_size, file_ext)
                 logger.info("Uploading %s to TeddyCloud %s", file_path, teddycloud_url)
-                
                 logger.trace("Starting upload process for %s", file_path)
                 response = client.upload_file(
                     destination_path=args.path, 
@@ -231,56 +245,59 @@ def main():
                     special=args.special_folder,
                 )
                 logger.trace("Upload response received: %s", response)
-                
                 upload_success = response.get('success', False)
                 if not upload_success:
                     error_msg = response.get('message', 'Unknown error')
-                    logger.error("Failed to upload %s to TeddyCloud: %s", file_path, error_msg)
+                    logger.error("Failed to upload %s to TeddyCloud: %s (HTTP Status: %s, Response: %s)", 
+                                 file_path, error_msg, response.get('status_code', 'Unknown'), response)
                     logger.trace("Exiting with code 1 due to upload failure")
                     sys.exit(1)
                 else:
                     logger.info("Successfully uploaded %s to TeddyCloud", file_path)
                     logger.debug("Upload response details: %s", 
                               {k: v for k, v in response.items() if k != 'success'})
-                
                 artwork_url = None
                 if args.include_artwork and file_path.lower().endswith('.taf'):
                     source_dir = os.path.dirname(file_path)
                     logger.info("Looking for artwork to upload for %s", file_path)
                     logger.debug("Searching for artwork in directory: %s", source_dir)
-                    
                     logger.trace("Calling upload_artwork function")
                     success, artwork_url = upload_artwork(client, file_path, source_dir, [])
                     logger.trace("upload_artwork returned: success=%s, artwork_url=%s", 
                               success, artwork_url)
-                    
                     if success:
                         logger.info("Successfully uploaded artwork for %s", file_path)
                         logger.debug("Artwork URL: %s", artwork_url)
                     else:
                         logger.warning("Failed to upload artwork for %s", file_path)
                         logger.debug("No suitable artwork found or upload failed")
-                
                 if args.create_custom_json and file_path.lower().endswith('.taf'):
                     output_dir = './output'
                     logger.debug("Creating/ensuring output directory for JSON: %s", output_dir)
                     if not os.path.exists(output_dir):
                         os.makedirs(output_dir, exist_ok=True)
                         logger.trace("Created output directory: %s", output_dir)
-
                     logger.debug("Updating tonies.custom.json with: taf=%s, artwork_url=%s", 
                               file_path, artwork_url)
-                    success = fetch_and_update_tonies_json(client, file_path, [], artwork_url, output_dir)
+                    client_param = client
+
+                    if args.version_2:
+                        logger.debug("Using version 2 of the Tonies JSON format")
+                        success = fetch_and_update_tonies_json_v2(client_param, file_path, [], artwork_url, output_dir)
+                    else:
+                        success = fetch_and_update_tonies_json_v1(client_param, file_path, [], artwork_url, output_dir)
                     if success:
                         logger.info("Successfully updated Tonies JSON for %s", file_path)
                     else:
                         logger.warning("Failed to update Tonies JSON for %s", file_path)
                         logger.debug("fetch_and_update_tonies_json returned failure")
-                
                 logger.trace("Exiting after direct upload with code 0")
                 sys.exit(0)
             elif not args.recursive:
-                logger.error("File not found or not a regular file: %s", args.input_filename)
+                if not os.path.exists(args.input_filename):
+                    logger.error("File not found: %s", args.input_filename)
+                elif not os.path.isfile(args.input_filename):
+                    logger.error("Not a regular file: %s", args.input_filename)
                 logger.debug("File exists: %s, Is file: %s", 
                           os.path.exists(args.input_filename), 
                           os.path.isfile(args.input_filename) if os.path.exists(args.input_filename) else False)
@@ -364,10 +381,16 @@ def main():
             if not skip_creation:
                 create_tonie_file(task_out_filename, audio_files, args.no_tonie_header, args.user_timestamp,
                                args.bitrate, not args.cbr, ffmpeg_binary, opus_binary, args.keep_temp, 
-                               args.auto_download, not args.use_legacy_tags)
+                               args.auto_download, not args.use_legacy_tags, 
+                               no_mono_conversion=args.no_mono_conversion)
                 logger.info("Successfully created Tonie file: %s", task_out_filename)
             
             created_files.append(task_out_filename)
+
+    # ------------- Initialization -------------------         
+
+            artwork_url = None
+            
     # ------------- Recursive File Upload -------------       
             if args.upload:                
                 response = client.upload_file(
@@ -391,12 +414,19 @@ def main():
                         logger.warning("Failed to upload artwork for %s", task_out_filename)
                             
                     # tonies.custom.json generation
-                if args.create_custom_json:
-                    success = fetch_and_update_tonies_json(client, task_out_filename, audio_files, artwork_url, output_dir)
-                    if success:
-                        logger.info("Successfully updated Tonies JSON for %s", task_out_filename)
-                    else:
-                        logger.warning("Failed to update Tonies JSON for %s", task_out_filename)
+            if args.create_custom_json:
+                base_path = os.path.dirname(args.input_filename)
+                json_output_dir = base_path if args.output_to_source else output_dir
+                client_param = client if 'client' in locals() else None
+                if args.version_2:
+                    logger.debug("Using version 2 of the Tonies JSON format")
+                    success = fetch_and_update_tonies_json_v2(client_param, task_out_filename, audio_files, artwork_url, json_output_dir)
+                else:
+                    success = fetch_and_update_tonies_json_v1(client_param, task_out_filename, audio_files, artwork_url, json_output_dir)
+                if success:
+                    logger.info("Successfully updated Tonies JSON for %s", task_out_filename)
+                else:
+                    logger.warning("Failed to update Tonies JSON for %s", task_out_filename)
         
         logger.info("Recursive processing completed. Created %d Tonie files.", len(process_tasks))
         sys.exit(0)
@@ -415,7 +445,6 @@ def main():
             split_to_opus_files(args.input_filename, args.output_filename)
             sys.exit(0)
         elif args.compare:
-            from .tonie_analysis import compare_taf_files
             logger.info("Comparing Tonie files: %s and %s", args.input_filename, args.compare)
             result = compare_taf_files(args.input_filename, args.compare, args.detailed_compare)
             sys.exit(0 if result else 1)
@@ -426,26 +455,12 @@ def main():
     if len(files) == 0:
         logger.error("No files found for pattern %s", args.input_filename)
         sys.exit(1)
-    if args.show_tags:
-        from .media_tags import get_file_tags
-        logger.info("Showing media tags for input files:")
-        
-        for file_index, file_path in enumerate(files):
-            tags = get_file_tags(file_path)
-            if tags:
-                print(f"\nFile {file_index + 1}: {os.path.basename(file_path)}")
-                print("-" * 40)
-                for tag_name, tag_value in sorted(tags.items()):
-                    print(f"{tag_name}: {tag_value}")
-            else:
-                print(f"\nFile {file_index + 1}: {os.path.basename(file_path)} - No tags found")
-        sys.exit(0)
+    
     guessed_name = None
     if args.use_media_tags:
         if len(files) > 1 and os.path.dirname(files[0]) == os.path.dirname(files[-1]):
             folder_path = os.path.dirname(files[0])            
-            logger.debug("Extracting album info from folder: %s", folder_path)
-            
+            logger.debug("Extracting album info from folder: %s", folder_path)            
             album_info = extract_album_info(folder_path)
             if album_info:
                 template = args.name_template or "{album} - {artist}"
@@ -457,7 +472,7 @@ def main():
                 else:
                     logger.debug("Could not format filename from album metadata")
         elif len(files) == 1:
-            from .media_tags import get_file_tags, format_metadata_filename
+
             
             tags = get_file_tags(files[0])
             if tags:
@@ -471,9 +486,7 @@ def main():
                     logger.debug("Could not format filename from file metadata")
         
         # For multiple files from different folders, try to use common tags if they exist
-        elif len(files) > 1:
-            from .media_tags import get_file_tags, format_metadata_filename
-            
+        elif len(files) > 1:            
             # Try to find common tags among files
             common_tags = {}
             for file_path in files:
@@ -547,7 +560,8 @@ def main():
     logger.info("Creating Tonie file: %s with %d input file(s)", out_filename, len(files))
     create_tonie_file(out_filename, files, args.no_tonie_header, args.user_timestamp,
                      args.bitrate, not args.cbr, ffmpeg_binary, opus_binary, args.keep_temp, 
-                     args.auto_download, not args.use_legacy_tags)
+                     args.auto_download, not args.use_legacy_tags, 
+                     no_mono_conversion=args.no_mono_conversion)
     logger.info("Successfully created Tonie file: %s", out_filename)
     
     # ------------- Single File Upload -------------  
@@ -571,13 +585,19 @@ def main():
                 logger.info("Successfully uploaded artwork for %s", out_filename)
             else:
                 logger.warning("Failed to upload artwork for %s", out_filename)        
-            # tonies.custom.json generation
-        if args.create_custom_json:
-            success = fetch_and_update_tonies_json(client, out_filename, files, artwork_url)
-            if success:
-                logger.info("Successfully updated Tonies JSON for %s", out_filename)
-            else:
-                logger.warning("Failed to update Tonies JSON for %s", out_filename)
+    
+    if args.create_custom_json:
+        json_output_dir = source_dir if args.output_to_source else './output'
+        client_param = client if 'client' in locals() else None
+        if args.version_2:
+            logger.debug("Using version 2 of the Tonies JSON format")
+            success = fetch_and_update_tonies_json_v2(client_param, out_filename, files, artwork_url, json_output_dir)
+        else:
+            success = fetch_and_update_tonies_json_v1(client_param, out_filename, files, artwork_url, json_output_dir)
+        if success:
+            logger.info("Successfully updated Tonies JSON for %s", out_filename)
+        else:
+            logger.warning("Failed to update Tonies JSON for %s", out_filename)
 
 if __name__ == "__main__":
     main()

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:
@@ -244,9 +287,34 @@ def get_input_files(input_filename):
         
         logger.debug("Found %d files in list file", len(input_files))
     else:
-        logger.debug("Processing glob pattern: %s", input_filename)
+        logger.debug("Processing input path: %s", input_filename)
+        
+        # Try the exact pattern first
         input_files = sorted(filter_directories(glob.glob(input_filename)))
-        logger.debug("Found %d files matching pattern", len(input_files))
+        if input_files:
+            logger.debug("Found %d files matching exact pattern", len(input_files))
+        else:
+            # If no extension is provided, try appending a wildcard for extension
+            _, ext = os.path.splitext(input_filename)
+            if not ext:
+                wildcard_pattern = input_filename + ".*"
+                logger.debug("No extension in pattern, trying with wildcard: %s", wildcard_pattern)
+                input_files = sorted(filter_directories(glob.glob(wildcard_pattern)))
+                
+                # If still no files found, try treating it as a directory
+                if not input_files and os.path.exists(os.path.dirname(input_filename)):
+                    potential_dir = input_filename
+                    if os.path.isdir(potential_dir):
+                        logger.debug("Treating input as directory: %s", potential_dir)
+                        dir_glob = os.path.join(potential_dir, "*")
+                        input_files = sorted(filter_directories(glob.glob(dir_glob)))
+                        if input_files:
+                            logger.debug("Found %d audio files in directory", len(input_files))
+                
+                if input_files:
+                    logger.debug("Found %d files after trying alternatives", len(input_files))
+                else:
+                    logger.warning("No files found for pattern %s even after trying alternatives", input_filename)
     
     logger.trace("Exiting get_input_files() with %d files", len(input_files))
     return input_files

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)
                     

TonieToolbox/tonie_file.py

@@ -15,7 +15,6 @@ from .ogg_page import OggPage
 from .constants import OPUS_TAGS, SAMPLE_RATE_KHZ, TIMESTAMP_DEDUCT
 from .logger import get_logger
 
-# Setup logging
 logger = get_logger('tonie_file')
 
 
@@ -38,7 +37,6 @@ def toniefile_comment_add(buffer, length, comment_str):
     buffer[length:length+4] = struct.pack("<I", str_length)
     length += 4
     
-    # Add the actual string
     buffer[length:length+str_length] = comment_str.encode('utf-8')
     length += str_length
     
@@ -115,49 +113,38 @@ def prepare_opus_tags(page, custom_tags=False, bitrate=64, vbr=True, opus_binary
         # Use custom tags for TonieToolbox
         # Create buffer for opus tags (similar to teddyCloud implementation)
         logger.debug("Creating custom Opus tags")
-        comment_data = bytearray(0x1B4)  # Same size as in teddyCloud
-        
-        # OpusTags signature
+        comment_data = bytearray(0x1B4)
         comment_data_pos = 0
         comment_data[comment_data_pos:comment_data_pos+8] = b"OpusTags"
-        comment_data_pos += 8
-        
+        comment_data_pos += 8        
         # Vendor string
-        comment_data_pos = toniefile_comment_add(comment_data, comment_data_pos, "TonieToolbox")
-        
+        comment_data_pos = toniefile_comment_add(comment_data, comment_data_pos, "TonieToolbox")        
         # Number of comments (3 comments: version, encoder info, and encoder options)
         comments_count = 3
         comment_data[comment_data_pos:comment_data_pos+4] = struct.pack("<I", comments_count)
-        comment_data_pos += 4
-        
+        comment_data_pos += 4        
         # Add version information
         from . import __version__
         version_str = f"version={__version__}"
-        comment_data_pos = toniefile_comment_add(comment_data, comment_data_pos, version_str)
-        
+        comment_data_pos = toniefile_comment_add(comment_data, comment_data_pos, version_str)        
         # Get actual opusenc version
         from .dependency_manager import get_opus_version
         encoder_info = get_opus_version(opus_binary)
-        comment_data_pos = toniefile_comment_add(comment_data, comment_data_pos, f"encoder={encoder_info}")
-        
+        comment_data_pos = toniefile_comment_add(comment_data, comment_data_pos, f"encoder={encoder_info}")        
         # Create encoder options string with actual settings
         vbr_opt = "--vbr" if vbr else "--cbr"
         encoder_options = f"encoder_options=--bitrate {bitrate} {vbr_opt}"
-        comment_data_pos = toniefile_comment_add(comment_data, comment_data_pos, encoder_options)
-        
+        comment_data_pos = toniefile_comment_add(comment_data, comment_data_pos, encoder_options)        
         # Add padding
         remain = len(comment_data) - comment_data_pos - 4
         comment_data[comment_data_pos:comment_data_pos+4] = struct.pack("<I", remain)
         comment_data_pos += 4
-        comment_data[comment_data_pos:comment_data_pos+4] = b"pad="
-        
+        comment_data[comment_data_pos:comment_data_pos+4] = b"pad="        
         # Create segments - handle data in chunks of 255 bytes maximum
-        comment_data = comment_data[:comment_data_pos + remain]  # Trim to actual used size
-        
+        comment_data = comment_data[:comment_data_pos + remain]  # Trim to actual used size        
         # Split large data into smaller segments (each <= 255 bytes)
         remaining_data = comment_data
-        first_segment = True
-        
+        first_segment = True        
         while remaining_data:
             chunk_size = min(255, len(remaining_data))
             segment = OpusPacket(None)
@@ -377,7 +364,7 @@ def fix_tonie_header(out_file, chapters, timestamp, sha):
 
 def create_tonie_file(output_file, input_files, no_tonie_header=False, user_timestamp=None,
                      bitrate=96, vbr=True, ffmpeg_binary=None, opus_binary=None, keep_temp=False, auto_download=False, 
-                     use_custom_tags=True):
+                     use_custom_tags=True, no_mono_conversion=False):
     """
     Create a Tonie file from input files.
     
@@ -393,13 +380,14 @@ def create_tonie_file(output_file, input_files, no_tonie_header=False, user_time
         keep_temp: Whether to keep temporary opus files for testing
         auto_download: Whether to automatically download dependencies if not found
         use_custom_tags: Whether to use dynamic comment tags generated with toniefile_comment_add
+        no_mono_conversion: Whether to skip mono conversion during audio processing
     """
     from .audio_conversion import get_opus_tempfile
     
     logger.trace("Entering create_tonie_file(output_file=%s, input_files=%s, no_tonie_header=%s, user_timestamp=%s, "
-                "bitrate=%d, vbr=%s, ffmpeg_binary=%s, opus_binary=%s, keep_temp=%s, auto_download=%s, use_custom_tags=%s)",
+                "bitrate=%d, vbr=%s, ffmpeg_binary=%s, opus_binary=%s, keep_temp=%s, auto_download=%s, use_custom_tags=%s, no_mono_conversion=%s)",
                 output_file, input_files, no_tonie_header, user_timestamp, bitrate, vbr, ffmpeg_binary, 
-                opus_binary, keep_temp, auto_download, use_custom_tags)
+                opus_binary, keep_temp, auto_download, use_custom_tags, no_mono_conversion)
     
     logger.info("Creating Tonie file from %d input files", len(input_files))
     logger.debug("Output file: %s, Bitrate: %d kbps, VBR: %s, No header: %s", 
@@ -465,9 +453,9 @@ def create_tonie_file(output_file, input_files, no_tonie_header=False, user_time
                 handle = open(fname, "rb")
                 temp_file_path = None
             else:
-                logger.debug("Converting %s to Opus format (bitrate: %d kbps, VBR: %s)", 
-                            fname, bitrate, vbr)
-                handle, temp_file_path = get_opus_tempfile(ffmpeg_binary, opus_binary, fname, bitrate, vbr, keep_temp, auto_download)
+                logger.debug("Converting %s to Opus format (bitrate: %d kbps, VBR: %s, no_mono_conversion: %s)", 
+                            fname, bitrate, vbr, no_mono_conversion)
+                handle, temp_file_path = get_opus_tempfile(ffmpeg_binary, opus_binary, fname, bitrate, vbr, keep_temp, auto_download, no_mono_conversion=no_mono_conversion)
                 if temp_file_path:
                     temp_files.append(temp_file_path)
                     logger.debug("Temporary opus file saved to: %s", temp_file_path)