pyappify 1.0.2__tar.gz → 1.0.4__tar.gz

{pyappify-1.0.2 → pyappify-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyappify
-Version: 1.0.2
+Version: 1.0.4
 Summary: My awesome Python application
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License

pyappify-1.0.4/pyappify/__init__.py

@@ -0,0 +1,279 @@
+# pyappify/__init__.py
+import os
+import signal
+import hashlib
+import json
+import logging
+import shutil
+import urllib.request
+import zipfile
+import threading
+import time
+
+app_version = os.environ.get("PYAPPIFY_APP_VERSION")
+app_starting_version = os.environ.get("PYAPPIFY_APP_STARTING_VERSION") or app_version
+update_note = os.environ.get("PYAPPIFY_UPDATE_NOTE")
+app_profile = os.environ.get("PYAPPIFY_APP_PROFILE")
+pyappify_version = os.environ.get("PYAPPIFY_VERSION")
+pyappify_executable = os.environ.get("PYAPPIFY_EXECUTABLE")
+
+pyappify_upgradeable = os.environ.get("PYAPPIFY_UPGRADEABLE") == '1'
+logger = None
+_console_logger = None
+
+try:
+    pid = int(os.environ.get("PYAPPIFY_PID"))
+except (ValueError, TypeError):
+    pid = None
+
+import sys
+
+try:
+    import ctypes
+except ImportError:
+    ctypes = None
+
+
+def _get_logger():
+    global _console_logger
+
+    if logger is not None:
+        return logger
+    if _console_logger is None:
+        _console_logger = logging.getLogger("pyappify")
+        if not _console_logger.handlers:
+            handler = logging.StreamHandler()
+            handler.setFormatter(logging.Formatter("%(levelname)s: %(message)s"))
+            _console_logger.addHandler(handler)
+        _console_logger.setLevel(logging.INFO)
+        _console_logger.propagate = False
+    return _console_logger
+
+
+def minimize_window_by_pid(pid):
+    if not ctypes or sys.platform != "win32":
+        return False
+
+    found_hwnd = []
+    EnumWindowsProc = ctypes.WINFUNCTYPE(ctypes.c_bool, ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int))
+
+    def enum_windows_callback(hwnd, lParam):
+        owner_pid = ctypes.c_ulong()
+        ctypes.windll.user32.GetWindowThreadProcessId(hwnd, ctypes.byref(owner_pid))
+        if owner_pid.value == pid and ctypes.windll.user32.IsWindowVisible(hwnd):
+            found_hwnd.append(hwnd)
+            return False
+        return True
+
+    ctypes.windll.user32.EnumWindows(EnumWindowsProc(enum_windows_callback), 0)
+
+    if found_hwnd:
+        ctypes.windll.user32.ShowWindow(found_hwnd[0], 6)
+        return True
+
+    return False
+
+def kill_pyappify():
+    if pid:
+        log = _get_logger()
+        log.info(f"Attempting to terminate process with PID: {pid}")
+        try:
+            os.kill(pid, signal.SIGTERM)
+            if not _wait_for_process_exit(pid):
+                log.warning(f"Timed out waiting for process with PID {pid} to exit.")
+        except Exception as e:
+            log.error(f"Failed to terminate process with PID {pid}: {e}")
+            pass
+
+
+def _wait_for_process_exit(process_pid, timeout=30):
+    if sys.platform == "win32" and ctypes:
+        synchronize = 0x00100000
+        wait_timeout = 0x00000102
+        wait_failed = 0xFFFFFFFF
+        ctypes.windll.kernel32.OpenProcess.argtypes = (
+            ctypes.c_uint,
+            ctypes.c_bool,
+            ctypes.c_ulong,
+        )
+        ctypes.windll.kernel32.OpenProcess.restype = ctypes.c_void_p
+        ctypes.windll.kernel32.WaitForSingleObject.argtypes = (
+            ctypes.c_void_p,
+            ctypes.c_uint,
+        )
+        ctypes.windll.kernel32.WaitForSingleObject.restype = ctypes.c_uint
+        ctypes.windll.kernel32.CloseHandle.argtypes = (ctypes.c_void_p,)
+        ctypes.windll.kernel32.CloseHandle.restype = ctypes.c_bool
+        handle = ctypes.windll.kernel32.OpenProcess(synchronize, False, process_pid)
+        if handle:
+            try:
+                result = ctypes.windll.kernel32.WaitForSingleObject(
+                    handle, int(timeout * 1000)
+                )
+                if result == wait_failed:
+                    return False
+                return result != wait_timeout
+            finally:
+                ctypes.windll.kernel32.CloseHandle(handle)
+
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        try:
+            os.kill(process_pid, 0)
+        except OSError:
+            return True
+        time.sleep(0.1)
+    return False
+
+
+def _replace_executable(source_path, target_path, timeout=30):
+    deadline = time.monotonic() + timeout
+    last_error = None
+    while True:
+        try:
+            shutil.move(source_path, target_path)
+            return
+        except PermissionError as e:
+            last_error = e
+            if time.monotonic() >= deadline:
+                raise last_error
+            time.sleep(0.25)
+
+
+def hide_pyappify():
+    if pid:
+        log = _get_logger()
+        log.info(f"Attempting to minimize window for process with PID: {pid}")
+        try:
+            minimize_window_by_pid(pid)
+        except Exception as e:
+            log.error(f"Failed to minimize window for process with PID {pid}: {e}")
+            pass
+
+def upgrade(to_version, executable_sha256, executable_zip_urls, stop_event=None):
+    log = _get_logger()
+    if not pyappify_upgradeable or not is_greater_version(to_version, pyappify_version):
+        log.info(f"pyappify no need to upgrade {pyappify_upgradeable} {to_version} {executable_sha256} {executable_zip_urls}")
+        return
+    log.info(
+        f"pyappify start to upgrade {pyappify_upgradeable} {to_version} {executable_sha256} {executable_zip_urls}")
+    def _do_upgrade():
+        tmp_dir = os.path.join(os.getcwd(), "pyappify_tmp")
+        try:
+            os.makedirs(tmp_dir, exist_ok=True)
+            downloaded_zip_path = None
+            for url in executable_zip_urls:
+                try:
+                    log.info(
+                        f"pyappify start to download {url}")
+                    local_zip_path = os.path.join(tmp_dir, os.path.basename(url))
+                    with urllib.request.urlopen(url) as response, open(local_zip_path, 'wb') as out_file:
+                        while True:
+                            if stop_event and stop_event.is_set():
+                                log.info("pyappify Upgrade download cancelled by stop event.")
+                                return
+                            chunk = response.read(8192)
+                            if not chunk:
+                                break
+                            out_file.write(chunk)
+                    downloaded_zip_path = local_zip_path
+                    log.info(
+                        f"pyappify download success {url}")
+                    break
+                except Exception as e:
+                    log.warning(f"pyappify Failed to download from {url}: {e}")
+                    continue
+
+            if not downloaded_zip_path:
+                log.error("pyappify Failed to download upgrade.")
+                return
+
+            with zipfile.ZipFile(downloaded_zip_path, 'r') as zip_ref:
+                zip_ref.extractall(tmp_dir)
+
+            new_executable_name = os.path.basename(pyappify_executable)
+            found_executable_path = None
+            for root, _, files in os.walk(tmp_dir):
+                if new_executable_name in files:
+                    found_executable_path = os.path.join(root, new_executable_name)
+                    break
+
+            if not found_executable_path:
+                log.error("pyappify Executable not found in zip.")
+                return
+
+            sha256_hash = hashlib.sha256()
+            with open(found_executable_path, "rb") as f:
+                for byte_block in iter(lambda: f.read(4096), b""):
+                    sha256_hash.update(byte_block)
+
+            if executable_sha256 and sha256_hash.hexdigest() != executable_sha256:
+                log.error("pyappify SHA256 checksum mismatch.")
+                return
+
+            kill_pyappify()
+            _replace_executable(found_executable_path, pyappify_executable)
+            log.info(f"pyappify Upgrade success")
+        except Exception as e:
+            log.error(f"pyappify Upgrade failed: {e}")
+        finally:
+            if os.path.exists(tmp_dir):
+                shutil.rmtree(tmp_dir)
+
+    thread = threading.Thread(target=_do_upgrade)
+    thread.daemon = True
+    thread.start()
+
+
+def is_app_updated():
+    return is_greater_version(app_version, app_starting_version)
+
+
+def is_app_downgraded():
+    return is_greater_version(app_starting_version, app_version)
+
+
+def is_updated():
+    return is_app_updated()
+
+
+def is_downgrade():
+    return is_app_downgraded()
+
+
+def get_update_notes():
+    if not update_note:
+        return []
+    try:
+        notes = json.loads(update_note)
+    except (TypeError, ValueError):
+        return []
+    if isinstance(notes, list):
+        return [str(note) for note in notes]
+    return []
+
+
+def get_update_note():
+    return get_update_notes()
+
+
+def is_greater_version(version1, version2):
+    """
+    Compares two semantic version strings.
+
+    Args:
+        version1 (str): The first version string.
+        version2 (str): The second version string.
+
+    Returns:
+        bool: True if version1 is strictly greater than version2,
+              False otherwise or if parsing fails.
+    """
+    try:
+        version1 = version1.lstrip('v')
+        version2 = version2.lstrip('v')
+        v1_parts = [int(p) for p in version1.split('.')]
+        v2_parts = [int(p) for p in version2.split('.')]
+        return v1_parts > v2_parts
+    except (ValueError, AttributeError):
+        return False

{pyappify-1.0.2 → pyappify-1.0.4}/pyappify.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyappify
-Version: 1.0.2
+Version: 1.0.4
 Summary: My awesome Python application
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License

{pyappify-1.0.2 → pyappify-1.0.4}/pyappify.egg-info/SOURCES.txt

@@ -7,4 +7,7 @@ pyappify.egg-info/dependency_links.txt
 pyappify.egg-info/entry_points.txt
 pyappify.egg-info/requires.txt
 pyappify.egg-info/top_level.txt
+tests/TestUpdateEnv.py
+tests/TestUpgrade.py
+tests/TestUpgradeOnline.py
 tests/TestVersion.py

{pyappify-1.0.2 → pyappify-1.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyappify"
-version = "1.0.2"
+version = "1.0.4"
 description = "My awesome Python application"
 readme = "README.md"
 requires-python = ">=3.7"
@@ -22,4 +22,4 @@ dev = ["twine", "build"]
 
 [tool.setuptools.packages.find]
 where = ["."]
-include = ["pyappify"]
+include = ["pyappify"]

pyappify-1.0.4/tests/TestUpdateEnv.py

@@ -0,0 +1,94 @@
+import importlib
+import os
+import unittest
+
+import pyappify
+
+
+ENV_KEYS = (
+    "PYAPPIFY_APP_VERSION",
+    "PYAPPIFY_APP_STARTING_VERSION",
+    "PYAPPIFY_UPDATE_NOTE",
+)
+
+
+class TestUpdateEnv(unittest.TestCase):
+    def setUp(self):
+        self._saved_env = {key: os.environ.get(key) for key in ENV_KEYS}
+
+    def tearDown(self):
+        for key, value in self._saved_env.items():
+            if value is None:
+                os.environ.pop(key, None)
+            else:
+                os.environ[key] = value
+        importlib.reload(pyappify)
+
+    def _reload_with_env(self, **env):
+        for key in ENV_KEYS:
+            os.environ.pop(key, None)
+        for key, value in env.items():
+            os.environ[key] = value
+        return importlib.reload(pyappify)
+
+    def test_starting_version_falls_back_to_app_version(self):
+        module = self._reload_with_env(PYAPPIFY_APP_VERSION="1.2.3")
+
+        self.assertEqual("1.2.3", module.app_version)
+        self.assertEqual("1.2.3", module.app_starting_version)
+        self.assertFalse(module.is_app_updated())
+        self.assertFalse(module.is_updated())
+        self.assertFalse(module.is_app_downgraded())
+        self.assertFalse(module.is_downgrade())
+
+    def test_missing_versions_are_not_update_or_downgrade(self):
+        module = self._reload_with_env()
+
+        self.assertIsNone(module.app_version)
+        self.assertIsNone(module.app_starting_version)
+        self.assertFalse(module.is_app_updated())
+        self.assertFalse(module.is_app_downgraded())
+
+    def test_detects_update_and_downgrade(self):
+        module = self._reload_with_env(
+            PYAPPIFY_APP_VERSION="2.0.0",
+            PYAPPIFY_APP_STARTING_VERSION="1.0.0",
+        )
+
+        self.assertTrue(module.is_app_updated())
+        self.assertTrue(module.is_updated())
+        self.assertFalse(module.is_app_downgraded())
+        self.assertFalse(module.is_downgrade())
+
+        module = self._reload_with_env(
+            PYAPPIFY_APP_VERSION="1.0.0",
+            PYAPPIFY_APP_STARTING_VERSION="2.0.0",
+        )
+
+        self.assertFalse(module.is_app_updated())
+        self.assertFalse(module.is_updated())
+        self.assertTrue(module.is_app_downgraded())
+        self.assertTrue(module.is_downgrade())
+
+    def test_returns_update_notes_from_json_array(self):
+        module = self._reload_with_env(
+            PYAPPIFY_UPDATE_NOTE='["first change", "second change"]'
+        )
+
+        self.assertEqual(["first change", "second change"], module.get_update_notes())
+        self.assertEqual(["first change", "second change"], module.get_update_note())
+
+    def test_invalid_or_missing_update_notes_return_empty_list(self):
+        self.assertEqual([], self._reload_with_env().get_update_notes())
+        self.assertEqual(
+            [],
+            self._reload_with_env(PYAPPIFY_UPDATE_NOTE="not json").get_update_notes(),
+        )
+        self.assertEqual(
+            [],
+            self._reload_with_env(PYAPPIFY_UPDATE_NOTE='"single note"').get_update_notes(),
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

pyappify-1.0.4/tests/TestUpgrade.py

@@ -0,0 +1,110 @@
+import hashlib
+import logging
+import os
+import shutil
+import subprocess
+import tempfile
+import time
+import unittest
+from pathlib import Path
+
+import pyappify
+
+
+EXECUTABLE_SHA256 = "50ef2557c193ca1f97c1e699bab3dad35b3966c9e8e8b860fb609bd5fb3861d1"
+
+
+def _sha256(path):
+    digest = hashlib.sha256()
+    with open(path, "rb") as file:
+        for block in iter(lambda: file.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def assert_upgrade_kills_running_executable_and_replaces_it(
+    test_case, zip_url, timeout_seconds
+):
+    source_executable = Path(os.environ["WINDIR"]) / "System32" / "PING.EXE"
+    test_case.assertTrue(source_executable.exists(), "Windows PING.EXE is required")
+
+    old_cwd = os.getcwd()
+    old_upgradeable = pyappify.pyappify_upgradeable
+    old_version = pyappify.pyappify_version
+    old_executable = pyappify.pyappify_executable
+    old_pid = pyappify.pid
+    old_logger = pyappify.logger
+
+    with tempfile.TemporaryDirectory() as temporary_directory:
+        executable = Path(temporary_directory) / "ok-ww.exe"
+        upgrade_temporary_directory = Path(temporary_directory) / "pyappify_tmp"
+        shutil.copy2(source_executable, executable)
+        test_case.assertNotEqual(_sha256(executable), EXECUTABLE_SHA256)
+
+        process = subprocess.Popen(
+            [str(executable), "-t", "127.0.0.1"],
+            cwd=temporary_directory,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        try:
+            time.sleep(1)
+            test_case.assertIsNone(
+                process.poll(), "the current executable exited before upgrade began"
+            )
+
+            pyappify.pyappify_upgradeable = True
+            pyappify.pyappify_version = "v3.3.45"
+            pyappify.pyappify_executable = str(executable)
+            pyappify.pid = process.pid
+            pyappify.logger = logging.getLogger(__name__)
+            os.chdir(temporary_directory)
+
+            pyappify.upgrade("v3.3.46", EXECUTABLE_SHA256, [zip_url])
+
+            deadline = time.monotonic() + timeout_seconds
+            while time.monotonic() < deadline:
+                process_stopped = process.poll() is not None
+                upgraded = (
+                    executable.exists()
+                    and _sha256(executable) == EXECUTABLE_SHA256
+                )
+                update_finished = not upgrade_temporary_directory.exists()
+                if process_stopped and upgraded and update_finished:
+                    break
+                time.sleep(0.1)
+
+            test_case.assertIsNotNone(
+                process.poll(), "upgrade did not stop the old process"
+            )
+            test_case.assertEqual(EXECUTABLE_SHA256, _sha256(executable))
+        finally:
+            os.chdir(old_cwd)
+            pyappify.pyappify_upgradeable = old_upgradeable
+            pyappify.pyappify_version = old_version
+            pyappify.pyappify_executable = old_executable
+            pyappify.pid = old_pid
+            pyappify.logger = old_logger
+            if process.poll() is None:
+                process.terminate()
+                try:
+                    process.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    process.wait(timeout=5)
+
+
+class TestUpgrade(unittest.TestCase):
+    LOCAL_ZIP = Path(__file__).with_name("ok-ww-win32.zip")
+
+    @unittest.skipUnless(os.name == "nt", "executable replacement test is Windows-only")
+    def test_upgrade_from_local_zip_kills_running_executable_and_replaces_it(self):
+        self.assertTrue(self.LOCAL_ZIP.exists(), "tests/ok-ww-win32.zip is required")
+        assert_upgrade_kills_running_executable_and_replaces_it(
+            self,
+            self.LOCAL_ZIP.as_uri(), timeout_seconds=30
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

pyappify-1.0.4/tests/TestUpgradeOnline.py

@@ -0,0 +1,21 @@
+import os
+import unittest
+
+from tests.TestUpgrade import assert_upgrade_kills_running_executable_and_replaces_it
+
+
+class TestUpgradeOnline(unittest.TestCase):
+    ZIP_URL = (
+        "https://github.com/ok-oldking/ok-wuthering-waves/"
+        "releases/download/v3.3.46/ok-ww-win32.zip"
+    )
+
+    @unittest.skipUnless(os.name == "nt", "executable replacement test is Windows-only")
+    def test_upgrade_from_online_zip_kills_running_executable_and_replaces_it(self):
+        assert_upgrade_kills_running_executable_and_replaces_it(
+            self, self.ZIP_URL, timeout_seconds=600
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

pyappify-1.0.2/pyappify/__init__.py

@@ -1,179 +0,0 @@
-# pyappify/__init__.py
-import os
-import signal
-import hashlib
-import shutil
-import urllib.request
-import zipfile
-import threading
-
-app_version = os.environ.get("PYAPPIFY_APP_VERSION")
-app_profile = os.environ.get("PYAPPIFY_APP_PROFILE")
-pyappify_version = os.environ.get("PYAPPIFY_VERSION")
-pyappify_executable = os.environ.get("PYAPPIFY_EXECUTABLE")
-
-pyappify_upgradeable = os.environ.get("PYAPPIFY_UPGRADEABLE") == '1'
-logger = None
-
-try:
-    pid = int(os.environ.get("PYAPPIFY_PID"))
-except (ValueError, TypeError):
-    pid = None
-
-import sys
-
-try:
-    import ctypes
-except ImportError:
-    ctypes = None
-
-
-def minimize_window_by_pid(pid):
-    if not ctypes or sys.platform != "win32":
-        return False
-
-    found_hwnd = []
-    EnumWindowsProc = ctypes.WINFUNCTYPE(ctypes.c_bool, ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int))
-
-    def enum_windows_callback(hwnd, lParam):
-        owner_pid = ctypes.c_ulong()
-        ctypes.windll.user32.GetWindowThreadProcessId(hwnd, ctypes.byref(owner_pid))
-        if owner_pid.value == pid and ctypes.windll.user32.IsWindowVisible(hwnd):
-            found_hwnd.append(hwnd)
-            return False
-        return True
-
-    ctypes.windll.user32.EnumWindows(EnumWindowsProc(enum_windows_callback), 0)
-
-    if found_hwnd:
-        ctypes.windll.user32.ShowWindow(found_hwnd[0], 6)
-        return True
-
-    return False
-
-def kill_pyappify():
-    if pid:
-        if logger:
-            logger.info(f"Attempting to terminate process with PID: {pid}")
-        try:
-            os.kill(pid, signal.SIGTERM)
-        except Exception as e:
-            if logger:
-                logger.error(f"Failed to terminate process with PID {pid}: {e}")
-            pass
-
-def hide_pyappify():
-    if pid:
-        if logger:
-            logger.info(f"Attempting to minimize window for process with PID: {pid}")
-        try:
-            minimize_window_by_pid(pid)
-        except Exception as e:
-            if logger:
-                logger.error(f"Failed to minimize window for process with PID {pid}: {e}")
-            pass
-
-def upgrade(to_version, executable_sha256, executable_zip_urls, stop_event=None):
-    if not pyappify_upgradeable or not is_greater_version(to_version, pyappify_version):
-        if logger:
-            logger.info(f"pyappify no need to upgrade {pyappify_upgradeable} {to_version} {executable_sha256} {executable_zip_urls}")
-        return
-    if logger:
-        logger.info(
-            f"pyappify start to upgrade {pyappify_upgradeable} {to_version} {executable_sha256} {executable_zip_urls}")
-    def _do_upgrade():
-        tmp_dir = os.path.join(os.getcwd(), "pyappify_tmp")
-        try:
-            os.makedirs(tmp_dir, exist_ok=True)
-            downloaded_zip_path = None
-            for url in executable_zip_urls:
-                try:
-                    if logger:
-                        logger.info(
-                            f"pyappify start to download {url}")
-                    local_zip_path = os.path.join(tmp_dir, os.path.basename(url))
-                    with urllib.request.urlopen(url) as response, open(local_zip_path, 'wb') as out_file:
-                        while True:
-                            if stop_event and stop_event.is_set():
-                                if logger:
-                                    logger.info("pyappify Upgrade download cancelled by stop event.")
-                                return
-                            chunk = response.read(8192)
-                            if not chunk:
-                                break
-                            out_file.write(chunk)
-                    downloaded_zip_path = local_zip_path
-                    if logger:
-                        logger.info(
-                            f"pyappify download success {url}")
-                    break
-                except Exception as e:
-                    if logger:
-                        logger.warning(f"pyappify Failed to download from {url}: {e}")
-                    continue
-
-            if not downloaded_zip_path:
-                if logger:
-                    logger.error("pyappify Failed to download upgrade.")
-                return
-
-            with zipfile.ZipFile(downloaded_zip_path, 'r') as zip_ref:
-                zip_ref.extractall(tmp_dir)
-
-            new_executable_name = os.path.basename(pyappify_executable)
-            found_executable_path = None
-            for root, _, files in os.walk(tmp_dir):
-                if new_executable_name in files:
-                    found_executable_path = os.path.join(root, new_executable_name)
-                    break
-
-            if not found_executable_path:
-                if logger:
-                    logger.error("pyappify Executable not found in zip.")
-                return
-
-            sha256_hash = hashlib.sha256()
-            with open(found_executable_path, "rb") as f:
-                for byte_block in iter(lambda: f.read(4096), b""):
-                    sha256_hash.update(byte_block)
-
-            if executable_sha256 and sha256_hash.hexdigest() != executable_sha256:
-                if logger:
-                    logger.error("pyappify SHA256 checksum mismatch.")
-                return
-
-            kill_pyappify()
-            shutil.move(found_executable_path, pyappify_executable)
-            if logger:
-                logger.info(f"pyappify Upgrade success")
-        except Exception as e:
-            if logger:
-                logger.error(f"pyappify Upgrade failed: {e}")
-        finally:
-            if os.path.exists(tmp_dir):
-                shutil.rmtree(tmp_dir)
-
-    thread = threading.Thread(target=_do_upgrade)
-    thread.daemon = True
-    thread.start()
-
-def is_greater_version(version1, version2):
-    """
-    Compares two semantic version strings.
-
-    Args:
-        version1 (str): The first version string.
-        version2 (str): The second version string.
-
-    Returns:
-        bool: True if version1 is strictly greater than version2,
-              False otherwise or if parsing fails.
-    """
-    try:
-        version1 = version1.lstrip('v')
-        version2 = version2.lstrip('v')
-        v1_parts = [int(p) for p in version1.split('.')]
-        v2_parts = [int(p) for p in version2.split('.')]
-        return v1_parts > v2_parts
-    except (ValueError, AttributeError):
-        return False