TonieToolbox 0.6.1__py3-none-any.whl → 0.6.4__py3-none-any.whl

TonieToolbox/__init__.py

@@ -3,4 +3,4 @@
 TonieToolbox - Convert audio files to Tonie box compatible format
 """
 
-__version__ = '0.6.1'
+__version__ = '0.6.4'

TonieToolbox/__main__.py

@@ -10,19 +10,22 @@ import logging
 from . import __version__
 from .audio_conversion import get_input_files, append_to_filename
 from .tonie_file import create_tonie_file
-from .tonie_analysis import check_tonie_file, check_tonie_file_cli, split_to_opus_files, compare_taf_files
+from .tonie_analysis import check_tonie_file, check_tonie_file_cli, split_to_opus_files, compare_taf_files, extract_to_mp3_files, extract_full_audio_to_mp3
+from .player import interactive_player
 from .dependency_manager import get_ffmpeg_binary, get_opus_binary, ensure_dependency
 from .logger import TRACE, setup_logging, get_logger
 from .filename_generator import guess_output_filename, apply_template_to_path,ensure_directory_exists
 from .version_handler import check_for_updates, clear_version_cache
-from .recursive_processor import process_recursive_folders
-from .media_tags import is_available as is_media_tags_available, ensure_mutagen, extract_album_info, format_metadata_filename, get_file_tags
+from .recursive_processor import process_recursive_folders, find_audio_folders, get_all_audio_files_recursive
+from .media_tags import is_available as is_media_tags_available, ensure_mutagen, extract_album_info, format_metadata_filename, get_file_tags, get_all_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
 from .integration import handle_integration, handle_config
 
+
+
 def main():
     """Entry point for the TonieToolbox application."""
     parser = argparse.ArgumentParser(description='Create Tonie compatible file from Ogg opus file(s).')
@@ -34,6 +37,8 @@ def main():
                        help='Upload to TeddyCloud instance (e.g., https://teddycloud.example.com). Supports .taf, .jpg, .jpeg, .png files.')
     teddycloud_group.add_argument('--include-artwork', action='store_true',
                        help='Upload cover artwork image alongside the Tonie file when using --upload')
+    teddycloud_group.add_argument('--assign-to-tag', action='store_true',
+                       help='Assign the uploaded file to a specific tag ID')
     teddycloud_group.add_argument('--get-tags', action='store', metavar='URL',
                        help='Get available tags from TeddyCloud instance')
     teddycloud_group.add_argument('--ignore-ssl-verify', action='store_true',
@@ -74,17 +79,23 @@ def main():
     # ------------- 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('-b', '--bitrate', type=int, help='set encoding bitrate in kbps for Opus & MP3 Conversion (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 - 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')
     parser.add_argument('-i', '--info', action='store_true', help='Check and display info about Tonie file')
+    parser.add_argument('-p', '--play', action='store_true', help='Play TAF audio file with interactive controls')
+    parser.add_argument('--play-ui', action='store_true', help='Play TAF audio file with user interface (future implementation)')
     parser.add_argument('-s', '--split', action='store_true', help='Split Tonie file into opus tracks')
     parser.add_argument('-r', '--recursive', action='store_true', help='Process folders recursively')
+    parser.add_argument('--files-to-taf', action='store_true', 
+                        help='Convert each audio file in a directory to individual .taf files')
+    parser.add_argument('--convert-to-separate-mp3', action='store_true', help='Convert Tonie file to individual MP3 tracks')
+    parser.add_argument('--convert-to-single-mp3', action='store_true', help='Convert Tonie file to a single MP3 file')
     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('-fc', '--force-creation', action='store_true', default=False,
@@ -134,9 +145,7 @@ 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()
-    
-    # ------------- Parser - Source Input -------------
+    args = parser.parse_args()    # ------------- Parser - Source Input -------------
     if args.input_filename is None and not (args.get_tags or args.upload or args.install_integration or args.uninstall_integration or args.config_integration or args.auto_download):
         parser.error("the following arguments are required: SOURCE")
 
@@ -178,17 +187,25 @@ def main():
             logger.info("Update available but user chose to continue without updating.")
 
     # ------------- Autodownload & Dependency Checks -------------
-    if args.auto_download:
-        logger.debug("Auto-download requested for ffmpeg and opusenc")
-        ffmpeg_binary = get_ffmpeg_binary(auto_download=True)
-        opus_binary = get_opus_binary(auto_download=True)
-        if ffmpeg_binary and opus_binary:
-            logger.info("FFmpeg and opusenc downloaded successfully.")
-            if args.input_filename is None:
-                sys.exit(0)
-        else:
-            logger.error("Failed to download ffmpeg or opusenc. Please install them manually.")
+        # ------------- 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")
             sys.exit(1)
+        logger.debug("Using FFmpeg binary: %s", ffmpeg_binary)
+
+    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)
 
     # ------------- Context Menu Integration -------------
     if args.install_integration or args.uninstall_integration:
@@ -207,10 +224,158 @@ def main():
         else:
             logger.error("FFmpeg and opusenc are required for context menu integration")
             sys.exit(1)    
+
     if args.config_integration:
         logger.debug("Opening configuration file for editing")
         handle_config()
         sys.exit(0)
+          # ------------- Files to TAF Processing -------------
+    if args.files_to_taf:
+        if args.recursive:
+            logger.info("Processing individual files to separate TAF files recursively: %s", args.input_filename)
+        else:
+            logger.info("Processing individual files to separate TAF files: %s", args.input_filename)
+        
+        if not os.path.isdir(args.input_filename):
+            logger.error("--files-to-taf requires a directory as input")
+            sys.exit(1)
+        
+        # Use recursive file discovery if --recursive flag is also specified
+        if args.recursive:
+            audio_files = get_all_audio_files_recursive(args.input_filename)
+        else:
+            audio_files = get_input_files(args.input_filename)
+        
+        if not audio_files:
+            search_type = "recursively" if args.recursive else "in directory"
+            logger.error("No audio files found %s: %s", search_type, args.input_filename)
+            sys.exit(1)
+            
+        logger.info("Found %d audio files to convert", len(audio_files))
+        
+        output_dir = args.input_filename if args.output_to_source else './output'
+        
+        if not args.output_to_source and not os.path.exists(output_dir):
+            os.makedirs(output_dir, exist_ok=True)
+            logger.debug("Created output directory: %s", output_dir)
+        
+        created_files = []
+        for file_index, audio_file in enumerate(audio_files):
+            # Generate output filename based on the original file
+            base_name = os.path.splitext(os.path.basename(audio_file))[0]
+            
+            # Apply media tag naming if requested
+            if args.use_media_tags:
+                tags = get_file_tags(audio_file)
+                if tags:
+                    template = args.name_template or "{artist} - {title}"
+                    new_name = format_metadata_filename(tags, template)
+                    if new_name:
+                        logger.debug("Using media tags for file naming: %s -> %s", base_name, new_name)
+                        base_name = new_name
+            
+            # Apply tonie tag if specified
+            if args.append_tonie_tag:
+                hex_tag = args.append_tonie_tag
+                if not all(c in '0123456789abcdefABCDEF' for c in hex_tag) or len(hex_tag) != 8:
+                    logger.error("TAG must be an 8-character hexadecimal value")
+                    sys.exit(1)
+                base_name = append_to_filename(base_name, hex_tag)
+            
+            output_filename = os.path.join(output_dir, f"{base_name}.taf")
+            
+            # Check if file already exists
+            skip_creation = False
+            if os.path.exists(output_filename):
+                logger.warning("Output file already exists: %s", output_filename)
+                valid_taf = check_tonie_file_cli(output_filename)
+                
+                if valid_taf and not args.force_creation:
+                    logger.warning("Valid Tonie file exists, skipping: %s", output_filename)
+                    skip_creation = True
+                else:
+                    logger.info("Output file exists but is not valid, proceeding to create new one")
+            
+            logger.info("[%d/%d] Converting: %s -> %s", 
+                      file_index + 1, len(audio_files), os.path.basename(audio_file), os.path.basename(output_filename))
+            
+            if not skip_creation:
+                try:
+                    create_tonie_file(output_filename, [audio_file], 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: %s", output_filename)
+                except Exception as e:
+                    logger.error("Failed to create %s: %s", output_filename, str(e))
+                    continue
+            
+            created_files.append(output_filename)
+            
+            # Handle upload if requested
+            if args.upload:
+                upload_path = args.path
+                if upload_path and '{' in upload_path and args.use_media_tags:
+                    metadata = get_file_tags(audio_file)
+                    if metadata:
+                        formatted_path = apply_template_to_path(upload_path, metadata)
+                        if formatted_path:
+                            logger.info("Using dynamic upload path from template: %s", formatted_path)
+                            upload_path = formatted_path
+                        else:
+                            logger.warning("Could not apply all tags to path template '%s'. Using as-is.", upload_path)
+                
+                # Create directories recursively if path is provided
+                if upload_path:
+                    logger.debug("Creating directory structure on server: %s", upload_path)
+                    try:
+                        client.create_directories_recursive(
+                            path=upload_path, 
+                            special=args.special_folder
+                        )
+                        logger.debug("Successfully created directory structure on server")
+                    except Exception as e:
+                        logger.warning("Failed to create directory structure on server: %s", str(e))
+                        logger.debug("Continuing with upload anyway, in case the directory already exists")
+                
+                response = client.upload_file(
+                    file_path=output_filename,
+                    destination_path=upload_path,                    
+                    special=args.special_folder,
+                )
+                upload_success = response.get('success', False)
+                
+                if not upload_success:
+                    logger.error("Failed to upload %s to TeddyCloud", output_filename)
+                else:
+                    logger.info("Successfully uploaded %s to TeddyCloud", output_filename)
+                
+                # Handle artwork upload
+                artwork_url = None
+                if args.include_artwork:
+                    success, artwork_url = upload_artwork(client, output_filename, os.path.dirname(audio_file), [audio_file])
+                    if success:
+                        logger.info("Successfully uploaded artwork for %s", output_filename)
+                    else:
+                        logger.warning("Failed to upload artwork for %s", output_filename)
+                
+                # Handle custom JSON creation
+                if args.create_custom_json:
+                    json_output_dir = args.input_filename 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, output_filename, [audio_file], artwork_url, json_output_dir)
+                    else:
+                        success = fetch_and_update_tonies_json_v1(client_param, output_filename, [audio_file], artwork_url, json_output_dir)
+                    if success:
+                        logger.info("Successfully updated Tonies JSON for %s", output_filename)
+                    else:
+                        logger.warning("Failed to update Tonies JSON for %s", output_filename)
+        
+        logger.info("Files to TAF processing completed. Created %d Tonie files.", len(created_files))
+        sys.exit(0)
+        
         # ------------- Normalize Path Input -------------
     if args.input_filename:
         logger.debug("Original input path: %s", args.input_filename)
@@ -258,7 +423,7 @@ def main():
             logger.error("No files found for pattern %s", args.input_filename)
             sys.exit(1)
         for file_index, file_path in enumerate(files):
-            tags = get_file_tags(file_path)
+            tags = get_all_file_tags(file_path)
             if tags:
                 print(f"\nFile {file_index + 1}: {os.path.basename(file_path)}")
                 print("-" * 40)
@@ -323,6 +488,21 @@ def main():
                 logger.info("Successfully uploaded %s to TeddyCloud", file_path)
                 logger.debug("Upload response details: %s", 
                           {k: v for k, v in response.items() if k != 'success'})
+                if args.assign_to_tag:
+                    tag_id = input("Enter the tag ID to assign the uploaded file: eg. 'E0:04:03:50:11:AA:7E:81': ").strip()
+                    fileName = os.path.basename(file_path)
+                    if upload_path:
+                        libPath = f"lib://{upload_path}/{fileName}"
+                    else:
+                        libPath = f"lib://{fileName}"
+                    logger.info("Assigning uploaded file %s to tag ID: %s", fileName, tag_id)
+                    logger.debug("Library path for assignment: %s", libPath)
+                    success = client.assign_tag_path(libPath, tag_id)
+                    if success:
+                        logger.info("Successfully assigned tag %s to %s", tag_id, fileName)
+                    else:
+                        logger.warning("Failed to assign tag %s to %s", tag_id, fileName)
+
             artwork_url = None
             if args.include_artwork and file_path.lower().endswith('.taf'):
                 source_dir = os.path.dirname(file_path)
@@ -500,6 +680,23 @@ def main():
             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)
+        elif args.play:
+            logger.info("Playing Tonie file: %s", args.input_filename)
+            interactive_player(args.input_filename)
+            sys.exit(0)        
+        elif args.play_ui:
+            logger.warning("Nothing to see here yet!")
+            logger.info("This is for future implementation of a minimal GUI player.")
+            logger.info("Playing Tonie file with user interface: %s", args.input_filename)
+            sys.exit(0)
+        elif args.convert_to_separate_mp3:
+            logger.info("Converting Tonie file to separate MP3 tracks: %s", args.input_filename)
+            extract_to_mp3_files(args.input_filename, args.output_filename, args.bitrate)
+            sys.exit(0)
+        elif args.convert_to_single_mp3:
+            logger.info("Converting Tonie file to single MP3: %s", args.input_filename)
+            extract_full_audio_to_mp3(args.input_filename, args.output_filename, args.bitrate)
+            sys.exit(0)
 
     files = get_input_files(args.input_filename)
     logger.debug("Found %d files to process", len(files))
@@ -600,7 +797,7 @@ def main():
                     out_filename = formatted_path
                 logger.info("Using template path for output: %s", out_filename)
             else:
-                logger.warning("Could not apply template to path. Using default output location.")
+                logger.warning("Could not apply template to path. Using default output handling.")
                 # Fall back to default output handling
                 if guessed_name:
                     logger.debug("Using guessed name for output: %s", guessed_name)
@@ -615,7 +812,7 @@ def main():
                         out_filename = os.path.join(output_dir, guessed_name)
                         logger.debug("Using default output location: %s", out_filename)
         else:
-            logger.warning("No metadata available to apply to template path. Using default output location.")
+            logger.warning("No metadata available to apply to template path. Using default output handling.")
             # Fall back to default output handling
     elif guessed_name:
         logger.debug("Using guessed name for output: %s", guessed_name)

TonieToolbox/audio_conversion.py

@@ -208,6 +208,83 @@ def get_opus_tempfile(
         return tmp_file, None
 
 
+def convert_opus_to_mp3(
+    opus_data: bytes,
+    output_path: str,
+    ffmpeg_binary: str = None,
+    bitrate: int = 128,
+    auto_download: bool = False
+) -> bool:
+    """
+    Convert Opus audio data to MP3 format using FFmpeg.
+    
+    Args:
+        opus_data (bytes): Raw Opus audio data (OGG container with Opus codec)
+        output_path (str): Path where to save the MP3 file
+        ffmpeg_binary (str | None): Path to the ffmpeg binary. If None, will be auto-detected or downloaded.
+        bitrate (int): Bitrate for the MP3 encoding in kbps
+        auto_download (bool): Whether to automatically download dependencies if not found
+    Returns:
+        bool: True if conversion was successful, False otherwise
+    """
+    logger.trace("Entering convert_opus_to_mp3(output_path=%s, bitrate=%d, auto_download=%s)",
+                output_path, bitrate, auto_download)
+    
+    logger.debug("Converting Opus data to MP3 format (bitrate: %d kbps)", bitrate)
+    
+    if ffmpeg_binary is None:
+        logger.debug("FFmpeg not specified, attempting to auto-detect")
+        ffmpeg_binary = get_ffmpeg_binary(auto_download)
+        if ffmpeg_binary is None:
+            logger.error("Could not find FFmpeg binary. Use --auto-download to enable automatic installation")
+            raise RuntimeError("Could not find FFmpeg binary. Use --auto-download to enable automatic installation")
+        logger.debug("Found FFmpeg at: %s", ffmpeg_binary)
+    
+    try:
+        logger.debug("Starting FFmpeg process for Opus to MP3 conversion")
+        ffmpeg_cmd = [
+            ffmpeg_binary, "-hide_banner", "-loglevel", "warning",
+            "-i", "-",  # Read from stdin
+            "-acodec", "libmp3lame",  # Use LAME MP3 encoder
+            "-b:a", f"{bitrate}k",  # Set bitrate
+            "-y",  # Overwrite output file
+            output_path
+        ]
+        logger.trace("FFmpeg command: %s", ffmpeg_cmd)
+        
+        ffmpeg_process = subprocess.Popen(
+            ffmpeg_cmd, 
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+        
+        # Write Opus data to FFmpeg stdin
+        stdout, stderr = ffmpeg_process.communicate(input=opus_data)
+        
+        logger.debug("FFmpeg process completed with return code: %d", ffmpeg_process.returncode)
+        
+        if ffmpeg_process.returncode != 0:
+            logger.error("FFmpeg conversion failed with return code %d", ffmpeg_process.returncode)
+            if stderr:
+                logger.error("FFmpeg error output: %s", stderr.decode('utf-8', errors='replace'))
+            return False
+        
+        # Verify the output file was created
+        if os.path.exists(output_path) and os.path.getsize(output_path) > 0:
+            logger.debug("Successfully created MP3 file: %s (size: %d bytes)", 
+                        output_path, os.path.getsize(output_path))
+            logger.trace("Exiting convert_opus_to_mp3() with success")
+            return True
+        else:
+            logger.error("MP3 file was not created or is empty: %s", output_path)
+            return False
+            
+    except Exception as e:
+        logger.error("Error during Opus to MP3 conversion: %s", str(e))
+        return False
+
+
 def filter_directories(glob_list: list[str]) -> list[str]:
     """
     Filter a list of glob results to include only audio files that can be handled by ffmpeg.

TonieToolbox/dependency_manager.py

@@ -945,6 +945,66 @@ def get_ffmpeg_binary(auto_download=False):
         logger.warning("FFmpeg is not available and --auto-download is not used.")
         return None
 
+def get_ffplay_binary(auto_download=False):
+    """
+    Get the path to the FFplay binary, downloading it if necessary and allowed.
+    FFplay is typically included with FFmpeg installations.
+    
+    Args:
+        auto_download (bool): Whether to automatically download FFplay if not found (defaults to False)
+        
+    Returns:
+        str: Path to the FFplay binary, or None if not available
+    """
+    logger.debug("Getting FFplay binary")
+    
+    # Define the expected binary path
+    local_dir = os.path.join(get_user_data_dir(), 'libs', 'ffmpeg')
+    if sys.platform == 'win32':
+        binary_path = os.path.join(local_dir, 'ffplay.exe')
+    else:
+        binary_path = os.path.join(local_dir, 'ffplay')
+    
+    # Check if binary exists
+    if os.path.exists(binary_path) and os.path.isfile(binary_path):
+        logger.debug("FFplay binary found at %s", binary_path)
+        return binary_path
+    
+    # Check if a system-wide FFplay is available
+    try:
+        if sys.platform == 'win32':
+            # On Windows, look for ffplay in PATH
+            from shutil import which
+            system_binary = which('ffplay')
+            if system_binary:
+                logger.debug("System-wide FFplay found at %s", system_binary)
+                return system_binary
+        else:
+            # On Unix-like systems, use 'which' command
+            system_binary = subprocess.check_output(['which', 'ffplay']).decode('utf-8').strip()
+            if system_binary:
+                logger.debug("System-wide FFplay found at %s", system_binary)
+                return system_binary
+    except (subprocess.SubprocessError, FileNotFoundError):
+        logger.debug("No system-wide FFplay found")
+    
+    # If FFplay is not found but auto_download is enabled, try to get FFmpeg first
+    # since FFplay is usually bundled with FFmpeg
+    if auto_download:
+        logger.info("FFplay not found, attempting to get FFmpeg (which includes FFplay)")
+        ffmpeg_path = get_ffmpeg_binary(auto_download=True)
+        if ffmpeg_path:
+            # Check if ffplay was included in the FFmpeg download
+            if os.path.exists(binary_path) and os.path.isfile(binary_path):
+                logger.info("FFplay found after FFmpeg download: %s", binary_path)
+                return binary_path
+        
+        logger.warning("FFplay not available even after FFmpeg download")
+        return None
+    else:
+        logger.warning("FFplay is not available and --auto-download is not used.")
+        return None
+
 def get_opus_binary(auto_download=False):
     """
     Get the path to the Opus binary, downloading it if necessary and allowed.

TonieToolbox/integration.py

@@ -46,7 +46,31 @@ def handle_integration(args):
     elif platform.system() == 'Darwin':
         raise NotImplementedError("Context menu integration is not supported on MacOS YET. But Soon™")
     elif platform.system() == 'Linux':
-        raise NotImplementedError("Context menu integration is not supported on Linux YET. But Soon™")
+        # Check if we're running in KDE
+        kde_session = os.environ.get('KDE_SESSION_VERSION') or os.environ.get('KDE_FULL_SESSION')
+        desktop_session = os.environ.get('DESKTOP_SESSION', '').lower()
+        xdg_current_desktop = os.environ.get('XDG_CURRENT_DESKTOP', '').lower()
+        
+        if kde_session or 'kde' in desktop_session or 'kde' in xdg_current_desktop:
+            from .integration_kde import KDEServiceMenuIntegration as ContextMenuIntegration
+            if args.install_integration:
+                success = ContextMenuIntegration.install()
+                if success:
+                    logger.info("Integration installed successfully.")
+                    return True
+                else:
+                    logger.error("Integration installation failed.")
+                    return False
+            elif args.uninstall_integration:
+                success = ContextMenuIntegration.uninstall()
+                if success:
+                    logger.info("Integration uninstalled successfully.")
+                    return True
+                else:
+                    logger.error("Integration uninstallation failed.")
+                    return False
+        else:
+            raise NotImplementedError("Context menu integration is currently only supported on KDE. Other Linux desktop environments are not supported yet.")
     else:
         raise NotImplementedError(f"Context menu integration is not supported on this OS: {platform.system()}")
     
@@ -68,6 +92,18 @@ def handle_config():
         context_menu._apply_config_template()
         subprocess.call(["open", config_path])
     elif platform.system() == "Linux":
+        kde_session = os.environ.get('KDE_SESSION_VERSION') or os.environ.get('KDE_FULL_SESSION')
+        desktop_session = os.environ.get('DESKTOP_SESSION', '').lower()
+        xdg_current_desktop = os.environ.get('XDG_CURRENT_DESKTOP', '').lower()
+        
+        if kde_session or 'kde' in desktop_session or 'kde' in xdg_current_desktop:
+            try:
+                from .integration_kde import KDEServiceMenuIntegration as ContextMenuIntegration
+                context_menu = ContextMenuIntegration()
+                context_menu._apply_config_template()
+            except Exception as e:
+                logger.warning(f"Could not create config template: {e}")
+        
         subprocess.call(["xdg-open", config_path])
     else:
         logger.error(f"Unsupported OS: {platform.system()}")