TonieToolbox 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

TonieToolbox/__init__.py

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

TonieToolbox/__main__.py

@@ -15,7 +15,7 @@ from .tonie_analysis import check_tonie_file, split_to_opus_files
 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
+from .version_handler import check_for_updates, clear_version_cache
 
 def main():
     """Entry point for the TonieToolbox application."""
@@ -45,8 +45,15 @@ def main():
                        help='Compare input file with another .taf file for debugging')
     parser.add_argument('--detailed-compare', action='store_true',
                        help='Show detailed OGG page differences when comparing files')
-    parser.add_argument('--skip-update-check', action='store_true',
+    
+    # Version check options
+    version_group = parser.add_argument_group('Version Check Options')
+    version_group.add_argument('--skip-update-check', action='store_true',
                        help='Skip checking for updates')
+    version_group.add_argument('--force-refresh-cache', action='store_true',
+                       help='Force refresh of update information from PyPI')
+    version_group.add_argument('--clear-version-cache', action='store_true',
+                       help='Clear cached version information')
     
     log_group = parser.add_argument_group('Logging Options')
     log_level_group = log_group.add_mutually_exclusive_group()
@@ -70,10 +77,25 @@ def main():
 
     setup_logging(log_level)
     logger = get_logger('main')
-    logger.debug("Starting TonieToolbox with log level: %s", logging.getLevelName(log_level))
+    logger.debug("Starting TonieToolbox v%s with log level: %s", __version__, logging.getLevelName(log_level))
+    
+    # Handle version cache operations
+    if args.clear_version_cache:
+        if clear_version_cache():
+            logger.info("Version cache cleared successfully")
+        else:
+            logger.info("No version cache to clear or error clearing cache")
     
+    # Check for updates
     if not args.skip_update_check:
-        check_for_updates(quiet=args.silent or args.quiet)
+        logger.debug("Checking for updates (force_refresh=%s)", args.force_refresh_cache)
+        is_latest, latest_version, message, update_confirmed = check_for_updates(
+            quiet=args.silent or args.quiet,
+            force_refresh=args.force_refresh_cache
+        )
+        
+        if not is_latest and not update_confirmed and not (args.silent or args.quiet):
+            logger.info("Update available but user chose to continue without updating.")
 
     ffmpeg_binary = args.ffmpeg
     if ffmpeg_binary is None:

TonieToolbox/dependency_manager.py

@@ -309,14 +309,65 @@ def ensure_dependency(dependency_name, auto_download=False):
         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)
+    
+    # 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
+                            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(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)
+            except Exception as e:
+                logger.warning("Error verifying downloaded binary: %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)
         return None
         
     # If not in PATH, check if we should install via package manager
-    if 'package' in DEPENDENCIES[dependency_name].get(system, {}):
-        package_name = DEPENDENCIES[dependency_name][system]['package']
+    if 'package' in dependency_info:
+        package_name = dependency_info['package']
         logger.info("%s not found. Attempting to install %s package...", dependency_name, package_name)
         if install_package(package_name):
             path_binary = check_binary_in_path(bin_name)
@@ -325,27 +376,14 @@ def ensure_dependency(dependency_name, auto_download=False):
                 return path_binary
     
     # If not installable via package manager or installation failed, try downloading
-    if 'url' not in DEPENDENCIES[dependency_name].get(system, {}):
+    if 'url' not in dependency_info:
         logger.error("Cannot download %s for %s", dependency_name, system)
         return None
     
-    # Set up paths
-    user_data_dir = get_user_data_dir()
-    dependency_info = DEPENDENCIES[dependency_name][system]
+    # Set up download paths
     download_url = dependency_info['url']
-    extract_dir_name = dependency_info['extract_dir']
-    binary_path = dependency_info['bin_path']
-    
-    extract_dir = os.path.join(user_data_dir, extract_dir_name)
-    logger.debug("Using extract directory: %s", extract_dir)
     os.makedirs(extract_dir, exist_ok=True)
     
-    # Check if we already downloaded and extracted it
-    existing_binary = find_binary_in_extracted_dir(extract_dir, binary_path)
-    if existing_binary and os.path.exists(existing_binary):
-        logger.info("Using existing %s: %s", dependency_name, existing_binary)
-        return existing_binary
-    
     # 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}")

TonieToolbox/version_handler.py

@@ -12,45 +12,70 @@ from urllib.error import URLError
 from . import __version__
 from .logger import get_logger
 
+# Cache filename for version information
 CACHE_DIR = os.path.join(os.path.expanduser("~"), ".tonietoolbox")
 CACHE_FILE = os.path.join(CACHE_DIR, "version_cache.json")
 CACHE_EXPIRY = 86400  # 24 hours in seconds
 
 
-def get_pypi_version():
+def get_pypi_version(force_refresh=False):
     """
     Get the latest version of TonieToolbox from PyPI.
     
+    Args:
+        force_refresh: If True, ignore the cache and fetch directly from PyPI
+        
     Returns:
         tuple: (latest_version, None) on success, (current_version, error_message) on failure
     """
     logger = get_logger("version_handler")
+    logger.debug("Checking for latest version (force_refresh=%s)", force_refresh)
+    logger.debug("Current version: %s", __version__)
     
     try:
-        if os.path.exists(CACHE_FILE):
+        # Check if we have a recent cache and should use it
+        if not force_refresh and os.path.exists(CACHE_FILE):
             try:
                 with open(CACHE_FILE, "r") as f:
                     cache_data = json.load(f)
                     
-                if time.time() - cache_data.get("timestamp", 0) < CACHE_EXPIRY:
-                    logger.debug("Using cached version info: %s", cache_data["version"])
-                    return cache_data["version"], None
+                cached_version = cache_data.get("version")
+                cache_timestamp = cache_data.get("timestamp", 0)
+                cache_age = time.time() - cache_timestamp
+                
+                logger.debug("Cache info: version=%s, age=%d seconds (expires after %d)", 
+                            cached_version, cache_age, CACHE_EXPIRY)
+                
+                if cache_age < CACHE_EXPIRY:
+                    logger.debug("Using cached version info: %s", cached_version)
+                    return cached_version, None
+                else:
+                    logger.debug("Cache expired (%d seconds old), refreshing from PyPI", cache_age)
             except (json.JSONDecodeError, KeyError) as e:
                 logger.debug("Cache file corrupt, will fetch from PyPI: %s", e)
+        else:
+            if force_refresh:
+                logger.debug("Forced refresh requested, bypassing cache")
+            else:
+                logger.debug("No cache found, fetching from PyPI")
         
+        # Fetch from PyPI
         logger.debug("Fetching latest version from PyPI")
         with request.urlopen("https://pypi.org/pypi/TonieToolbox/json", timeout=2) as response:
             pypi_data = json.loads(response.read().decode("utf-8"))
             latest_version = pypi_data["info"]["version"]
             
+            # Update cache
             if not os.path.exists(CACHE_DIR):
                 os.makedirs(CACHE_DIR, exist_ok=True)
                 
             with open(CACHE_FILE, "w") as f:
-                json.dump({
+                cache_data = {
                     "version": latest_version,
                     "timestamp": time.time()
-                }, f)
+                }
+                json.dump(cache_data, f)
+                logger.debug("Updated cache: %s", cache_data)
                 
             logger.debug("Latest version from PyPI: %s", latest_version)
             return latest_version, None
@@ -74,43 +99,67 @@ def compare_versions(v1, v2):
     Returns:
         int: -1 if v1 < v2, 0 if v1 == v2, 1 if v1 > v2
     """
-    v1_parts = [int(x) for x in v1.split('.')]
-    v2_parts = [int(x) for x in v2.split('.')]
+    logger = get_logger("version_handler")
+    logger.debug("Comparing versions: '%s' vs '%s'", v1, v2)
     
-    for i in range(max(len(v1_parts), len(v2_parts))):
-        v1_part = v1_parts[i] if i < len(v1_parts) else 0
-        v2_part = v2_parts[i] if i < len(v2_parts) else 0
+    try:
+        v1_parts = [int(x) for x in v1.split('.')]
+        v2_parts = [int(x) for x in v2.split('.')]
+        
+        logger.debug("Version parts: %s vs %s", v1_parts, v2_parts)
         
-        if v1_part < v2_part:
-            return -1
-        elif v1_part > v2_part:
-            return 1
+        for i in range(max(len(v1_parts), len(v2_parts))):
+            v1_part = v1_parts[i] if i < len(v1_parts) else 0
+            v2_part = v2_parts[i] if i < len(v2_parts) else 0
             
-    return 0
+            logger.debug("Comparing part %d: %d vs %d", i, v1_part, v2_part)
+            
+            if v1_part < v2_part:
+                logger.debug("Result: '%s' is OLDER than '%s'", v1, v2)
+                return -1
+            elif v1_part > v2_part:
+                logger.debug("Result: '%s' is NEWER than '%s'", v1, v2)
+                return 1
+        
+        logger.debug("Result: versions are EQUAL")
+        return 0
+    except Exception as e:
+        logger.debug("Error comparing versions '%s' and '%s': %s", v1, v2, e)
+        # On error, assume versions are equal
+        return 0
 
 
-def check_for_updates(quiet=False):
+def check_for_updates(quiet=False, force_refresh=False):
     """
     Check if the current version of TonieToolbox is the latest.
     
     Args:
-        quiet: If True, will not log any information messages
+        quiet: If True, will not log any information messages and skip user confirmation
+        force_refresh: If True, bypass cache and check PyPI directly
         
     Returns:
-        tuple: (is_latest, latest_version, message)
+        tuple: (is_latest, latest_version, message, update_confirmed)
             is_latest: boolean indicating if the current version is the latest
             latest_version: string with the latest version
             message: string message about the update status or error
+            update_confirmed: boolean indicating if the user confirmed the update
     """
     logger = get_logger("version_handler")
     current_version = __version__
+    update_confirmed = False
     
-    latest_version, error = get_pypi_version()
+    logger.debug("Starting update check (quiet=%s, force_refresh=%s)", 
+                quiet, force_refresh)
+    latest_version, error = get_pypi_version(force_refresh)
     
     if error:
-        return True, current_version, error
+        logger.debug("Error occurred during update check: %s", error)
+        return True, current_version, error, update_confirmed
         
-    is_latest = compare_versions(current_version, latest_version) >= 0
+    compare_result = compare_versions(current_version, latest_version)
+    is_latest = compare_result >= 0  # current >= latest
+    
+    logger.debug("Version comparison result: %d (is_latest=%s)", compare_result, is_latest)
     
     if is_latest:
         message = f"You are using the latest version of TonieToolbox ({current_version})"
@@ -120,6 +169,88 @@ def check_for_updates(quiet=False):
         message = f"Update available! Current version: {current_version}, Latest version: {latest_version}"
         if not quiet:
             logger.info(message)
-            logger.info("Consider upgrading with: pip install --upgrade TonieToolbox")
+            
+            # Show confirmation prompt if not in quiet mode
+            try:
+                response = input(f"Do you want to upgrade to TonieToolbox {latest_version}? [y/N]: ").lower().strip()
+                update_confirmed = response == 'y' or response == 'yes'
+                
+                if update_confirmed:
+                    logger.info("Update confirmed. Attempting to install update...")
+                    if install_update():
+                        logger.info(f"Successfully updated to TonieToolbox {latest_version}")
+                        import sys
+                        logger.info("Exiting program. Please restart TonieToolbox to use the new version.")
+                        sys.exit(0)
+                    else:
+                        logger.error("Failed to install update automatically")
+                        logger.error("Please update manually using: pip install --upgrade TonieToolbox")
+                        import sys
+                        sys.exit(1)
+                else:
+                    logger.info("Update skipped by user.")
+            except (EOFError, KeyboardInterrupt):
+                logger.debug("User input interrupted")
+                update_confirmed = False
+    
+    return is_latest, latest_version, message, update_confirmed
+
+
+def install_update():
+    """
+    Try to install the update using pip, pip3, or pipx.
     
-    return is_latest, latest_version, message
+    Returns:
+        bool: True if the update was successfully installed, False otherwise
+    """
+    logger = get_logger("version_handler")
+    import subprocess
+    import sys
+    
+    package_name = "TonieToolbox"
+    commands = [
+        [sys.executable, "-m", "pip", "install", "--upgrade", package_name],
+        ["pip", "install", "--upgrade", package_name],
+        ["pip3", "install", "--upgrade", package_name],
+        ["pipx", "upgrade", package_name]
+    ]
+    
+    for cmd in commands:
+        try:
+            logger.info(f"Attempting to install update using: {' '.join(cmd)}")
+            result = subprocess.run(cmd, capture_output=True, text=True, check=False)
+            
+            if result.returncode == 0:
+                logger.debug("Update command succeeded")
+                logger.debug(f"Output: {result.stdout}")
+                return True
+            else:
+                logger.debug(f"Command failed with returncode {result.returncode}")
+                logger.debug(f"stdout: {result.stdout}")
+                logger.debug(f"stderr: {result.stderr}")
+        except Exception as e:
+            logger.debug(f"Exception while running {cmd[0]}: {str(e)}")
+    
+    return False
+
+
+def clear_version_cache():
+    """
+    Clear the version cache file to force a refresh on next check.
+    
+    Returns:
+        bool: True if cache was cleared, False otherwise
+    """
+    logger = get_logger("version_handler")
+    
+    try:
+        if os.path.exists(CACHE_FILE):
+            logger.debug("Removing version cache file: %s", CACHE_FILE)
+            os.remove(CACHE_FILE)
+            return True
+        else:
+            logger.debug("No cache file to remove")
+            return False
+    except Exception as e:
+        logger.debug("Error clearing cache: %s", e)
+        return False

{tonietoolbox-0.1.5.dist-info → tonietoolbox-0.1.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TonieToolbox
-Version: 0.1.5
+Version: 0.1.7
 Summary: Convert audio files to Tonie box compatible format
 Home-page: https://github.com/Quentendo64/TonieToolbox
 Author: Quentendo64

{tonietoolbox-0.1.5.dist-info → tonietoolbox-0.1.7.dist-info}/RECORD

@@ -1,8 +1,8 @@
-TonieToolbox/__init__.py,sha256=GWKHuNGUgyxzsQA6MMamoyPceyqIYi7kmsdxdMgwreg,96
-TonieToolbox/__main__.py,sha256=c1D_6YP2Y-aBB6sl1aFZPyiwnmdMY8vM3taPcDLWX_Q,7385
+TonieToolbox/__init__.py,sha256=H7iZa88oEbyIf0RTuwe8HaIbX7hDamX8WW6fQubcijs,96
+TonieToolbox/__main__.py,sha256=eEsfnwLsgI6ynwR4uxo4CKptuOJDpGp6lYWSRwJSY3M,8520
 TonieToolbox/audio_conversion.py,sha256=10PayO1VQDGee2bcO6JD8zRSFoJRJhO2pBeba5k15vk,7998
 TonieToolbox/constants.py,sha256=QQWQpnCI65GByLlXLOkt2n8nALLu4m6BWp0zuhI3M04,2021
-TonieToolbox/dependency_manager.py,sha256=sr7PMBsqQ26bYszM-7Ay-UbKPuBJGyeJV3y1BPAOiBQ,15028
+TonieToolbox/dependency_manager.py,sha256=LHH8PlKp12_TkFFk2dyg6CRURh3-oCOiDff1AIEUbKU,17397
 TonieToolbox/filename_generator.py,sha256=RqQHyGTKakuWR01yMSnFVMU_HfLw3rqFxKhXNIHdTlg,3441
 TonieToolbox/logger.py,sha256=Up9fBVkOZwkY61_645bX4tienCpyVSkap-FeTV0v730,1441
 TonieToolbox/ogg_page.py,sha256=-ViaIRBgh5ayfwmyplL8QmmRr5P36X8W0DdHkSFUYUU,21948
@@ -11,10 +11,10 @@ TonieToolbox/tonie_analysis.py,sha256=4eOzxHL_g0TJFhuexNHcZXivxZ7eb5xfb9-efUZ02W
 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=XVvxaRx1h2SjIG57-ninjf0XBSn0wmyHgS1u_mGKlZY,4211
-tonietoolbox-0.1.5.dist-info/licenses/LICENSE.md,sha256=rGoga9ZAgNco9fBapVFpWf6ri7HOBp1KRnt1uIruXMk,35190
-tonietoolbox-0.1.5.dist-info/METADATA,sha256=JVTZeD9xtYoYrip9yw08VA025YjCurSE-lN2lvz_H4Y,8971
-tonietoolbox-0.1.5.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
-tonietoolbox-0.1.5.dist-info/entry_points.txt,sha256=oqpeyBxel7aScg35Xr4gZKnf486S5KW9okqeBwyJxxc,60
-tonietoolbox-0.1.5.dist-info/top_level.txt,sha256=Wkkm-2p7I3ENfS7ZbYtYUB2g-xwHrXVlERHfonsOPuE,13
-tonietoolbox-0.1.5.dist-info/RECORD,,
+TonieToolbox/version_handler.py,sha256=7Zx-pgzAUhz6jMplvNal1wHyxidodVxaNcAV0EMph5k,9778
+tonietoolbox-0.1.7.dist-info/licenses/LICENSE.md,sha256=rGoga9ZAgNco9fBapVFpWf6ri7HOBp1KRnt1uIruXMk,35190
+tonietoolbox-0.1.7.dist-info/METADATA,sha256=7kF7ZRqq_GWhRUrw-z6XlxdfG6kY_nTOtlIUfVFk0DU,8971
+tonietoolbox-0.1.7.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+tonietoolbox-0.1.7.dist-info/entry_points.txt,sha256=oqpeyBxel7aScg35Xr4gZKnf486S5KW9okqeBwyJxxc,60
+tonietoolbox-0.1.7.dist-info/top_level.txt,sha256=Wkkm-2p7I3ENfS7ZbYtYUB2g-xwHrXVlERHfonsOPuE,13
+tonietoolbox-0.1.7.dist-info/RECORD,,