TonieToolbox 0.1.8__py3-none-any.whl → 0.2.0__py3-none-any.whl

TonieToolbox/__init__.py

@@ -2,4 +2,4 @@
 TonieToolbox - Convert audio files to Tonie box compatible format
 """
 
-__version__ = '0.1.8'
+__version__ = '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/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/dependency_manager.py

@@ -392,6 +392,9 @@ def ensure_dependency(dependency_name, auto_download=False):
     dependency_info = DEPENDENCIES[dependency_name].get(system, {})
     binary_path = dependency_info.get('bin_path', dependency_name if dependency_name != 'opusenc' else 'opusenc')
     
+    # 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)
     
@@ -442,7 +445,6 @@ def ensure_dependency(dependency_name, auto_download=False):
                     logger.warning("Error verifying downloaded binary: %s", e)
 
         # Second priority: Check if it's in PATH (only if auto_download is False)
-        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)

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.8.dist-info → tonietoolbox-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TonieToolbox
-Version: 0.1.8
+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.8.dist-info → tonietoolbox-0.2.0.dist-info}/RECORD

@@ -1,20 +1,21 @@
-TonieToolbox/__init__.py,sha256=hVjFi2m8AmDYdgUfUTtXSWyyN2C7gLHLN2UgFdmsjpo,96
-TonieToolbox/__main__.py,sha256=eEsfnwLsgI6ynwR4uxo4CKptuOJDpGp6lYWSRwJSY3M,8520
-TonieToolbox/audio_conversion.py,sha256=10PayO1VQDGee2bcO6JD8zRSFoJRJhO2pBeba5k15vk,7998
+TonieToolbox/__init__.py,sha256=VFFoZT_t4IpL4Df8aABMBjxC8VE2JEKJD6-OHEwd-2A,96
+TonieToolbox/__main__.py,sha256=uDWIgVp-8T3jPi9kBDVsOigGoUWSGGeltUyM4zQElb8,10772
+TonieToolbox/audio_conversion.py,sha256=ra72qsE8j2GEP_4kqDT9m6aKlnnREZhZAlpf7y83pA0,11202
 TonieToolbox/constants.py,sha256=QQWQpnCI65GByLlXLOkt2n8nALLu4m6BWp0zuhI3M04,2021
-TonieToolbox/dependency_manager.py,sha256=Ag4_xuB6shqTAuoIVs5hfwzXA3nrOJbxW_08vC_76Ig,23386
+TonieToolbox/dependency_manager.py,sha256=fWtYp_UQDKrgIKcOyy95w7Grk_wYx5Fadyg8ulpb7nE,23451
 TonieToolbox/filename_generator.py,sha256=RqQHyGTKakuWR01yMSnFVMU_HfLw3rqFxKhXNIHdTlg,3441
 TonieToolbox/logger.py,sha256=Up9fBVkOZwkY61_645bX4tienCpyVSkap-FeTV0v730,1441
 TonieToolbox/ogg_page.py,sha256=-ViaIRBgh5ayfwmyplL8QmmRr5P36X8W0DdHkSFUYUU,21948
 TonieToolbox/opus_packet.py,sha256=OcHXEe3I_K4mWPUD55prpG42sZxJsEeAxqSbFxBmb0c,7895
+TonieToolbox/recursive_processor.py,sha256=vhQzC05bJVRPX8laj_5lxuRD40eLsZatzwCoCavMsmY,9304
 TonieToolbox/tonie_analysis.py,sha256=4eOzxHL_g0TJFhuexNHcZXivxZ7eb5xfb9-efUZ02W0,20344
 TonieToolbox/tonie_file.py,sha256=nIS4qhpBKIyPvTU39yYljRidpY6cz78halXlz3HJy9w,15294
 TonieToolbox/tonie_header.proto,sha256=WaWfwO4VrwGtscK2ujfDRKtpeBpaVPoZhI8iMmR-C0U,202
 TonieToolbox/tonie_header_pb2.py,sha256=s5bp4ULTEekgq6T61z9fDkRavyPM-3eREs20f_Pxxe8,3665
 TonieToolbox/version_handler.py,sha256=7Zx-pgzAUhz6jMplvNal1wHyxidodVxaNcAV0EMph5k,9778
-tonietoolbox-0.1.8.dist-info/licenses/LICENSE.md,sha256=rGoga9ZAgNco9fBapVFpWf6ri7HOBp1KRnt1uIruXMk,35190
-tonietoolbox-0.1.8.dist-info/METADATA,sha256=4TWL1cpSAVPDreuEIhjT2I3EZkVr7we-UFHrSNJ4Vlw,8971
-tonietoolbox-0.1.8.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
-tonietoolbox-0.1.8.dist-info/entry_points.txt,sha256=oqpeyBxel7aScg35Xr4gZKnf486S5KW9okqeBwyJxxc,60
-tonietoolbox-0.1.8.dist-info/top_level.txt,sha256=Wkkm-2p7I3ENfS7ZbYtYUB2g-xwHrXVlERHfonsOPuE,13
-tonietoolbox-0.1.8.dist-info/RECORD,,
+tonietoolbox-0.2.0.dist-info/licenses/LICENSE.md,sha256=rGoga9ZAgNco9fBapVFpWf6ri7HOBp1KRnt1uIruXMk,35190
+tonietoolbox-0.2.0.dist-info/METADATA,sha256=5qQuKTLQ9W3Txo6G_95M33OocNEg52emFXhUZFn4uww,10039
+tonietoolbox-0.2.0.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+tonietoolbox-0.2.0.dist-info/entry_points.txt,sha256=oqpeyBxel7aScg35Xr4gZKnf486S5KW9okqeBwyJxxc,60
+tonietoolbox-0.2.0.dist-info/top_level.txt,sha256=Wkkm-2p7I3ENfS7ZbYtYUB2g-xwHrXVlERHfonsOPuE,13
+tonietoolbox-0.2.0.dist-info/RECORD,,