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

TonieToolbox/__main__.py

@@ -7,27 +7,27 @@ import argparse
 import os
 import sys
 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, 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
-from .teddycloud import upload_to_teddycloud, get_tags_from_teddycloud, get_file_paths
-from .tonies_json import fetch_and_update_tonies_json
+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_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).')
     parser.add_argument('-v', '--version', action='version', version=f'TonieToolbox {__version__}',
-                        help='show program version and exit')
-    
-    # TeddyCloud options first to check for existence before requiring SOURCE
+                        help='show program version and exit')    
+    # ------------- Parser - Teddycloud -------------
     teddycloud_group = parser.add_argument_group('TeddyCloud Options')
     teddycloud_group.add_argument('--upload', metavar='URL', action='store',
                        help='Upload to TeddyCloud instance (e.g., https://teddycloud.example.com). Supports .taf, .jpg, .jpeg, .png files.')
@@ -41,8 +41,6 @@ def main():
                        help='Special folder to upload to (currently only "library" is supported)', default='library')
     teddycloud_group.add_argument('--path', action='store', metavar='PATH',
                        help='Path where to write the file on TeddyCloud server')
-    teddycloud_group.add_argument('--show-progress', action='store_true', default=True,
-                       help='Show progress bar during file upload (default: enabled)')
     teddycloud_group.add_argument('--connection-timeout', type=int, metavar='SECONDS', default=10,
                        help='Connection timeout in seconds (default: 10)')
     teddycloud_group.add_argument('--read-timeout', type=int, metavar='SECONDS', default=300,
@@ -53,18 +51,33 @@ 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')
+    teddycloud_group.add_argument('--password', action='store', metavar='PASSWORD',
+                       help='Password for basic authentication')
+    teddycloud_group.add_argument('--client-cert', action='store', metavar='CERT_FILE',
+                       help='Path to client certificate file for certificate-based authentication')
+    teddycloud_group.add_argument('--client-key', action='store', metavar='KEY_FILE',
+                       help='Path to client private key file for certificate-based authentication')
 
+    # ------------- Parser - Source Input -------------
     parser.add_argument('input_filename', metavar='SOURCE', type=str, nargs='?',
                         help='input file or directory or a file list (.lst)')
     parser.add_argument('output_filename', metavar='TARGET', nargs='?', type=str,
                         help='the output file name (default: ---ID---)')
     parser.add_argument('-t', '--timestamp', dest='user_timestamp', metavar='TIMESTAMP', action='store',
                         help='set custom timestamp / bitstream serial')
-
+    # ------------- Parser - Librarys -------------
     parser.add_argument('-f', '--ffmpeg', help='specify location of ffmpeg', default=None)
     parser.add_argument('-o', '--opusenc', help='specify location of opusenc', default=None)
     parser.add_argument('-b', '--bitrate', type=int, help='set encoding bitrate in kbps (default: 96)', default=96)
     parser.add_argument('-c', '--cbr', action='store_true', help='encode in cbr mode')
+    parser.add_argument('--auto-download', action='store_true',
+                        help='automatically download ffmpeg and opusenc if not found')
+    # ------------- Parser - TAF -------------
     parser.add_argument('-a', '--append-tonie-tag', metavar='TAG', action='store',
                         help='append [TAG] to filename (must be an 8-character hex value)')
     parser.add_argument('-n', '--no-tonie-header', action='store_true', help='do not write Tonie header')
@@ -73,7 +86,11 @@ def main():
     parser.add_argument('-r', '--recursive', action='store_true', help='Process folders recursively')
     parser.add_argument('-O', '--output-to-source', action='store_true', 
                         help='Save output files in the source directory instead of output directory')
-    parser.add_argument('-A', '--auto-download', action='store_true', help='Automatically download FFmpeg and opusenc if needed')
+    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')
     parser.add_argument('-u', '--use-legacy-tags', action='store_true',
@@ -81,9 +98,8 @@ def main():
     parser.add_argument('-C', '--compare', action='store', metavar='FILE2', 
                        help='Compare input file with another .taf file for debugging')
     parser.add_argument('-D', '--detailed-compare', action='store_true',
-                       help='Show detailed OGG page differences when comparing files')
-    
-    # Media tag options
+                       help='Show detailed OGG page differences when comparing files')    
+    # ------------- Parser - Media Tag Options -------------
     media_tag_group = parser.add_argument_group('Media Tag Options')
     media_tag_group.add_argument('-m', '--use-media-tags', action='store_true',
                        help='Use media tags from audio files for naming')
@@ -91,8 +107,7 @@ def main():
                        help='Template for naming files using media tags. Example: "{album} - {artist}"')
     media_tag_group.add_argument('--show-tags', action='store_true',
                        help='Show available media tags from input files')
-    
-    # Version check options
+    # ------------- Parser - Version handling -------------
     version_group = parser.add_argument_group('Version Check Options')
     version_group.add_argument('-S', '--skip-update-check', action='store_true',
                        help='Skip checking for updates')
@@ -100,7 +115,7 @@ def main():
                        help='Force refresh of update information from PyPI')
     version_group.add_argument('-X', '--clear-version-cache', action='store_true',
                        help='Clear cached version information')
-    
+    # ------------- Parser - Logging -------------
     log_group = parser.add_argument_group('Logging Options')
     log_level_group = log_group.add_mutually_exclusive_group()
     log_level_group.add_argument('-d', '--debug', action='store_true', help='Enable debug logging')
@@ -109,16 +124,14 @@ def main():
     log_level_group.add_argument('-Q', '--silent', action='store_true', help='Show only errors')
     log_group.add_argument('--log-file', action='store_true', default=False,
                        help='Save logs to a timestamped file in .tonietoolbox folder')
-
     args = parser.parse_args()
     
-    # Validate that input_filename is provided if not using --get-tags or --upload-existing
+    # ------------- Parser - Source Input -------------
     if args.input_filename is None and not (args.get_tags or args.upload):
         parser.error("the following arguments are required: SOURCE")
-        
-    # Set up the logging level
+
+    # ------------- Logging -------------
     if args.trace:
-        from .logger import TRACE
         log_level = TRACE
     elif args.debug:
         log_level = logging.DEBUG
@@ -127,17 +140,15 @@ def main():
     elif args.silent:
         log_level = logging.ERROR
     else:
-        log_level = logging.INFO
-    
+        log_level = logging.INFO 
     setup_logging(log_level, log_to_file=args.log_file)
     logger = get_logger('main')
     logger.debug("Starting TonieToolbox v%s with log level: %s", __version__, logging.getLevelName(log_level))
-    
-    # Log the command-line arguments at trace level for debugging purposes
-    logger.log(logging.DEBUG - 1, "Command-line arguments: %s", vars(args))
+    logger.debug("Command-line arguments: %s", vars(args))
 
+    # ------------- Version handling -------------
     if args.clear_version_cache:
-        logger.log(logging.DEBUG - 1, "Clearing version cache")
+        logger.debug("Clearing version cache")
         if clear_version_cache():
             logger.info("Version cache cleared successfully")
         else:
@@ -150,73 +161,155 @@ def main():
             force_refresh=args.force_refresh_cache
         )
         
-        logger.log(logging.DEBUG - 1, "Update check results: is_latest=%s, latest_version=%s, update_confirmed=%s", 
+        logger.debug( "Update check results: is_latest=%s, latest_version=%s, update_confirmed=%s", 
                    is_latest, latest_version, update_confirmed)
         
         if not is_latest and not update_confirmed and not (args.silent or args.quiet):
             logger.info("Update available but user chose to continue without updating.")
 
-    # Handle get-tags from TeddyCloud if requested
-    if args.get_tags:
-        logger.debug("Getting tags from TeddyCloud: %s", args.get_tags)
-        teddycloud_url = args.get_tags
-        success = get_tags_from_teddycloud(teddycloud_url, args.ignore_ssl_verify)
-        logger.log(logging.DEBUG - 1, "Exiting with code %d", 0 if success else 1)
-        sys.exit(0 if success else 1)
+        # ------------- Normalize Path Input -------------
+    if args.input_filename:
+        logger.debug("Original input path: %s", args.input_filename)
+        # Strip quotes from the beginning and end
+        args.input_filename = args.input_filename.strip('"\'')
+        # Handle paths that end with a backslash
+        if args.input_filename.endswith('\\'):
+            args.input_filename = args.input_filename.rstrip('\\')
+        logger.debug("Normalized input path: %s", args.input_filename)
+
+        # ------------- Setup TeddyCloudClient-------------
+    if args.upload or args.get_tags:
+        if args.upload:
+            teddycloud_url = args.upload
+        elif args.get_tags:
+            teddycloud_url = args.get_tags        
+        if not teddycloud_url:
+            logger.error("TeddyCloud URL is required for --upload or --get-tags")
+            sys.exit(1)
+        try:
+            client = TeddyCloudClient(
+                base_url=teddycloud_url,
+                ignore_ssl_verify=args.ignore_ssl_verify,
+                username=args.username,
+                password=args.password,
+                cert_file=args.client_cert,                
+                key_file=args.client_key
+            )
+            logger.debug("TeddyCloud client initialized successfully")
+        except Exception as e:
+            logger.error("Failed to initialize TeddyCloud client: %s", str(e))
+            sys.exit(1)
+
+        if args.get_tags:
+            logger.debug("Getting tags from TeddyCloud: %s", teddycloud_url)
+            success = get_tags(client)
+            logger.debug( "Exiting with code %d", 0 if success else 1)
+            sys.exit(0 if success else 1)
     
-    # Handle upload to TeddyCloud if requested
-    if args.upload:
-        teddycloud_url = args.upload
-        logger.debug("Upload to TeddyCloud requested: %s", teddycloud_url)
+    # ------------- Show Media Tags -------------
+    if args.show_tags:
+        logger.info("Showing media tags for input files:")
         
-        if not args.input_filename:
-            logger.error("Missing input file for --upload. Provide a file path as SOURCE argument.")
-            sys.exit(1)
-            
-        # Check if the input file is already a .taf file or an image file
-        if os.path.exists(args.input_filename) and (args.input_filename.lower().endswith('.taf') or 
-                                                  args.input_filename.lower().endswith(('.jpg', '.jpeg', '.png'))):
-            # Direct upload of existing TAF or image file
-            logger.debug("Direct upload of existing TAF or image file detected")
-            # Use get_file_paths to handle Windows backslashes and resolve the paths correctly
-            file_paths = get_file_paths(args.input_filename)
-            
-            if not file_paths:
-                logger.error("No files found for pattern %s", args.input_filename)
-                sys.exit(1)
-                
-            logger.info("Found %d file(s) to upload to TeddyCloud %s", len(file_paths), teddycloud_url)
-            
-            for file_path in file_paths:
-                # Only upload supported file types
-                if not file_path.lower().endswith(('.taf', '.jpg', '.jpeg', '.png')):
-                    logger.warning("Skipping unsupported file type: %s", file_path)
-                    continue
-                    
+        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)
+
+
+                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)
-                upload_success = upload_to_teddycloud(
-                    file_path, teddycloud_url, args.ignore_ssl_verify,
-                    args.special_folder, args.path, args.show_progress,
-                    args.connection_timeout, args.read_timeout,
-                    args.max_retries, args.retry_delay
+                logger.trace("Starting upload process for %s", file_path)
+                response = client.upload_file(
+                    destination_path=args.path, 
+                    file_path=file_path,                   
+                    special=args.special_folder,
                 )
-                
+                logger.trace("Upload response received: %s", response)
+                upload_success = response.get('success', False)
                 if not upload_success:
-                    logger.error("Failed to upload %s to TeddyCloud", file_path)
+                    error_msg = response.get('message', 'Unknown error')
+                    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.log(logging.DEBUG - 1, "Exiting after direct upload with code 0")
-            sys.exit(0)
-            
-        # If we get here, it's not a TAF or image file, so continue with normal processing
-        # which will convert the input files and upload the result later
-        logger.debug("Input is not a direct upload file, continuing with conversion workflow")
-        pass
+                    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)
+                    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:
+                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)
+                logger.trace("Exiting with code 1 due to invalid input file")
+                sys.exit(1)
+        
+        if args.recursive and args.upload:
+            logger.info("Recursive mode with upload enabled: %s -> %s", args.input_filename, teddycloud_url)
+            logger.debug("Will process all files in directory recursively and upload to TeddyCloud")
+    
+    # ------------- Librarys / Prereqs -------------
+    logger.debug("Checking for external dependencies")
     ffmpeg_binary = args.ffmpeg
     if ffmpeg_binary is None:
+        logger.debug("No FFmpeg specified, attempting to locate binary (auto_download=%s)", args.auto_download)
         ffmpeg_binary = get_ffmpeg_binary(args.auto_download)
         if ffmpeg_binary is None:
             logger.error("Could not find FFmpeg. Please install FFmpeg or specify its location using --ffmpeg or use --auto-download")
@@ -225,13 +318,13 @@ def main():
 
     opus_binary = args.opusenc
     if opus_binary is None:
+        logger.debug("No opusenc specified, attempting to locate binary (auto_download=%s)", args.auto_download)
         opus_binary = get_opus_binary(args.auto_download) 
         if opus_binary is None:
             logger.error("Could not find opusenc. Please install opus-tools or specify its location using --opusenc or use --auto-download")
             sys.exit(1)
         logger.debug("Using opusenc binary: %s", opus_binary)
 
-    # Check for media tags library and handle --show-tags option
     if (args.use_media_tags or args.show_tags or args.name_template) and not is_media_tags_available():
         if not ensure_mutagen(auto_install=args.auto_download):
             logger.warning("Media tags functionality requires the mutagen library but it could not be installed.")
@@ -240,8 +333,8 @@ def main():
                 sys.exit(1)
         else:
             logger.info("Successfully enabled media tag support")
-
-    # Handle recursive processing
+        
+    # ------------- Recursive Processing -------------
     if args.recursive:
         logger.info("Processing folders recursively: %s", args.input_filename)
         process_tasks = process_recursive_folders(
@@ -266,113 +359,75 @@ def main():
                 task_out_filename = os.path.join(folder_path, f"{output_name}.taf")
             else:
                 task_out_filename = os.path.join(output_dir, f"{output_name}.taf")
-                
+            
+            skip_creation = False
+            if os.path.exists(task_out_filename):
+                logger.warning("Output file already exists: %s", task_out_filename)
+                valid_taf = check_tonie_file_cli(task_out_filename)
+
+                if valid_taf and not args.force_creation:
+                    logger.warning("Valid Tonie file: %s", task_out_filename)
+                    logger.warning("Skipping creation step for existing Tonie file: %s", task_out_filename)
+                    skip_creation = True
+                else:
+                    logger.info("Output file exists but is not a valid Tonie file, proceeding to create a new one.")
+            
             logger.info("[%d/%d] Processing folder: %s -> %s", 
                       task_index + 1, len(process_tasks), folder_path, task_out_filename)
             
-            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)
-            logger.info("Successfully created Tonie file: %s", task_out_filename)
-            created_files.append(task_out_filename)
+            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, 
+                               no_mono_conversion=args.no_mono_conversion)
+                logger.info("Successfully created Tonie file: %s", task_out_filename)
             
-        logger.info("Recursive processing completed. Created %d Tonie files.", len(process_tasks))
-        
-        # Handle upload to TeddyCloud if requested
-        if args.upload and created_files:
-            teddycloud_url = args.upload
+            created_files.append(task_out_filename)
+
+    # ------------- Initialization -------------------         
+
+            artwork_url = None
             
-            for taf_file in created_files:
-                upload_success = upload_to_teddycloud(
-                    taf_file, teddycloud_url, args.ignore_ssl_verify,
-                    args.special_folder, args.path, args.show_progress,
-                    args.connection_timeout, args.read_timeout,
-                    args.max_retries, args.retry_delay
+    # ------------- Recursive File Upload -------------       
+            if args.upload:                
+                response = client.upload_file(
+                    file_path=task_out_filename,
+                    destination_path=args.path,                    
+                    special=args.special_folder,
                 )
+                upload_success = response.get('success', False)
                 
                 if not upload_success:
-                    logger.error("Failed to upload %s to TeddyCloud", taf_file)
+                    logger.error("Failed to upload %s to TeddyCloud", task_out_filename)
                 else:
-                    logger.info("Successfully uploaded %s to TeddyCloud", taf_file)
+                    logger.info("Successfully uploaded %s to TeddyCloud", task_out_filename)
                     
-                    # Handle artwork upload if requested
-                    if args.include_artwork:
-                        # Extract folder path from the current task
-                        folder_path = os.path.dirname(taf_file)
-                        taf_file_basename = os.path.basename(taf_file)
-                        taf_name = os.path.splitext(taf_file_basename)[0]  # Get name without extension
-                        logger.info("Looking for artwork for %s", folder_path)
-                        
-                        # Try to find cover image in the folder
-                        from .media_tags import find_cover_image
-                        artwork_path = find_cover_image(folder_path)
-                        temp_artwork = None
-                        
-                        # If no cover image found, try to extract it from one of the audio files
-                        if not artwork_path:
-                            # Get current task's audio files
-                            for task_name, task_folder, task_files in process_tasks:
-                                if task_folder == folder_path or os.path.normpath(task_folder) == os.path.normpath(folder_path):
-                                    if task_files and len(task_files) > 0:
-                                        # Try to extract from first file
-                                        from .media_tags import extract_artwork, ensure_mutagen
-                                        if ensure_mutagen(auto_install=args.auto_download):
-                                            temp_artwork = extract_artwork(task_files[0])
-                                            if temp_artwork:
-                                                artwork_path = temp_artwork
-                                                break
-                        
-                        if artwork_path:
-                            logger.info("Found artwork for %s: %s", folder_path, artwork_path)                    
-                            artwork_upload_path = "/custom_img"                            
-                            artwork_ext = os.path.splitext(artwork_path)[1]
+                    # Handle artwork upload
+                if args.include_artwork:
+                    success, artwork_url = upload_artwork(client, task_out_filename, folder_path, audio_files)                        
+                    if success:
+                        logger.info("Successfully uploaded artwork for %s", task_out_filename)
+                    else:
+                        logger.warning("Failed to upload artwork for %s", task_out_filename)
                             
-                            # Create a temporary copy with the same name as the taf file
-                            import shutil
-                            renamed_artwork_path = 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.copy2(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)
-                                
-                                artwork_upload_success = upload_to_teddycloud(
-                                    renamed_artwork_path, teddycloud_url, args.ignore_ssl_verify,
-                                    args.special_folder, artwork_upload_path, args.show_progress,
-                                    args.connection_timeout, args.read_timeout,
-                                    args.max_retries, args.retry_delay
-                                )
-                                
-                                if artwork_upload_success:
-                                    logger.info("Successfully uploaded artwork for %s", folder_path)
-                                else:
-                                    logger.warning("Failed to upload artwork for %s", folder_path)
-                                    
-                                if renamed_artwork_path != 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) and temp_artwork != renamed_artwork_path:
-                                    try:
-                                        os.unlink(temp_artwork)
-                                        logger.debug("Removed temporary artwork file: %s", temp_artwork)
-                                    except Exception as e:
-                                        logger.debug("Failed to remove temporary artwork file: %s", e)
-                            except Exception as e:
-                                logger.error("Error during artwork renaming or upload: %s", e)
-                        else:
-                            logger.warning("No artwork found for %s", folder_path)
+                    # tonies.custom.json generation
+            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)
-
-    # Handle directory or file input
+    # ------------- Single File Processing -------------
     if os.path.isdir(args.input_filename):
         logger.debug("Input is a directory: %s", args.input_filename)
         args.input_filename += "/*"
@@ -387,7 +442,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)
@@ -398,36 +452,14 @@ def main():
     if len(files) == 0:
         logger.error("No files found for pattern %s", args.input_filename)
         sys.exit(1)
-
-    # Show tags for input files if requested
-    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)
-        
-    # Use media tags for file naming if requested
+    
     guessed_name = None
     if args.use_media_tags:
-        # If this is a single folder, try to get consistent album info
         if len(files) > 1 and os.path.dirname(files[0]) == os.path.dirname(files[-1]):
-            folder_path = os.path.dirname(files[0])
-            
-            from .media_tags import extract_album_info, format_metadata_filename
-            logger.debug("Extracting album info from folder: %s", folder_path)
-            
+            folder_path = os.path.dirname(files[0])            
+            logger.debug("Extracting album info from folder: %s", folder_path)            
             album_info = extract_album_info(folder_path)
             if album_info:
-                # Use album info for naming the output file
                 template = args.name_template or "{album} - {artist}"
                 new_name = format_metadata_filename(album_info, template)
                 
@@ -436,10 +468,8 @@ def main():
                     guessed_name = new_name
                 else:
                     logger.debug("Could not format filename from album metadata")
-        
-        # For single files, use the file's metadata
         elif len(files) == 1:
-            from .media_tags import get_file_tags, format_metadata_filename
+
             
             tags = get_file_tags(files[0])
             if tags:
@@ -453,9 +483,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:
@@ -509,6 +537,9 @@ def main():
                 os.makedirs(output_dir, exist_ok=True)
             out_filename = os.path.join(output_dir, guessed_name)
             logger.debug("Using default output location: %s", out_filename)
+    
+    # Make sure source_dir is defined for later use with artwork upload
+    source_dir = os.path.dirname(files[0]) if files else '.'
 
     if args.append_tonie_tag:
         logger.debug("Appending Tonie tag to output filename")
@@ -526,155 +557,44 @@ 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)
     
-    # Handle upload to TeddyCloud if requested
-    if args.upload:
-        teddycloud_url = args.upload
-        
-        upload_success = upload_to_teddycloud(
-            out_filename, teddycloud_url, args.ignore_ssl_verify,
-            args.special_folder, args.path, args.show_progress,
-            args.connection_timeout, args.read_timeout,
-            args.max_retries, args.retry_delay
+    # ------------- Single File Upload -------------  
+    artwork_url = None
+    if args.upload:                
+        response = client.upload_file(
+            file_path=out_filename,
+            destination_path=args.path,                    
+            special=args.special_folder,
         )
+        upload_success = response.get('success', False)
         if not upload_success:
             logger.error("Failed to upload %s to TeddyCloud", out_filename)
-            sys.exit(1)
         else:
             logger.info("Successfully uploaded %s to TeddyCloud", out_filename)
-            
-            # Handle artwork upload if requested
-            if args.include_artwork:
-                logger.info("Looking for artwork to upload alongside the Tonie file")
-                artwork_path = None
-                
-                # Try to find a cover image in the source directory first
-                source_dir = os.path.dirname(files[0]) if files else None
-                if source_dir:
-                    from .media_tags import find_cover_image
-                    artwork_path = find_cover_image(source_dir)
-                
-                # If no cover in source directory, try to extract it from audio file
-                if not artwork_path and len(files) > 0:
-                    from .media_tags import extract_artwork, ensure_mutagen
-                    
-                    # Make sure mutagen is available for artwork extraction
-                    if ensure_mutagen(auto_install=args.auto_download):
-                        # Try to extract artwork from the first file
-                        temp_artwork = extract_artwork(files[0])
-                        if temp_artwork:
-                            artwork_path = temp_artwork
-                            # Note: this creates a temporary file that will be deleted after upload
-                
-                # Upload the artwork if found
-                if artwork_path:
-                    logger.info("Found artwork: %s", artwork_path)
-                    
-                    # Create artwork upload path - keep same path but use "custom_img" folder
-                    artwork_upload_path = args.path
-                    if not artwork_upload_path:
-                        artwork_upload_path = "/custom_img"
-                    elif not artwork_upload_path.startswith("/custom_img"):
-                        # Make sure we're using the custom_img folder
-                        if artwork_upload_path.startswith("/"):
-                            artwork_upload_path = "/custom_img" + artwork_upload_path
-                        else:
-                            artwork_upload_path = "/custom_img/" + artwork_upload_path
-                    
-                    # Get the original artwork file extension
-                    artwork_ext = os.path.splitext(artwork_path)[1]
-                    
-                    # Create a temporary copy with the same name as the taf file
-                    import shutil
-                    renamed_artwork_path = None
-                    try:
-                        renamed_artwork_path = os.path.join(os.path.dirname(artwork_path), 
-                                                          f"{os.path.splitext(os.path.basename(out_filename))[0]}{artwork_ext}")
-                        
-                        if renamed_artwork_path != artwork_path:
-                            shutil.copy2(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, os.path.splitext(os.path.basename(out_filename))[0], artwork_ext)
-                        
-                        artwork_upload_success = upload_to_teddycloud(
-                            renamed_artwork_path, teddycloud_url, args.ignore_ssl_verify,
-                            args.special_folder, artwork_upload_path, args.show_progress,
-                            args.connection_timeout, args.read_timeout,
-                            args.max_retries, args.retry_delay
-                        )
-                        
-                        if artwork_upload_success:
-                            logger.info("Successfully uploaded artwork")
-                        else:
-                            logger.warning("Failed to upload artwork")
-                            
-                        # Clean up temporary renamed file
-                        if renamed_artwork_path != 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)
-                        
-                        # Clean up temporary extracted artwork file if needed
-                        if temp_artwork and os.path.exists(temp_artwork) and temp_artwork != renamed_artwork_path:
-                            try:
-                                os.unlink(temp_artwork)
-                                logger.debug("Removed temporary artwork file: %s", temp_artwork)
-                            except Exception as e:
-                                logger.debug("Failed to remove temporary artwork file: %s", e)
-                    except Exception as e:
-                        logger.error("Error during artwork renaming or upload: %s", e)
-                else:
-                    logger.warning("No artwork found to upload")
 
-    # Handle create-custom-json option
-    if args.create_custom_json and args.upload:
-        teddycloud_url = args.upload
-        artwork_url = None
-        
-        # If artwork was uploaded, construct its URL for the JSON
+            # Handle artwork upload
         if args.include_artwork:
-            taf_basename = os.path.splitext(os.path.basename(out_filename))[0]
-            artwork_ext = None
-            
-            # Try to determine the artwork extension by checking what was uploaded
-            source_dir = os.path.dirname(files[0]) if files else None
-            if source_dir:
-                from .media_tags import find_cover_image
-                artwork_path = find_cover_image(source_dir)
-                if artwork_path:
-                    artwork_ext = os.path.splitext(artwork_path)[1]
-            
-            # If we couldn't determine extension from a found image, default to .jpg
-            if not artwork_ext:
-                artwork_ext = ".jpg"
-                
-            # Construct the URL for the artwork based on TeddyCloud structure
-            artwork_path = args.path or "/custom_img"
-            if not artwork_path.endswith('/'):
-                artwork_path += '/'
-                
-            artwork_url = f"{teddycloud_url}{artwork_path}{taf_basename}{artwork_ext}"
-            logger.debug("Using artwork URL: %s", artwork_url)
-        
-        logger.info("Fetching and updating custom Tonies JSON data")
-        success = fetch_and_update_tonies_json(
-            teddycloud_url, 
-            args.ignore_ssl_verify,
-            out_filename, 
-            files, 
-            artwork_url
-        )
-        
+            success, artwork_url = upload_artwork(client, out_filename, source_dir, files)                        
+            if success:
+                logger.info("Successfully uploaded artwork for %s", out_filename)
+            else:
+                logger.warning("Failed to upload artwork 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 custom Tonies JSON data")
+            logger.info("Successfully updated Tonies JSON for %s", out_filename)
         else:
-            logger.warning("Failed to update custom Tonies JSON data")
+            logger.warning("Failed to update Tonies JSON for %s", out_filename)
 
 if __name__ == "__main__":
     main()