TonieToolbox 0.1.7__tar.gz → 0.2.0__tar.gz

{tonietoolbox-0.1.7/TonieToolbox.egg-info → tonietoolbox-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TonieToolbox
-Version: 0.1.7
+Version: 0.2.0
 Summary: Convert audio files to Tonie box compatible format
 Home-page: https://github.com/Quentendo64/TonieToolbox
 Author: Quentendo64
@@ -62,6 +62,7 @@ TonieToolbox allows you to create custom audio content for Tonie boxes by conver
 The tool provides several capabilities:
 
 - Convert single or multiple audio files into a Tonie-compatible format
+- Process complex folder structures recursively to handle entire audio collections
 - Analyze and validate existing Tonie files
 - Split Tonie files into individual opus tracks
 - Compare two TAF files for debugging differences
@@ -137,6 +138,22 @@ Or use a list file (.lst) containing paths to multiple audio files:
 tonietoolbox playlist.lst
 ```
 
+**Process folders recursively:**
+
+To process an entire folder structure with multiple audio folders:
+
+```
+tonietoolbox --recursive "Music/Albums"
+```
+
+This will scan all subfolders, identify those containing audio files, and create a TAF file for each folder.
+
+By default, all generated TAF files are saved in the `.\output` directory. If you want to save each TAF file in its source directory instead:
+
+```
+tonietoolbox --recursive --output-to-source "Music/Albums"
+```
+
 ### Advanced Options
 
 Run the following command to see all available options:
@@ -149,8 +166,8 @@ Output:
 ```
 usage: TonieToolbox.py [-h] [--ts TIMESTAMP] [--ffmpeg FFMPEG] [--opusenc OPUSENC] 
                     [--bitrate BITRATE] [--cbr] [--append-tonie-tag TAG] 
-                    [--no-tonie-header] [--info] [--split] [--recursive] [--compare FILE2]
-                    [--detailed-compare] [--debug] [--trace] [--quiet] [--silent]
+                    [--no-tonie-header] [--info] [--split] [--recursive] [--output-to-source]
+                    [--compare FILE2] [--detailed-compare] [--debug] [--trace] [--quiet] [--silent]
                     SOURCE [TARGET]
 
 Create Tonie compatible file from Ogg opus file(s).
@@ -170,6 +187,8 @@ optional arguments:
   --no-tonie-header     do not write Tonie header
   --info                Check and display info about Tonie file
   --split               Split Tonie file into opus tracks
+  --recursive           Process folders recursively
+  --output-to-source    Save output files in the source directory instead of output directory
   --compare FILE2       Compare input file with another .taf file for debugging
   --detailed-compare    Show detailed OGG page differences when comparing files
 
@@ -222,6 +241,20 @@ tonietoolbox input.mp3 --ts ./reference.taf  # Reference TAF for extraction
 tonietoolbox input.mp3 --bitrate 128
 ```
 
+#### Process a complex folder structure:
+
+Process an audiobook series with multiple folders:
+
+```
+tonietoolbox --recursive "\Hörspiele\Die drei Fragezeichen\Folgen"
+```
+
+Process a music collection with nested album folders and save TAF files alongside the source directories:
+
+```
+tonietoolbox --recursive --output-to-source "\Hörspiele\"
+```
+
 ## Technical Details
 
 ### TAF (Tonie Audio Format) File Structure

{tonietoolbox-0.1.7 → tonietoolbox-0.2.0}/README.md

@@ -35,6 +35,7 @@ TonieToolbox allows you to create custom audio content for Tonie boxes by conver
 The tool provides several capabilities:
 
 - Convert single or multiple audio files into a Tonie-compatible format
+- Process complex folder structures recursively to handle entire audio collections
 - Analyze and validate existing Tonie files
 - Split Tonie files into individual opus tracks
 - Compare two TAF files for debugging differences
@@ -110,6 +111,22 @@ Or use a list file (.lst) containing paths to multiple audio files:
 tonietoolbox playlist.lst
 ```
 
+**Process folders recursively:**
+
+To process an entire folder structure with multiple audio folders:
+
+```
+tonietoolbox --recursive "Music/Albums"
+```
+
+This will scan all subfolders, identify those containing audio files, and create a TAF file for each folder.
+
+By default, all generated TAF files are saved in the `.\output` directory. If you want to save each TAF file in its source directory instead:
+
+```
+tonietoolbox --recursive --output-to-source "Music/Albums"
+```
+
 ### Advanced Options
 
 Run the following command to see all available options:
@@ -122,8 +139,8 @@ Output:
 ```
 usage: TonieToolbox.py [-h] [--ts TIMESTAMP] [--ffmpeg FFMPEG] [--opusenc OPUSENC] 
                     [--bitrate BITRATE] [--cbr] [--append-tonie-tag TAG] 
-                    [--no-tonie-header] [--info] [--split] [--recursive] [--compare FILE2]
-                    [--detailed-compare] [--debug] [--trace] [--quiet] [--silent]
+                    [--no-tonie-header] [--info] [--split] [--recursive] [--output-to-source]
+                    [--compare FILE2] [--detailed-compare] [--debug] [--trace] [--quiet] [--silent]
                     SOURCE [TARGET]
 
 Create Tonie compatible file from Ogg opus file(s).
@@ -143,6 +160,8 @@ optional arguments:
   --no-tonie-header     do not write Tonie header
   --info                Check and display info about Tonie file
   --split               Split Tonie file into opus tracks
+  --recursive           Process folders recursively
+  --output-to-source    Save output files in the source directory instead of output directory
   --compare FILE2       Compare input file with another .taf file for debugging
   --detailed-compare    Show detailed OGG page differences when comparing files
 
@@ -195,6 +214,20 @@ tonietoolbox input.mp3 --ts ./reference.taf  # Reference TAF for extraction
 tonietoolbox input.mp3 --bitrate 128
 ```
 
+#### Process a complex folder structure:
+
+Process an audiobook series with multiple folders:
+
+```
+tonietoolbox --recursive "\Hörspiele\Die drei Fragezeichen\Folgen"
+```
+
+Process a music collection with nested album folders and save TAF files alongside the source directories:
+
+```
+tonietoolbox --recursive --output-to-source "\Hörspiele\"
+```
+
 ## Technical Details
 
 ### TAF (Tonie Audio Format) File Structure

{tonietoolbox-0.1.7 → tonietoolbox-0.2.0}/TonieToolbox/__init__.py

@@ -2,4 +2,4 @@
 TonieToolbox - Convert audio files to Tonie box compatible format
 """
 
-__version__ = '0.1.7'
+__version__ = '0.2.0'

{tonietoolbox-0.1.7 → tonietoolbox-0.2.0}/TonieToolbox/__main__.py

@@ -16,6 +16,7 @@ from .dependency_manager import get_ffmpeg_binary, get_opus_binary
 from .logger import 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
 
 def main():
     """Entry point for the TonieToolbox application."""
@@ -38,6 +39,9 @@ def main():
     parser.add_argument('--no-tonie-header', action='store_true', help='do not write Tonie header')
     parser.add_argument('--info', action='store_true', help='Check and display info about Tonie file')
     parser.add_argument('--split', action='store_true', help='Split Tonie file into opus tracks')
+    parser.add_argument('--recursive', action='store_true', help='Process folders recursively')
+    parser.add_argument('--output-to-source', action='store_true', 
+                        help='Save output files in the source directory instead of output directory')
     parser.add_argument('--auto-download', action='store_true', help='Automatically download FFmpeg and opusenc if needed')
     parser.add_argument('--keep-temp', action='store_true', 
                        help='Keep temporary opus files in a temp folder for testing')
@@ -113,6 +117,39 @@ def main():
             sys.exit(1)
         logger.debug("Using opusenc binary: %s", opus_binary)
 
+    # Handle recursive processing
+    if args.recursive:
+        logger.info("Processing folders recursively: %s", args.input_filename)
+        process_tasks = process_recursive_folders(args.input_filename)
+        
+        if not process_tasks:
+            logger.error("No folders with audio files found for recursive processing")
+            sys.exit(1)
+            
+        output_dir = None if args.output_to_source else './output'
+        
+        if output_dir and not os.path.exists(output_dir):
+            os.makedirs(output_dir, exist_ok=True)
+            logger.debug("Created output directory: %s", output_dir)
+        
+        for task_index, (output_name, folder_path, audio_files) in enumerate(process_tasks):
+            if args.output_to_source:
+                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")
+                
+            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)
+            logger.info("Successfully created Tonie file: %s", task_out_filename)
+            
+        logger.info("Recursive processing completed. Created %d Tonie files.", len(process_tasks))
+        sys.exit(0)
+
+    # Handle directory or file input
     if os.path.isdir(args.input_filename):
         logger.debug("Input is a directory: %s", args.input_filename)
         args.input_filename += "/*"
@@ -143,12 +180,17 @@ def main():
         out_filename = args.output_filename
     else:
         guessed_name = guess_output_filename(args.input_filename, files)    
-        output_dir = './output'
-        if not os.path.exists(output_dir):
-            logger.debug("Creating default output directory: %s", output_dir)
-            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)
+        if args.output_to_source:
+            source_dir = os.path.dirname(files[0]) if files else '.'
+            out_filename = os.path.join(source_dir, guessed_name)
+            logger.debug("Using source location for output: %s", out_filename)
+        else:
+            output_dir = './output'
+            if not os.path.exists(output_dir):
+                logger.debug("Creating default output directory: %s", output_dir)
+                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)
 
     if args.append_tonie_tag:
         logger.debug("Appending Tonie tag to output filename")
@@ -162,7 +204,7 @@ def main():
     
     if not out_filename.lower().endswith('.taf'):
         out_filename += '.taf'
-
+    
     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)

{tonietoolbox-0.1.7 → tonietoolbox-0.2.0}/TonieToolbox/audio_conversion.py

@@ -58,37 +58,65 @@ def get_opus_tempfile(ffmpeg_binary=None, opus_binary=None, filename=None, bitra
         logger.info("Creating persistent temporary file: %s", temp_path)
         
         logger.debug("Starting FFmpeg process")
-        ffmpeg_process = subprocess.Popen(
-            [ffmpeg_binary, "-hide_banner", "-loglevel", "warning", "-i", filename, "-f", "wav",
-             "-ar", "48000", "-"], stdout=subprocess.PIPE)
+        try:
+            ffmpeg_process = subprocess.Popen(
+                [ffmpeg_binary, "-hide_banner", "-loglevel", "warning", "-i", filename, "-f", "wav",
+                 "-ar", "48000", "-"], stdout=subprocess.PIPE)
+        except FileNotFoundError:
+            logger.error("Error opening input file %s", filename)
+            raise RuntimeError(f"Error opening input file {filename}")
              
         logger.debug("Starting opusenc process")
-        opusenc_process = subprocess.Popen(
-            [opus_binary, "--quiet", vbr_parameter, "--bitrate", f"{bitrate:d}", "-", temp_path],
-            stdin=ffmpeg_process.stdout, stderr=subprocess.DEVNULL)
+        try:
+            opusenc_process = subprocess.Popen(
+                [opus_binary, "--quiet", vbr_parameter, "--bitrate", f"{bitrate:d}", "-", temp_path],
+                stdin=ffmpeg_process.stdout, stderr=subprocess.DEVNULL)
+        except Exception as e:
+            logger.error("Opus encoding failed: %s", str(e))
+            raise RuntimeError(f"Opus encoding failed: {str(e)}")
         
-        opusenc_process.communicate()
+        ffmpeg_process.stdout.close()  # Allow ffmpeg to receive SIGPIPE if opusenc exits
+        opusenc_return = opusenc_process.wait()
+        ffmpeg_return = ffmpeg_process.wait()
         
-        if opusenc_process.returncode != 0:
-            logger.error("Opus encoding failed with return code %d", opusenc_process.returncode)
-            raise RuntimeError(f"Opus encoding failed with return code {opusenc_process.returncode}")
+        if ffmpeg_return != 0:
+            logger.error("FFmpeg processing failed with return code %d", ffmpeg_return)
+            raise RuntimeError(f"FFmpeg processing failed with return code {ffmpeg_return}")
+        
+        if opusenc_return != 0:
+            logger.error("Opus encoding failed with return code %d", opusenc_return)
+            raise RuntimeError(f"Opus encoding failed with return code {opusenc_return}")
         
         logger.debug("Opening temporary file for reading")
-        tmp_file = open(temp_path, "rb")
-        return tmp_file, temp_path
+        try:
+            tmp_file = open(temp_path, "rb")
+            return tmp_file, temp_path
+        except Exception as e:
+            logger.error("Failed to open temporary file: %s", str(e))
+            raise RuntimeError(f"Failed to open temporary file: {str(e)}")
     else:        
         logger.debug("Using in-memory temporary file")
         
         logger.debug("Starting FFmpeg process")
-        ffmpeg_process = subprocess.Popen(
-            [ffmpeg_binary, "-hide_banner", "-loglevel", "warning", "-i", filename, "-f", "wav",
-             "-ar", "48000", "-"], stdout=subprocess.PIPE)
+        try:
+            ffmpeg_process = subprocess.Popen(
+                [ffmpeg_binary, "-hide_banner", "-loglevel", "warning", "-i", filename, "-f", "wav",
+                 "-ar", "48000", "-"], stdout=subprocess.PIPE)
+        except FileNotFoundError:
+            logger.error("Error opening input file %s", filename)
+            raise RuntimeError(f"Error opening input file {filename}")
              
         logger.debug("Starting opusenc process")
-        opusenc_process = subprocess.Popen(
-            [opus_binary, "--quiet", vbr_parameter, "--bitrate", f"{bitrate:d}", "-", "-"],
-            stdin=ffmpeg_process.stdout, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
+        try:
+            opusenc_process = subprocess.Popen(
+                [opus_binary, "--quiet", vbr_parameter, "--bitrate", f"{bitrate:d}", "-", "-"],
+                stdin=ffmpeg_process.stdout, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
+        except Exception as e:
+            logger.error("Opus encoding failed: %s", str(e))
+            raise RuntimeError(f"Opus encoding failed: {str(e)}")
 
+        ffmpeg_process.stdout.close()  # Allow ffmpeg to receive SIGPIPE if opusenc exits
+        
         tmp_file = tempfile.SpooledTemporaryFile()
         bytes_written = 0
         
@@ -97,9 +125,16 @@ def get_opus_tempfile(ffmpeg_binary=None, opus_binary=None, filename=None, bitra
             tmp_file.write(chunk)
             bytes_written += len(chunk)
         
-        if opusenc_process.wait() != 0:
-            logger.error("Opus encoding failed with return code %d", opusenc_process.returncode)
-            raise RuntimeError(f"Opus encoding failed with return code {opusenc_process.returncode}")
+        opusenc_return = opusenc_process.wait()
+        ffmpeg_return = ffmpeg_process.wait()
+        
+        if ffmpeg_return != 0:
+            logger.error("FFmpeg processing failed with return code %d", ffmpeg_return)
+            raise RuntimeError(f"FFmpeg processing failed with return code {ffmpeg_return}")
+        
+        if opusenc_return != 0:
+            logger.error("Opus encoding failed with return code %d", opusenc_return)
+            raise RuntimeError(f"Opus encoding failed with return code {opusenc_return}")
         
         logger.debug("Wrote %d bytes to temporary file", bytes_written)
         tmp_file.seek(0)
@@ -157,12 +192,38 @@ def get_input_files(input_filename):
         logger.debug("Processing list file: %s", input_filename)
         list_dir = os.path.dirname(os.path.abspath(input_filename))
         input_files = []
-        with open(input_filename) as file_list:
-            for line in file_list:
-                fname = line.rstrip()
-                full_path = os.path.join(list_dir, fname)
-                input_files.append(full_path)
-                logger.trace("Added file from list: %s", full_path)
+        with open(input_filename, 'r', encoding='utf-8') as file_list:
+            for line_num, line in enumerate(file_list, 1):
+                fname = line.strip()
+                if not fname or fname.startswith('#'):  # Skip empty lines and comments
+                    continue
+                
+                # Remove any quote characters from path
+                fname = fname.strip('"\'')
+                    
+                # Check if the path is absolute or has a drive letter (Windows)
+                if os.path.isabs(fname) or (len(fname) > 1 and fname[1] == ':'):
+                    full_path = fname  # Use as is if it's an absolute path
+                    logger.trace("Using absolute path from list: %s", full_path)
+                else:
+                    full_path = os.path.join(list_dir, fname)
+                    logger.trace("Using relative path from list: %s", full_path)
+                
+                # Handle directory paths by finding all audio files in the directory
+                if os.path.isdir(full_path):
+                    logger.debug("Path is a directory, finding audio files in: %s", full_path)
+                    dir_glob = os.path.join(full_path, "*")
+                    dir_files = sorted(filter_directories(glob.glob(dir_glob)))
+                    if dir_files:
+                        input_files.extend(dir_files)
+                        logger.debug("Found %d audio files in directory", len(dir_files))
+                    else:
+                        logger.warning("No audio files found in directory at line %d: %s", line_num, full_path)
+                elif os.path.isfile(full_path):
+                    input_files.append(full_path)
+                else:
+                    logger.warning("File not found at line %d: %s", line_num, full_path)
+        
         logger.debug("Found %d files in list file", len(input_files))
     else:
         logger.debug("Processing glob pattern: %s", input_filename)

{tonietoolbox-0.1.7 → tonietoolbox-0.2.0}/TonieToolbox/dependency_manager.py

@@ -13,11 +13,15 @@ import shutil
 import zipfile
 import tarfile
 import urllib.request
+import time
 from pathlib import Path
 
 from .logger import get_logger
 logger = get_logger('dependency_manager')
 
+CACHE_DIR = os.path.join(os.path.expanduser("~"), ".tonietoolbox")
+LIBS_DIR = os.path.join(CACHE_DIR, "libs")
+
 DEPENDENCIES = {
     'ffmpeg': {
         'windows': {
@@ -59,16 +63,7 @@ def get_system():
 
 def get_user_data_dir():
     """Get the user data directory for storing downloaded dependencies."""
-    system = get_system()
-    
-    if system == 'windows':
-        base_dir = os.environ.get('APPDATA', os.path.expanduser('~'))
-    elif system == 'darwin':
-        base_dir = os.path.expanduser('~/Library/Application Support')
-    else:  # linux or other unix-like
-        base_dir = os.environ.get('XDG_DATA_HOME', os.path.expanduser('~/.local/share'))
-    
-    app_dir = os.path.join(base_dir, 'TonieToolbox')
+    app_dir = LIBS_DIR
     logger.debug("Using application data directory: %s", app_dir)
     
     os.makedirs(app_dir, exist_ok=True)
@@ -130,31 +125,121 @@ def extract_archive(archive_path, extract_dir):
         logger.info("Extracting %s to %s", archive_path, extract_dir)
         os.makedirs(extract_dir, exist_ok=True)
         
+        # Extract to a temporary subdirectory first
+        temp_extract_dir = os.path.join(extract_dir, "_temp_extract")
+        os.makedirs(temp_extract_dir, exist_ok=True)
+        
         if archive_path.endswith('.zip'):
             logger.debug("Extracting ZIP archive")
             with zipfile.ZipFile(archive_path, 'r') as zip_ref:
-                zip_ref.extractall(extract_dir)
-                logger.trace("Extracted files: %s", zip_ref.namelist())
+                zip_ref.extractall(temp_extract_dir)
+                files_extracted = zip_ref.namelist()
+                logger.trace("Extracted files: %s", files_extracted)
         elif archive_path.endswith(('.tar.gz', '.tgz')):
             logger.debug("Extracting TAR.GZ archive")
             with tarfile.open(archive_path, 'r:gz') as tar_ref:
-                tar_ref.extractall(extract_dir)
-                logger.trace("Extracted files: %s", tar_ref.getnames())
+                tar_ref.extractall(temp_extract_dir)
+                files_extracted = tar_ref.getnames()
+                logger.trace("Extracted files: %s", files_extracted)
         elif archive_path.endswith(('.tar.xz', '.txz')):
             logger.debug("Extracting TAR.XZ archive")
             with tarfile.open(archive_path, 'r:xz') as tar_ref:
-                tar_ref.extractall(extract_dir)
-                logger.trace("Extracted files: %s", tar_ref.getnames())
+                tar_ref.extractall(temp_extract_dir)
+                files_extracted = tar_ref.getnames()
+                logger.trace("Extracted files: %s", files_extracted)
         elif archive_path.endswith('.tar'):
             logger.debug("Extracting TAR archive")
             with tarfile.open(archive_path, 'r') as tar_ref:
-                tar_ref.extractall(extract_dir)
-                logger.trace("Extracted files: %s", tar_ref.getnames())
+                tar_ref.extractall(temp_extract_dir)
+                files_extracted = tar_ref.getnames()
+                logger.trace("Extracted files: %s", files_extracted)
         else:
             logger.error("Unsupported archive format: %s", archive_path)
             return False
             
         logger.info("Archive extracted successfully")
+        
+        # Fix FFmpeg nested directory issue by moving binary files to the correct location
+        dependency_name = os.path.basename(extract_dir)
+        if dependency_name == 'ffmpeg':
+            # Check for common nested directory structures for FFmpeg
+            if os.path.exists(os.path.join(temp_extract_dir, "ffmpeg-master-latest-win64-gpl", "bin")):
+                # Windows FFmpeg path
+                bin_dir = os.path.join(temp_extract_dir, "ffmpeg-master-latest-win64-gpl", "bin")
+                logger.debug("Found nested FFmpeg bin directory: %s", bin_dir)
+                
+                # Move all files from bin directory to the main dependency directory
+                for file in os.listdir(bin_dir):
+                    src = os.path.join(bin_dir, file)
+                    dst = os.path.join(extract_dir, file)
+                    logger.debug("Moving %s to %s", src, dst)
+                    shutil.move(src, dst)
+            
+            elif os.path.exists(os.path.join(temp_extract_dir, "ffmpeg-master-latest-linux64-gpl", "bin")):
+                # Linux FFmpeg path
+                bin_dir = os.path.join(temp_extract_dir, "ffmpeg-master-latest-linux64-gpl", "bin")
+                logger.debug("Found nested FFmpeg bin directory: %s", bin_dir)
+                
+                # Move all files from bin directory to the main dependency directory
+                for file in os.listdir(bin_dir):
+                    src = os.path.join(bin_dir, file)
+                    dst = os.path.join(extract_dir, file)
+                    logger.debug("Moving %s to %s", src, dst)
+                    shutil.move(src, dst)
+            else:
+                # Check for any directory with a 'bin' subdirectory
+                for root, dirs, _ in os.walk(temp_extract_dir):
+                    if "bin" in dirs:
+                        bin_dir = os.path.join(root, "bin")
+                        logger.debug("Found nested bin directory: %s", bin_dir)
+                        
+                        # Move all files from bin directory to the main dependency directory
+                        for file in os.listdir(bin_dir):
+                            src = os.path.join(bin_dir, file)
+                            dst = os.path.join(extract_dir, file)
+                            logger.debug("Moving %s to %s", src, dst)
+                            shutil.move(src, dst)
+                        break
+                else:
+                    # If no bin directory was found, just move everything from the temp directory
+                    logger.debug("No bin directory found, moving all files from temp directory")
+                    for item in os.listdir(temp_extract_dir):
+                        src = os.path.join(temp_extract_dir, item)
+                        dst = os.path.join(extract_dir, item)
+                        if os.path.isfile(src):
+                            logger.debug("Moving file %s to %s", src, dst)
+                            shutil.move(src, dst)
+        else:
+            # For non-FFmpeg dependencies, just move all files from temp directory
+            for item in os.listdir(temp_extract_dir):
+                src = os.path.join(temp_extract_dir, item)
+                dst = os.path.join(extract_dir, item)
+                if os.path.isfile(src):
+                    logger.debug("Moving file %s to %s", src, dst)
+                    shutil.move(src, dst)
+                else:
+                    logger.debug("Moving directory %s to %s", src, dst)
+                    # If destination already exists, remove it first
+                    if os.path.exists(dst):
+                        shutil.rmtree(dst)
+                    shutil.move(src, dst)
+        
+        # Clean up the temporary extraction directory
+        try:
+            shutil.rmtree(temp_extract_dir)
+            logger.debug("Removed temporary extraction directory")
+        except Exception as e:
+            logger.warning("Failed to remove temporary extraction directory: %s", e)
+        
+        # Remove the archive file after successful extraction
+        try:
+            logger.debug("Removing archive file: %s", archive_path)
+            os.remove(archive_path)
+            logger.debug("Archive file removed successfully")
+        except Exception as e:
+            logger.warning("Failed to remove archive file: %s (error: %s)", archive_path, e)
+            # Continue even if we couldn't remove the file
+        
         return True
     except Exception as e:
         logger.error("Failed to extract %s: %s", archive_path, e)
@@ -302,73 +387,93 @@ def ensure_dependency(dependency_name, auto_download=False):
         logger.error("Unknown dependency: %s", dependency_name)
         return None
     
-    # First check if it's already in PATH
-    bin_name = dependency_name if dependency_name != 'opusenc' else 'opusenc'
-    path_binary = check_binary_in_path(bin_name)
-    if path_binary:
-        logger.info("Found %s in PATH: %s", dependency_name, path_binary)
-        return path_binary
-    
     # Set up paths to check for previously downloaded versions
     user_data_dir = get_user_data_dir()
     dependency_info = DEPENDENCIES[dependency_name].get(system, {})
-    extract_dir_name = dependency_info.get('extract_dir', dependency_name)
-    binary_path = dependency_info.get('bin_path', bin_name)
-    extract_dir = os.path.join(user_data_dir, extract_dir_name)
+    binary_path = dependency_info.get('bin_path', dependency_name if dependency_name != 'opusenc' else 'opusenc')
     
-    # Check if we already downloaded and extracted it previously
-    logger.debug("Checking for previously downloaded %s in %s", dependency_name, extract_dir)
-    if os.path.exists(extract_dir):
-        existing_binary = find_binary_in_extracted_dir(extract_dir, binary_path)
-        if existing_binary and os.path.exists(existing_binary):
-            # Verify that the binary works
-            logger.info("Found previously downloaded %s: %s", dependency_name, existing_binary)
-            try:
-                if os.access(existing_binary, os.X_OK) or system == 'windows':
-                    if system in ['linux', 'darwin']:
-                        logger.debug("Ensuring executable permissions on %s", existing_binary)
-                        os.chmod(existing_binary, 0o755)
-                    
-                    # Quick check to verify binary works
-                    if dependency_name == 'opusenc':
-                        cmd = [existing_binary, '--version']
-                        try:
-                            result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=5)
-                            if result.returncode == 0:
-                                logger.info("Using previously downloaded %s: %s", dependency_name, existing_binary)
-                                return existing_binary
-                        except:
-                            # If --version fails, try without arguments
+    # Define bin_name early so it's available in all code paths
+    bin_name = dependency_name if dependency_name != 'opusenc' else 'opusenc'
+    
+    # Create a specific folder for this dependency
+    dependency_dir = os.path.join(user_data_dir, dependency_name)
+    
+    # First priority: Check if we already downloaded and extracted it previously
+    # When auto_download is True, we'll skip this check and download fresh versions
+    if not auto_download:
+        logger.debug("Checking for previously downloaded %s in %s", dependency_name, dependency_dir)
+        if os.path.exists(dependency_dir):
+            existing_binary = find_binary_in_extracted_dir(dependency_dir, binary_path)
+            if existing_binary and os.path.exists(existing_binary):
+                # Verify that the binary works
+                logger.info("Found previously downloaded %s: %s", dependency_name, existing_binary)
+                try:
+                    if os.access(existing_binary, os.X_OK) or system == 'windows':
+                        if system in ['linux', 'darwin']:
+                            logger.debug("Ensuring executable permissions on %s", existing_binary)
+                            os.chmod(existing_binary, 0o755)
+                        
+                        # Quick check to verify binary works
+                        if dependency_name == 'opusenc':
+                            cmd = [existing_binary, '--version']
+                            try:
+                                result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=5)
+                                if result.returncode == 0:
+                                    logger.info("Using previously downloaded %s: %s", dependency_name, existing_binary)
+                                    return existing_binary
+                            except:
+                                # If --version fails, try without arguments
+                                try:
+                                    result = subprocess.run([existing_binary], stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=5)
+                                    if result.returncode == 0:
+                                        logger.info("Using previously downloaded %s: %s", dependency_name, existing_binary)
+                                        return existing_binary
+                                except:
+                                    pass
+                        else:
+                            cmd = [existing_binary, '-version']
                             try:
-                                result = subprocess.run([existing_binary], stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=5)
+                                result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=5)
                                 if result.returncode == 0:
                                     logger.info("Using previously downloaded %s: %s", dependency_name, existing_binary)
                                     return existing_binary
                             except:
                                 pass
-                    else:
-                        cmd = [existing_binary, '-version']
-                        try:
-                            result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=5)
-                            if result.returncode == 0:
-                                logger.info("Using previously downloaded %s: %s", dependency_name, existing_binary)
-                                return existing_binary
-                        except:
-                            pass
-                            
-                    logger.warning("Previously downloaded %s exists but failed verification", dependency_name)
+                                
+                        logger.warning("Previously downloaded %s exists but failed verification", dependency_name)
+                except Exception as e:
+                    logger.warning("Error verifying downloaded binary: %s", e)
+
+        # Second priority: Check if it's in PATH (only if auto_download is False)
+        path_binary = check_binary_in_path(bin_name)
+        if path_binary:
+            logger.info("Found %s in PATH: %s", dependency_name, path_binary)
+            return path_binary
+    else:
+        logger.info("Auto-download enabled, forcing download/installation of %s", dependency_name)
+        # If there's an existing download directory, rename or remove it
+        if os.path.exists(dependency_dir):
+            try:
+                backup_dir = f"{dependency_dir}_backup_{int(time.time())}"
+                logger.debug("Moving existing dependency directory to: %s", backup_dir)
+                os.rename(dependency_dir, backup_dir)
             except Exception as e:
-                logger.warning("Error verifying downloaded binary: %s", e)
+                logger.warning("Failed to rename existing dependency directory: %s", e)
+                try:
+                    logger.debug("Trying to remove existing dependency directory")
+                    shutil.rmtree(dependency_dir, ignore_errors=True)
+                except Exception as e:
+                    logger.warning("Failed to remove existing dependency directory: %s", e)
     
     # If auto_download is not enabled, don't try to install or download
     if not auto_download:
-        logger.warning("%s not found in PATH and auto-download is disabled. Use --auto-download to enable automatic installation.", dependency_name)
+        logger.warning("%s not found in libs directory or PATH and auto-download is disabled. Use --auto-download to enable automatic installation.", dependency_name)
         return None
         
-    # If not in PATH, check if we should install via package manager
+    # If not in libs or PATH, check if we should install via package manager
     if 'package' in dependency_info:
         package_name = dependency_info['package']
-        logger.info("%s not found. Attempting to install %s package...", dependency_name, package_name)
+        logger.info("%s not found or forced download. Attempting to install %s package...", dependency_name, package_name)
         if install_package(package_name):
             path_binary = check_binary_in_path(bin_name)
             if path_binary:
@@ -382,16 +487,18 @@ def ensure_dependency(dependency_name, auto_download=False):
     
     # Set up download paths
     download_url = dependency_info['url']
-    os.makedirs(extract_dir, exist_ok=True)
+    
+    # Create dependency-specific directory
+    os.makedirs(dependency_dir, exist_ok=True)
     
     # Download and extract
     archive_ext = '.zip' if download_url.endswith('zip') else '.tar.xz'
-    archive_path = os.path.join(user_data_dir, f"{dependency_name}{archive_ext}")
+    archive_path = os.path.join(dependency_dir, f"{dependency_name}{archive_ext}")
     logger.debug("Using archive path: %s", archive_path)
     
     if download_file(download_url, archive_path):
-        if extract_archive(archive_path, extract_dir):
-            binary = find_binary_in_extracted_dir(extract_dir, binary_path)
+        if extract_archive(archive_path, dependency_dir):
+            binary = find_binary_in_extracted_dir(dependency_dir, binary_path)
             if binary:
                 # Make sure it's executable on Unix-like systems
                 if system in ['linux', 'darwin']:

tonietoolbox-0.2.0/TonieToolbox/recursive_processor.py

@@ -0,0 +1,250 @@
+"""
+Recursive folder processing functionality for the TonieToolbox package
+"""
+
+import os
+import glob
+from typing import List, Dict, Tuple, Set
+import logging
+import re
+
+from .audio_conversion import filter_directories
+from .logger import get_logger
+
+logger = get_logger('recursive_processor')
+
+
+def find_audio_folders(root_path: str) -> List[Dict[str, any]]:
+    """
+    Find and return all folders that contain audio files in a recursive manner,
+    organized in a way that handles nested folder structures.
+    
+    Args:
+        root_path: Root directory to start searching from
+        
+    Returns:
+        List of dictionaries with folder information, including paths and relationships
+    """
+    logger.info("Finding folders with audio files in: %s", root_path)
+    
+    # Dictionary to store folder information
+    # Key: folder path, Value: {audio_files, parent, children, depth}
+    folders_info = {}
+    abs_root = os.path.abspath(root_path)
+    
+    # First pass: Identify all folders containing audio files and calculate their depth
+    for dirpath, dirnames, filenames in os.walk(abs_root):
+        # Look for audio files in this directory
+        all_files = [os.path.join(dirpath, f) for f in filenames]
+        audio_files = filter_directories(all_files)
+        
+        if audio_files:
+            # Calculate folder depth relative to root
+            rel_path = os.path.relpath(dirpath, abs_root)
+            depth = 0 if rel_path == '.' else rel_path.count(os.sep) + 1
+            
+            # Store folder info
+            folders_info[dirpath] = {
+                'path': dirpath,
+                'audio_files': audio_files,
+                'parent': os.path.dirname(dirpath),
+                'children': [],
+                'depth': depth,
+                'file_count': len(audio_files)
+            }
+            logger.debug("Found folder with %d audio files: %s (depth %d)", 
+                        len(audio_files), dirpath, depth)
+    
+    # Second pass: Build parent-child relationships
+    for folder_path, info in folders_info.items():
+        parent_path = info['parent']
+        if parent_path in folders_info:
+            folders_info[parent_path]['children'].append(folder_path)
+    
+    # Convert to list and sort by path for consistent processing
+    folder_list = sorted(folders_info.values(), key=lambda x: x['path'])
+    logger.info("Found %d folders containing audio files", len(folder_list))
+    
+    return folder_list
+
+
+def determine_processing_folders(folders: List[Dict[str, any]]) -> List[Dict[str, any]]:
+    """
+    Determine which folders should be processed based on their position in the hierarchy.
+    
+    Args:
+        folders: List of folder dictionaries with hierarchy information
+        
+    Returns:
+        List of folders that should be processed (filtered)
+    """
+    # We'll use a set to track which folders we've decided to process
+    to_process = set()
+    
+    # Let's examine folders with the deepest nesting level first
+    max_depth = max(folder['depth'] for folder in folders) if folders else 0
+    
+    # First, mark terminal folders (leaf nodes) for processing
+    for folder in folders:
+        if not folder['children']:  # No children means it's a leaf node
+            to_process.add(folder['path'])
+            logger.debug("Marking leaf folder for processing: %s", folder['path'])
+    
+    # Check if any parent folders should be processed
+    # If a parent folder has significantly more audio files than the sum of its children,
+    # or some children aren't marked for processing, we should process the parent too
+    all_folders_by_path = {folder['path']: folder for folder in folders}
+    
+    # Work from bottom up (max depth to min)
+    for depth in range(max_depth, -1, -1):
+        for folder in [f for f in folders if f['depth'] == depth]:
+            if folder['path'] in to_process:
+                continue
+                
+            # Count audio files in children that will be processed
+            child_file_count = sum(all_folders_by_path[child]['file_count'] 
+                                  for child in folder['children'] 
+                                  if child in to_process)
+            
+            # If this folder has more files than what will be processed in children,
+            # or not all children will be processed, then process this folder too
+            if folder['file_count'] > child_file_count or any(child not in to_process for child in folder['children']):
+                to_process.add(folder['path'])
+                logger.debug("Marking parent folder for processing: %s (files: %d, child files: %d)", 
+                           folder['path'], folder['file_count'], child_file_count)
+    
+    # Return only folders that should be processed
+    result = [folder for folder in folders if folder['path'] in to_process]
+    logger.info("Determined %d folders should be processed (out of %d total folders with audio)", 
+              len(result), len(folders))
+    return result
+
+
+def get_folder_audio_files(folder_path: str) -> List[str]:
+    """
+    Get all audio files in a specific folder.
+    
+    Args:
+        folder_path: Path to folder
+        
+    Returns:
+        List of paths to audio files in natural sort order
+    """
+    audio_files = glob.glob(os.path.join(folder_path, "*"))
+    filtered_files = filter_directories(audio_files)
+    
+    # Sort files naturally (so that '2' comes before '10')
+    sorted_files = natural_sort(filtered_files)
+    logger.debug("Found %d audio files in folder: %s", len(sorted_files), folder_path)
+    
+    return sorted_files
+
+
+def natural_sort(file_list: List[str]) -> List[str]:
+    """
+    Sort a list of files in natural order (so that 2 comes before 10).
+    
+    Args:
+        file_list: List of file paths
+        
+    Returns:
+        Naturally sorted list of file paths
+    """
+    def convert(text):
+        return int(text) if text.isdigit() else text.lower()
+    
+    def alphanum_key(key):
+        return [convert(c) for c in re.split('([0-9]+)', key)]
+    
+    return sorted(file_list, key=alphanum_key)
+
+
+def extract_folder_meta(folder_path: str) -> Dict[str, str]:
+    """
+    Extract metadata from folder name.
+    Common format might be: "YYYY - NNN - Title"
+    
+    Args:
+        folder_path: Path to folder
+        
+    Returns:
+        Dictionary with extracted metadata (year, number, title)
+    """
+    folder_name = os.path.basename(folder_path)
+    logger.debug("Extracting metadata from folder: %s", folder_name)
+    
+    # Try to match the format "YYYY - NNN - Title"
+    match = re.match(r'(\d{4})\s*-\s*(\d+)\s*-\s*(.+)', folder_name)
+    
+    meta = {
+        'year': '',
+        'number': '',
+        'title': folder_name  # Default to the folder name if parsing fails
+    }
+    
+    if match:
+        year, number, title = match.groups()
+        meta['year'] = year
+        meta['number'] = number
+        meta['title'] = title.strip()
+        logger.debug("Extracted metadata: year=%s, number=%s, title=%s", 
+                    meta['year'], meta['number'], meta['title'])
+    else:
+        # Try to match just the number format "NNN - Title"
+        match = re.match(r'(\d+)\s*-\s*(.+)', folder_name)
+        if match:
+            number, title = match.groups()
+            meta['number'] = number
+            meta['title'] = title.strip()
+            logger.debug("Extracted metadata: number=%s, title=%s", 
+                        meta['number'], meta['title'])
+        else:
+            logger.debug("Could not extract structured metadata from folder name")
+    
+    return meta
+
+
+def process_recursive_folders(root_path: str) -> List[Tuple[str, str, List[str]]]:
+    """
+    Process folders recursively and prepare data for conversion.
+    
+    Args:
+        root_path: Root directory to start processing from
+        
+    Returns:
+        List of tuples: (output_filename, folder_path, list_of_audio_files)
+    """
+    logger.info("Processing folders recursively: %s", root_path)
+    
+    # Get folder info with hierarchy details
+    all_folders = find_audio_folders(root_path)
+    
+    # Determine which folders should be processed
+    folders_to_process = determine_processing_folders(all_folders)
+    
+    results = []
+    for folder_info in folders_to_process:
+        folder_path = folder_info['path']
+        audio_files = folder_info['audio_files']
+        
+        # Use natural sort order to ensure consistent results
+        audio_files = natural_sort(audio_files)
+        
+        meta = extract_folder_meta(folder_path)
+        
+        if audio_files:
+            # Create output filename from metadata
+            if meta['number'] and meta['title']:
+                output_name = f"{meta['number']} - {meta['title']}"
+            else:
+                output_name = os.path.basename(folder_path)
+                
+            # Clean up the output name (remove invalid filename characters)
+            output_name = re.sub(r'[<>:"/\\|?*]', '_', output_name)
+            
+            results.append((output_name, folder_path, audio_files))
+            logger.debug("Created processing task: %s -> %s (%d files)", 
+                        folder_path, output_name, len(audio_files))
+    
+    logger.info("Created %d processing tasks", len(results))
+    return results

{tonietoolbox-0.1.7 → tonietoolbox-0.2.0/TonieToolbox.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TonieToolbox
-Version: 0.1.7
+Version: 0.2.0
 Summary: Convert audio files to Tonie box compatible format
 Home-page: https://github.com/Quentendo64/TonieToolbox
 Author: Quentendo64
@@ -62,6 +62,7 @@ TonieToolbox allows you to create custom audio content for Tonie boxes by conver
 The tool provides several capabilities:
 
 - Convert single or multiple audio files into a Tonie-compatible format
+- Process complex folder structures recursively to handle entire audio collections
 - Analyze and validate existing Tonie files
 - Split Tonie files into individual opus tracks
 - Compare two TAF files for debugging differences
@@ -137,6 +138,22 @@ Or use a list file (.lst) containing paths to multiple audio files:
 tonietoolbox playlist.lst
 ```
 
+**Process folders recursively:**
+
+To process an entire folder structure with multiple audio folders:
+
+```
+tonietoolbox --recursive "Music/Albums"
+```
+
+This will scan all subfolders, identify those containing audio files, and create a TAF file for each folder.
+
+By default, all generated TAF files are saved in the `.\output` directory. If you want to save each TAF file in its source directory instead:
+
+```
+tonietoolbox --recursive --output-to-source "Music/Albums"
+```
+
 ### Advanced Options
 
 Run the following command to see all available options:
@@ -149,8 +166,8 @@ Output:
 ```
 usage: TonieToolbox.py [-h] [--ts TIMESTAMP] [--ffmpeg FFMPEG] [--opusenc OPUSENC] 
                     [--bitrate BITRATE] [--cbr] [--append-tonie-tag TAG] 
-                    [--no-tonie-header] [--info] [--split] [--recursive] [--compare FILE2]
-                    [--detailed-compare] [--debug] [--trace] [--quiet] [--silent]
+                    [--no-tonie-header] [--info] [--split] [--recursive] [--output-to-source]
+                    [--compare FILE2] [--detailed-compare] [--debug] [--trace] [--quiet] [--silent]
                     SOURCE [TARGET]
 
 Create Tonie compatible file from Ogg opus file(s).
@@ -170,6 +187,8 @@ optional arguments:
   --no-tonie-header     do not write Tonie header
   --info                Check and display info about Tonie file
   --split               Split Tonie file into opus tracks
+  --recursive           Process folders recursively
+  --output-to-source    Save output files in the source directory instead of output directory
   --compare FILE2       Compare input file with another .taf file for debugging
   --detailed-compare    Show detailed OGG page differences when comparing files
 
@@ -222,6 +241,20 @@ tonietoolbox input.mp3 --ts ./reference.taf  # Reference TAF for extraction
 tonietoolbox input.mp3 --bitrate 128
 ```
 
+#### Process a complex folder structure:
+
+Process an audiobook series with multiple folders:
+
+```
+tonietoolbox --recursive "\Hörspiele\Die drei Fragezeichen\Folgen"
+```
+
+Process a music collection with nested album folders and save TAF files alongside the source directories:
+
+```
+tonietoolbox --recursive --output-to-source "\Hörspiele\"
+```
+
 ## Technical Details
 
 ### TAF (Tonie Audio Format) File Structure

{tonietoolbox-0.1.7 → tonietoolbox-0.2.0}/TonieToolbox.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ TonieToolbox/filename_generator.py
 TonieToolbox/logger.py
 TonieToolbox/ogg_page.py
 TonieToolbox/opus_packet.py
+TonieToolbox/recursive_processor.py
 TonieToolbox/tonie_analysis.py
 TonieToolbox/tonie_file.py
 TonieToolbox/tonie_header.proto