pyappify 1.0.6__tar.gz → 1.0.8__tar.gz

{pyappify-1.0.6 → pyappify-1.0.8}/PKG-INFO

@@ -1,12 +1,12 @@
-Metadata-Version: 2.4
-Name: pyappify
-Version: 1.0.6
-Summary: My awesome Python application
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-Provides-Extra: dev
-Requires-Dist: twine; extra == "dev"
-Requires-Dist: build; extra == "dev"
+Metadata-Version: 2.4
+Name: pyappify
+Version: 1.0.8
+Summary: My awesome Python application
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: build; extra == "dev"

{pyappify-1.0.6 → pyappify-1.0.8}/pyappify/__init__.py

@@ -10,6 +10,10 @@ import urllib.request
 import zipfile
 import threading
 import time
+import tempfile
+import uuid
+import sys
+from pathlib import Path
 
 from .app_config import (
     UPDATE_METHOD_AUTO,
@@ -35,7 +39,6 @@ update_note = os.environ.get("PYAPPIFY_UPDATE_NOTE")
 app_profile = os.environ.get("PYAPPIFY_APP_PROFILE")
 app_locale = os.environ.get("PYAPPIFY_LOCALE") or "en"
 pyappify_version = os.environ.get("PYAPPIFY_VERSION")
-pyappify_executable = os.environ.get("PYAPPIFY_EXECUTABLE")
 app_json_path = configure_app_json(os.environ.get("PYAPPIFY_APP_JSON_PATH"))
 
 pyappify_upgradeable = os.environ.get("PYAPPIFY_UPGRADEABLE") == '1'
@@ -47,14 +50,41 @@ try:
 except (ValueError, TypeError):
     pid = None
 
-import sys
-
 try:
     import ctypes
 except ImportError:
     ctypes = None
 
 
+def find_pyappify_executable(start_dir=None, environ=None):
+    """Find the launcher configured by PyAppify or in a parent directory."""
+    environ = os.environ if environ is None else environ
+    configured = environ.get("PYAPPIFY_EXECUTABLE")
+    if configured:
+        configured_path = Path(configured).expanduser()
+        if configured_path.is_file():
+            return str(configured_path.resolve())
+
+    current = Path(start_dir or os.getcwd()).expanduser()
+    if current.is_file():
+        current = current.parent
+    try:
+        current = current.resolve()
+    except OSError:
+        current = current.absolute()
+
+    executable_names = ("pyappify.exe", "pyappify")
+    for directory in (current,) + tuple(current.parents):
+        for executable_name in executable_names:
+            candidate = directory / executable_name
+            if candidate.is_file():
+                return str(candidate.resolve())
+    return None
+
+
+pyappify_executable = find_pyappify_executable()
+
+
 def _get_logger():
     global _console_logger
 
@@ -209,16 +239,18 @@ def show_pyappify(args=None, cwd=None, env=None):
     global pid
 
     log = _get_logger()
-    if _is_process_running(pid):
+    already_running = _is_process_running(pid)
+    if already_running and not args:
         log.info(f"PyAppify is already running with PID: {pid}")
         bring_window_to_front_by_pid(pid)
         return pid
 
-    if not pyappify_executable:
-        log.error("PYAPPIFY_EXECUTABLE is not configured.")
+    executable = pyappify_executable or find_pyappify_executable()
+    if not executable:
+        log.error("PyAppify executable was not found.")
         return None
 
-    command = [pyappify_executable]
+    command = [executable]
     if args:
         if isinstance(args, str):
             command.append(args)
@@ -228,15 +260,208 @@ def show_pyappify(args=None, cwd=None, env=None):
     try:
         process = subprocess.Popen(
             command,
-            cwd=cwd or os.path.dirname(pyappify_executable) or None,
+            cwd=cwd or os.path.dirname(executable) or None,
             env=env,
         )
-        pid = process.pid
+        if not already_running:
+            pid = process.pid
         return pid
     except Exception as e:
-        log.error(f"Failed to start PyAppify executable {pyappify_executable}: {e}")
+        log.error(f"Failed to start PyAppify executable {executable}: {e}")
+        return None
+
+
+def _require_pyappify_executable():
+    global pyappify_executable
+
+    if pyappify_executable and os.path.isfile(pyappify_executable):
+        return os.path.abspath(pyappify_executable)
+    pyappify_executable = find_pyappify_executable()
+    if not pyappify_executable:
+        raise FileNotFoundError(
+            "PyAppify executable was not found. Set PYAPPIFY_EXECUTABLE to an "
+            "existing executable or place pyappify.exe in this directory or a parent directory."
+        )
+    return pyappify_executable
+
+
+def _run_launcher_api(arguments, timeout=300):
+    executable = _require_pyappify_executable()
+    response_path = os.path.join(
+        tempfile.gettempdir(),
+        "pyappify-response-{}-{}.json".format(os.getpid(), uuid.uuid4().hex),
+    )
+    command = list(arguments) + ["--response-file", response_path]
+    try:
+        subprocess.Popen(
+            [executable] + command,
+            cwd=os.path.dirname(executable) or None,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+    except OSError as error:
+        raise RuntimeError(
+            "Failed to execute PyAppify at '{}': {}".format(executable, error)
+        )
+
+    deadline = time.monotonic() + timeout
+    try:
+        while time.monotonic() < deadline:
+            try:
+                with open(response_path, "r", encoding="utf-8") as response_file:
+                    response = json.load(response_file)
+                if isinstance(response, dict) and response.get("error"):
+                    raise RuntimeError(response["error"])
+                return response
+            except FileNotFoundError:
+                pass
+            except json.JSONDecodeError:
+                # The running launcher may still be completing the response write.
+                pass
+            time.sleep(0.05)
+    finally:
+        try:
+            os.remove(response_path)
+        except FileNotFoundError:
+            pass
+
+    raise TimeoutError("Timed out waiting for a response from PyAppify")
+
+
+def get_version_list(number_versions=10, release_only=True, timeout=120):
+    """Return the latest versions and each version's notes since its predecessor."""
+    if isinstance(number_versions, bool) or not isinstance(number_versions, int):
+        raise TypeError("number_versions must be an integer")
+    if number_versions <= 0:
+        raise ValueError("number_versions must be greater than zero")
+    if not isinstance(release_only, bool):
+        raise TypeError("release_only must be a boolean")
+
+    if "PYAPPIFY_PYTHON_TEST" in os.environ:
+        time.sleep(5)
+        return _get_mock_version_list(number_versions)
+
+    response = _run_launcher_api(
+        [
+            "--get-version-list",
+            "--number-versions",
+            str(number_versions),
+            "--release-only",
+            str(release_only).lower(),
+        ],
+        timeout=timeout,
+    )
+    if not isinstance(response, list):
+        raise RuntimeError("PyAppify returned an invalid version-list response")
+    return response
+
+
+def get_versions(number_versions=10, release_only=True, timeout=120):
+    """Alias for get_version_list."""
+    return get_version_list(number_versions, release_only, timeout)
+
+
+def calculate_update_notes(update_notes, current_version, target_version):
+    """Return descending notes without including versions newer than the target."""
+    if not isinstance(update_notes, list):
+        raise TypeError("update_notes must be a list")
+
+    versions = [
+        item for item in update_notes
+        if isinstance(item, dict) and item.get("version")
+    ]
+
+    def normalize(version):
+        return str(version or "").lstrip("v")
+
+    def find_index(version):
+        normalized = normalize(version)
+        return next(
+            (index for index, item in enumerate(versions)
+             if normalize(item["version"]) == normalized),
+            None,
+        )
+
+    target_index = find_index(target_version)
+    if target_index is None:
+        return []
+
+    current_index = find_index(current_version)
+    if current_index is None:
+        selected_versions = versions[target_index:]
+    else:
+        first = min(current_index, target_index)
+        last = max(current_index, target_index)
+        selected_versions = versions[first:last + 1]
+
+    notes = []
+    for item in selected_versions:
+        raw_notes = item.get("update_note") or []
+        notes.extend(raw_notes if isinstance(raw_notes, list) else [raw_notes])
+    return [str(note) for note in notes]
+
+
+def update_to_version(version, timeout=300):
+    """Start PyAppify (or forward to it) and update the managed app to version."""
+    if not isinstance(version, str) or not version.strip():
+        raise ValueError("version must be a non-empty string")
+    if "PYAPPIFY_PYTHON_TEST" in os.environ:
+        return {"updated": True, "version": version, "mocked": True}
+    response = _run_launcher_api(
+        ["--update-to-version", version],
+        timeout=timeout,
+    )
+    if not isinstance(response, dict) or not response.get("updated"):
+        raise RuntimeError("PyAppify returned an invalid update response")
+    return response
+
+
+def _get_mock_version_list(number_versions):
+    """Return deterministic launcher data for UI and integration tests."""
+    current = app_version or "v1.0.0"
+    prefix = "v" if current.startswith("v") else ""
+    try:
+        parts = [int(part) for part in current.lstrip("v").split(".")]
+    except (TypeError, ValueError):
+        parts = [1, 0, 0]
+        prefix = "v"
+    parts = (parts + [0, 0, 0])[:3]
+
+    def previous_parts(version_parts):
+        major, minor, patch = version_parts
+        if patch > 0:
+            return [major, minor, patch - 1]
+        if minor > 0:
+            return [major, minor - 1, 9]
+        if major > 0:
+            return [major - 1, 9, 9]
         return None
 
+    version_parts = [[100, 1, 1], parts[:2] + [parts[2] + 2], parts[:2] + [parts[2] + 1], parts]
+    previous = previous_parts(parts)
+    while len(version_parts) < number_versions:
+        if previous is not None:
+            version_parts.append(previous)
+            previous = previous_parts(previous)
+        else:
+            break
+
+    versions = []
+    for item_parts in version_parts:
+        item_prefix = "v" if item_parts == [100, 1, 1] else prefix
+        version = item_prefix + ".".join(str(part) for part in item_parts)
+        previous_item = previous_parts(item_parts)
+        previous = item_prefix + ".".join(str(part) for part in previous_item) if previous_item else version
+        versions.append({
+            "version": version,
+            "previous_version": previous,
+            "update_note": [
+                f"Mock update note for {version}",
+                f"Changes since {previous}",
+            ],
+        })
+    return versions[:number_versions]
+
 
 def _replace_executable(source_path, target_path, timeout=30):
     deadline = time.monotonic() + timeout

pyappify-1.0.8/pyappify/main.py

@@ -0,0 +1,2 @@
+def main():
+    print("PyAppify Hello world")

{pyappify-1.0.6 → pyappify-1.0.8}/pyappify.egg-info/PKG-INFO

@@ -1,12 +1,12 @@
-Metadata-Version: 2.4
-Name: pyappify
-Version: 1.0.6
-Summary: My awesome Python application
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-Provides-Extra: dev
-Requires-Dist: twine; extra == "dev"
-Requires-Dist: build; extra == "dev"
+Metadata-Version: 2.4
+Name: pyappify
+Version: 1.0.8
+Summary: My awesome Python application
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: build; extra == "dev"

{pyappify-1.0.6 → pyappify-1.0.8}/pyappify.egg-info/SOURCES.txt

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

{pyappify-1.0.6 → pyappify-1.0.8}/pyproject.toml

@@ -1,25 +1,25 @@
-[build-system]
-requires = ["setuptools>=61.0"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "pyappify"
-version = "1.0.6"
-description = "My awesome Python application"
-readme = "README.md"
-requires-python = ">=3.7"
-classifiers = [
-    "Programming Language :: Python :: 3",
-    "License :: OSI Approved :: MIT License",
-    "Operating System :: OS Independent",
-]
-
-[project.scripts]
-pyappify = "pyappify.main:main"
-
-[project.optional-dependencies]
-dev = ["twine", "build"]
-
-[tool.setuptools.packages.find]
-where = ["."]
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyappify"
+version = "1.0.8"
+description = "My awesome Python application"
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.scripts]
+pyappify = "pyappify.main:main"
+
+[project.optional-dependencies]
+dev = ["twine", "build"]
+
+[tool.setuptools.packages.find]
+where = ["."]
 include = ["pyappify"]

{pyappify-1.0.6 → pyappify-1.0.8}/setup.cfg

@@ -1,4 +1,4 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyappify-1.0.6/pyappify/main.py

@@ -1,2 +0,0 @@
-def main():
-    print("PyAppify Hello world")

pyappify-1.0.6/tests/TestAppConfig.py

@@ -1,89 +0,0 @@
-import json
-import os
-import tempfile
-import threading
-import unittest
-
-from pyappify.app_config import (
-    AppConfigAPI,
-    UPDATE_METHOD_AUTO_PRE_RELEASE,
-    UPDATE_METHOD_MANUAL,
-)
-
-
-class TestAppConfig(unittest.TestCase):
-    def setUp(self):
-        self.temporary_directory = tempfile.TemporaryDirectory()
-        self.config_path = os.path.join(self.temporary_directory.name, "app.json")
-        self._write_document(
-            {
-                "name": "example",
-                "installed": True,
-                "auto_start": False,
-                "update_method": "AUTO_UPDATE",
-            }
-        )
-        self.api = AppConfigAPI(self.config_path)
-
-    def tearDown(self):
-        self.api.stop_watcher()
-        self.temporary_directory.cleanup()
-
-    def _write_document(self, document):
-        with open(self.config_path, "w", encoding="utf-8") as config_file:
-            json.dump(document, config_file)
-
-    def test_reads_and_updates_preferences_without_losing_other_fields(self):
-        self.assertEqual(
-            {"auto_start": False, "update_method": "AUTO_UPDATE"},
-            self.api.get(),
-        )
-
-        self.api.update(
-            auto_start=True,
-            update_method=UPDATE_METHOD_AUTO_PRE_RELEASE,
-        )
-
-        with open(self.config_path, "r", encoding="utf-8") as config_file:
-            saved = json.load(config_file)
-        self.assertEqual("example", saved["name"])
-        self.assertTrue(saved["installed"])
-        self.assertTrue(saved["auto_start"])
-        self.assertEqual(UPDATE_METHOD_AUTO_PRE_RELEASE, saved["update_method"])
-
-    def test_rejects_invalid_preferences(self):
-        with self.assertRaises(ValueError):
-            self.api.update(auto_start="yes")
-        with self.assertRaises(ValueError):
-            self.api.update(update_method="UNKNOWN")
-        with self.assertRaises(ValueError):
-            self.api.update(update_method=[])
-
-    def test_watcher_notifies_when_an_external_writer_changes_the_file(self):
-        changed = threading.Event()
-        received = []
-
-        def listener(config):
-            received.append(config)
-            changed.set()
-
-        self.api.add_listener(listener)
-        self.api.configure(self.config_path, watch=True, watch_interval=0.05)
-        self._write_document(
-            {
-                "name": "example",
-                "installed": True,
-                "auto_start": True,
-                "update_method": UPDATE_METHOD_MANUAL,
-            }
-        )
-
-        self.assertTrue(changed.wait(2), "watcher did not observe app.json change")
-        self.assertEqual(
-            {"auto_start": True, "update_method": UPDATE_METHOD_MANUAL},
-            received[-1],
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()

pyappify-1.0.6/tests/TestProcessControls.py

@@ -1,77 +0,0 @@
-import os
-import signal
-import unittest
-from unittest import mock
-
-import pyappify
-
-
-class TestProcessControls(unittest.TestCase):
-    def setUp(self):
-        self.old_pid = pyappify.pid
-        self.old_executable = pyappify.pyappify_executable
-        self.old_logger = pyappify.logger
-        pyappify.logger = mock.Mock()
-
-    def tearDown(self):
-        pyappify.pid = self.old_pid
-        pyappify.pyappify_executable = self.old_executable
-        pyappify.logger = self.old_logger
-
-    def test_kill_pyappify_exe_terminates_configured_pid(self):
-        pyappify.pid = 1234
-
-        with mock.patch.object(pyappify.os, "kill") as kill, mock.patch.object(
-            pyappify, "_wait_for_process_exit", return_value=True
-        ) as wait:
-            self.assertTrue(pyappify.kill_pyappify_exe(timeout=5))
-
-        kill.assert_called_once_with(1234, signal.SIGTERM)
-        wait.assert_called_once_with(1234, 5)
-
-    def test_show_pyappify_brings_existing_window_to_front(self):
-        pyappify.pid = 1234
-
-        with mock.patch.object(
-            pyappify, "_is_process_running", return_value=True
-        ) as is_running, mock.patch.object(
-            pyappify, "bring_window_to_front_by_pid", return_value=True
-        ) as bring_to_front, mock.patch.object(pyappify.subprocess, "Popen") as popen:
-            self.assertEqual(1234, pyappify.show_pyappify())
-
-        is_running.assert_called_once_with(1234)
-        bring_to_front.assert_called_once_with(1234)
-        popen.assert_not_called()
-
-    def test_show_pyappify_starts_executable_when_not_running(self):
-        executable = os.path.abspath("pyappify.exe")
-        pyappify.pid = 1234
-        pyappify.pyappify_executable = executable
-        process = mock.Mock()
-        process.pid = 5678
-
-        with mock.patch.object(
-            pyappify, "_is_process_running", return_value=False
-        ), mock.patch.object(pyappify.subprocess, "Popen", return_value=process) as popen:
-            self.assertEqual(
-                5678,
-                pyappify.show_pyappify(args=["--profile", "dev"]),
-            )
-
-        popen.assert_called_once_with(
-            [executable, "--profile", "dev"],
-            cwd=os.path.dirname(executable),
-            env=None,
-        )
-        self.assertEqual(5678, pyappify.pid)
-
-    def test_show_pyappify_returns_none_without_executable(self):
-        pyappify.pid = None
-        pyappify.pyappify_executable = None
-
-        with mock.patch.object(pyappify, "_is_process_running", return_value=False):
-            self.assertIsNone(pyappify.show_pyappify())
-
-
-if __name__ == "__main__":
-    unittest.main()

pyappify-1.0.6/tests/TestUpdateEnv.py

@@ -1,100 +0,0 @@
-import importlib
-import os
-import unittest
-
-import pyappify
-
-
-ENV_KEYS = (
-    "PYAPPIFY_APP_VERSION",
-    "PYAPPIFY_APP_STARTING_VERSION",
-    "PYAPPIFY_UPDATE_NOTE",
-    "PYAPPIFY_APP_JSON_PATH",
-    "PYAPPIFY_LOCALE",
-)
-
-
-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(),
-        )
-
-    def test_reads_locale_with_english_fallback(self):
-        self.assertEqual("zh-CN", self._reload_with_env(PYAPPIFY_LOCALE="zh-CN").get_locale())
-        self.assertEqual("en", self._reload_with_env().get_locale())
-
-
-if __name__ == "__main__":
-    unittest.main()

pyappify-1.0.6/tests/TestUpgrade.py

@@ -1,110 +0,0 @@
-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.6/tests/TestUpgradeOnline.py

@@ -1,21 +0,0 @@
-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.6/tests/TestVersion.py

@@ -1,33 +0,0 @@
-# filename: test_pyappify.is_greater_version.py
-import unittest
-import pyappify
-
-class TestIsGreaterVersion(unittest.TestCase):
-
-    def test_version1_is_greater(self):
-        self.assertTrue(pyappify.is_greater_version("2.0.0", "1.9.9"))
-        self.assertTrue(pyappify.is_greater_version("1.2.0", "v1.1.9"))
-        self.assertTrue(pyappify.is_greater_version("v1.1.2", "1.1.1"))
-        self.assertTrue(pyappify.is_greater_version("1.1.0", "1.1"))
-        self.assertTrue(pyappify.is_greater_version("v10.0.0", "9.0.0"))
-
-    def test_version1_is_not_greater(self):
-        self.assertFalse(pyappify.is_greater_version("v1.0.0", "2.0.0"))
-        self.assertFalse(pyappify.is_greater_version("1.1.0", "v1.2.0"))
-        self.assertFalse(pyappify.is_greater_version("1.1.1", "1.1.2"))
-        self.assertFalse(pyappify.is_greater_version("1.1", "1.1.0"))
-
-    def test_versions_are_equal(self):
-        self.assertFalse(pyappify.is_greater_version("qwer", "1.0.0"))
-        self.assertFalse(pyappify.is_greater_version("1.2.3", "1.2.3"))
-
-    def test_invalid_or_edge_cases(self):
-        self.assertFalse(pyappify.is_greater_version(None, "1.0.0"))
-        self.assertFalse(pyappify.is_greater_version("1.0.0", None))
-        self.assertFalse(pyappify.is_greater_version(None, None))
-        self.assertFalse(pyappify.is_greater_version("v1.a.0", "1.0.0"))
-        self.assertFalse(pyappify.is_greater_version("1.0.0", "invalid"))
-        self.assertFalse(pyappify.is_greater_version("", "1.0.0"))
-
-if __name__ == '__main__':
-    unittest.main(argv=['first-arg-is-ignored'], exit=False)