pyappify 1.0.4__tar.gz → 1.0.6__tar.gz

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

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

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

@@ -1,35 +1,56 @@
-# pyappify/__init__.py
+# pyappify/__init__.py
 import os
 import signal
 import hashlib
 import json
 import logging
 import shutil
+import subprocess
 import urllib.request
 import zipfile
 import threading
 import time
 
+from .app_config import (
+    UPDATE_METHOD_AUTO,
+    UPDATE_METHOD_AUTO_PRE_RELEASE,
+    UPDATE_METHOD_MANUAL,
+    add_app_config_listener,
+    configure_app_json,
+    get_app_config,
+    get_app_json_path,
+    get_auto_start,
+    get_update_method,
+    remove_app_config_listener,
+    set_auto_start,
+    set_update_method,
+    start_app_config_watcher,
+    stop_app_config_watcher,
+    update_app_config,
+)
+
 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")
+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'
 logger = None
 _console_logger = None
-
-try:
-    pid = int(os.environ.get("PYAPPIFY_PID"))
-except (ValueError, TypeError):
-    pid = None
-
-import sys
-
-try:
-    import ctypes
+
+try:
+    pid = int(os.environ.get("PYAPPIFY_PID"))
+except (ValueError, TypeError):
+    pid = None
+
+import sys
+
+try:
+    import ctypes
 except ImportError:
     ctypes = None
 
@@ -50,40 +71,63 @@ def _get_logger():
     return _console_logger
 
 
+def _find_visible_window_by_pid(process_pid):
+    if not ctypes or sys.platform != "win32":
+        return None
+
+    found_hwnd = []
+    EnumWindowsProc = ctypes.WINFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_void_p)
+
+    def enum_windows_callback(hwnd, lParam):
+        owner_pid = ctypes.c_ulong()
+        ctypes.windll.user32.GetWindowThreadProcessId(hwnd, ctypes.byref(owner_pid))
+        if owner_pid.value == process_pid and ctypes.windll.user32.IsWindowVisible(hwnd):
+            found_hwnd.append(hwnd)
+            return False
+        return True
+
+    ctypes.windll.user32.EnumWindows(EnumWindowsProc(enum_windows_callback), 0)
+
+    return found_hwnd[0] if found_hwnd else 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():
+    hwnd = _find_visible_window_by_pid(pid)
+    if hwnd:
+        ctypes.windll.user32.ShowWindow(hwnd, 6)
+        return True
+
+    return False
+
+
+def bring_window_to_front_by_pid(pid):
+    hwnd = _find_visible_window_by_pid(pid)
+    if hwnd:
+        ctypes.windll.user32.ShowWindow(hwnd, 9)
+        return bool(ctypes.windll.user32.SetForegroundWindow(hwnd))
+
+    return False
+
+
+def kill_pyappify(timeout=30):
     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):
+            if not _wait_for_process_exit(pid, timeout):
                 log.warning(f"Timed out waiting for process with PID {pid} to exit.")
+                return False
+            log.info(f'_wait_for_process_exit success {pid}')
+            return True
         except Exception as e:
             log.error(f"Failed to terminate process with PID {pid}: {e}")
-            pass
+            return False
+    return False
+
+
+def kill_pyappify_exe(timeout=30):
+    return kill_pyappify(timeout)
 
 
 def _wait_for_process_exit(process_pid, timeout=30):
@@ -126,6 +170,74 @@ def _wait_for_process_exit(process_pid, timeout=30):
     return False
 
 
+def _is_process_running(process_pid):
+    if not process_pid:
+        return False
+
+    if sys.platform == "win32" and ctypes:
+        synchronize = 0x00100000
+        wait_timeout = 0x00000102
+        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 not handle:
+            return False
+        try:
+            return ctypes.windll.kernel32.WaitForSingleObject(handle, 0) == wait_timeout
+        finally:
+            ctypes.windll.kernel32.CloseHandle(handle)
+
+    try:
+        os.kill(process_pid, 0)
+    except OSError:
+        return False
+    return True
+
+
+def show_pyappify(args=None, cwd=None, env=None):
+    global pid
+
+    log = _get_logger()
+    if _is_process_running(pid):
+        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.")
+        return None
+
+    command = [pyappify_executable]
+    if args:
+        if isinstance(args, str):
+            command.append(args)
+        else:
+            command.extend(args)
+
+    try:
+        process = subprocess.Popen(
+            command,
+            cwd=cwd or os.path.dirname(pyappify_executable) or None,
+            env=env,
+        )
+        pid = process.pid
+        return pid
+    except Exception as e:
+        log.error(f"Failed to start PyAppify executable {pyappify_executable}: {e}")
+        return None
+
+
 def _replace_executable(source_path, target_path, timeout=30):
     deadline = time.monotonic() + timeout
     last_error = None
@@ -160,7 +272,7 @@ def upgrade(to_version, executable_sha256, executable_zip_urls, stop_event=None)
     def _do_upgrade():
         tmp_dir = os.path.join(os.getcwd(), "pyappify_tmp")
         try:
-            os.makedirs(tmp_dir, exist_ok=True)
+            os.makedirs(tmp_dir, exist_ok=True)
             downloaded_zip_path = None
             for url in executable_zip_urls:
                 try:
@@ -172,10 +284,10 @@ def upgrade(to_version, executable_sha256, executable_zip_urls, stop_event=None)
                             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)
+                            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}")
@@ -187,26 +299,26 @@ def upgrade(to_version, executable_sha256, executable_zip_urls, stop_event=None)
             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
-
+
+            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)
-
+
+            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
@@ -216,10 +328,10 @@ def upgrade(to_version, executable_sha256, executable_zip_urls, stop_event=None)
             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)
-
+        finally:
+            if os.path.exists(tmp_dir):
+                shutil.rmtree(tmp_dir)
+
     thread = threading.Thread(target=_do_upgrade)
     thread.daemon = True
     thread.start()
@@ -257,23 +369,27 @@ def get_update_note():
     return get_update_notes()
 
 
+def get_locale():
+    return app_locale
+
+
 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):
+
+    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.6/pyappify/app_config.py

@@ -0,0 +1,244 @@
+import atexit
+import json
+import logging
+import os
+import tempfile
+import threading
+
+
+UPDATE_METHOD_MANUAL = "MANUAL_UPDATE"
+UPDATE_METHOD_AUTO = "AUTO_UPDATE"
+UPDATE_METHOD_AUTO_PRE_RELEASE = "AUTO_UPDATE_PRE_RELEASE"
+UPDATE_METHODS = {
+    UPDATE_METHOD_MANUAL,
+    UPDATE_METHOD_AUTO,
+    UPDATE_METHOD_AUTO_PRE_RELEASE,
+}
+
+_UNSET = object()
+_LOG = logging.getLogger("pyappify.app_config")
+
+
+class AppConfigAPI:
+    """Thread-safe access to the app preferences stored by PyAppify."""
+
+    def __init__(self, path=None, watch=False, watch_interval=0.5):
+        self._lock = threading.RLock()
+        self._path = None
+        self._preferences = {
+            "auto_start": False,
+            "update_method": UPDATE_METHOD_AUTO,
+        }
+        self._listeners = set()
+        self._watch_interval = watch_interval
+        self._watch_stop = None
+        self._watch_thread = None
+        if path:
+            self.configure(path, watch=watch, watch_interval=watch_interval)
+
+    @property
+    def path(self):
+        with self._lock:
+            return self._path
+
+    def configure(self, path, watch=True, watch_interval=0.5):
+        self.stop_watcher()
+        normalized_path = os.path.abspath(os.path.expanduser(path)) if path else None
+        with self._lock:
+            self._path = normalized_path
+            self._watch_interval = watch_interval
+            self._preferences = {
+                "auto_start": False,
+                "update_method": UPDATE_METHOD_AUTO,
+            }
+        if normalized_path:
+            self.refresh(notify=False)
+            if watch:
+                self.start_watcher()
+        return normalized_path
+
+    def _read_document(self):
+        path = self.path
+        if not path:
+            raise RuntimeError("PYAPPIFY_APP_JSON_PATH is not configured")
+        with open(path, "r", encoding="utf-8") as config_file:
+            document = json.load(config_file)
+        if not isinstance(document, dict):
+            raise ValueError("app.json must contain a JSON object")
+        return document
+
+    @staticmethod
+    def _preferences_from_document(document):
+        auto_start = document.get("auto_start", False)
+        update_method = document.get("update_method", UPDATE_METHOD_AUTO)
+        if not isinstance(auto_start, bool):
+            raise ValueError("auto_start must be a boolean")
+        if not isinstance(update_method, str) or update_method not in UPDATE_METHODS:
+            raise ValueError("Unsupported update_method: {}".format(update_method))
+        return {
+            "auto_start": auto_start,
+            "update_method": update_method,
+        }
+
+    def _store_preferences(self, preferences, notify=True):
+        with self._lock:
+            changed = preferences != self._preferences
+            self._preferences = dict(preferences)
+            listeners = tuple(self._listeners) if changed and notify else ()
+            result = dict(self._preferences)
+        for listener in listeners:
+            try:
+                listener(dict(result))
+            except Exception:
+                _LOG.exception("An app config listener failed")
+        return result
+
+    def refresh(self, notify=True):
+        with self._lock:
+            preferences = self._preferences_from_document(self._read_document())
+        return self._store_preferences(preferences, notify=notify)
+
+    def get(self, refresh=True):
+        if refresh and self.path:
+            return self.refresh()
+        with self._lock:
+            return dict(self._preferences)
+
+    def update(self, auto_start=_UNSET, update_method=_UNSET):
+        if auto_start is not _UNSET and not isinstance(auto_start, bool):
+            raise ValueError("auto_start must be a boolean")
+        if update_method is not _UNSET and (
+            not isinstance(update_method, str) or update_method not in UPDATE_METHODS
+        ):
+            raise ValueError("Unsupported update_method: {}".format(update_method))
+
+        with self._lock:
+            document = self._read_document()
+            if auto_start is not _UNSET:
+                document["auto_start"] = auto_start
+            if update_method is not _UNSET:
+                document["update_method"] = update_method
+            preferences = self._preferences_from_document(document)
+            config_dir = os.path.dirname(self._path) or os.curdir
+            temporary_path = None
+            try:
+                with tempfile.NamedTemporaryFile(
+                    mode="w",
+                    encoding="utf-8",
+                    dir=config_dir,
+                    prefix=".app-json-",
+                    suffix=".tmp",
+                    delete=False,
+                ) as temporary_file:
+                    temporary_path = temporary_file.name
+                    json.dump(document, temporary_file, indent=2, ensure_ascii=False)
+                    temporary_file.write("\n")
+                    temporary_file.flush()
+                    os.fsync(temporary_file.fileno())
+                os.replace(temporary_path, self._path)
+                temporary_path = None
+            finally:
+                if temporary_path and os.path.exists(temporary_path):
+                    os.unlink(temporary_path)
+        return self._store_preferences(preferences)
+
+    def add_listener(self, listener):
+        if not callable(listener):
+            raise TypeError("listener must be callable")
+        with self._lock:
+            self._listeners.add(listener)
+        return listener
+
+    def remove_listener(self, listener):
+        with self._lock:
+            self._listeners.discard(listener)
+
+    def start_watcher(self):
+        with self._lock:
+            if not self._path:
+                raise RuntimeError("PYAPPIFY_APP_JSON_PATH is not configured")
+            if self._watch_thread and self._watch_thread.is_alive():
+                return self._watch_thread
+            stop_event = threading.Event()
+            self._watch_stop = stop_event
+            thread = threading.Thread(
+                target=self._watch_loop,
+                args=(stop_event,),
+                name="pyappify-app-config-watch",
+                daemon=True,
+            )
+            self._watch_thread = thread
+            thread.start()
+            return thread
+
+    def stop_watcher(self):
+        with self._lock:
+            stop_event = self._watch_stop
+            thread = self._watch_thread
+            self._watch_stop = None
+            self._watch_thread = None
+        if stop_event:
+            stop_event.set()
+        if thread and thread is not threading.current_thread():
+            thread.join(timeout=max(1.0, self._watch_interval * 2))
+
+    def _watch_loop(self, stop_event):
+        while not stop_event.wait(self._watch_interval):
+            try:
+                self.refresh()
+            except (OSError, ValueError, json.JSONDecodeError):
+                _LOG.exception("Failed to refresh app preferences from %s", self.path)
+
+
+_api = AppConfigAPI()
+
+
+def configure_app_json(path=None, watch=True, watch_interval=0.5):
+    return _api.configure(path, watch=watch, watch_interval=watch_interval)
+
+
+def get_app_json_path():
+    return _api.path
+
+
+def get_app_config():
+    return _api.get()
+
+
+def update_app_config(auto_start=_UNSET, update_method=_UNSET):
+    return _api.update(auto_start=auto_start, update_method=update_method)
+
+
+def get_auto_start():
+    return get_app_config()["auto_start"]
+
+
+def set_auto_start(auto_start):
+    return update_app_config(auto_start=auto_start)["auto_start"]
+
+
+def get_update_method():
+    return get_app_config()["update_method"]
+
+
+def set_update_method(update_method):
+    return update_app_config(update_method=update_method)["update_method"]
+
+
+def add_app_config_listener(listener):
+    return _api.add_listener(listener)
+
+
+def remove_app_config_listener(listener):
+    _api.remove_listener(listener)
+
+
+def start_app_config_watcher():
+    return _api.start_watcher()
+
+
+def stop_app_config_watcher():
+    _api.stop_watcher()
+
+
+atexit.register(stop_app_config_watcher)

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

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

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

@@ -1,5 +1,6 @@
 pyproject.toml
 pyappify/__init__.py
+pyappify/app_config.py
 pyappify/main.py
 pyappify.egg-info/PKG-INFO
 pyappify.egg-info/SOURCES.txt
@@ -7,6 +8,8 @@ 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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyappify"
-version = "1.0.4"
+version = "1.0.6"
 description = "My awesome Python application"
 readme = "README.md"
 requires-python = ">=3.7"

pyappify-1.0.6/tests/TestAppConfig.py

@@ -0,0 +1,89 @@
+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

@@ -0,0 +1,77 @@
+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.4 → pyappify-1.0.6}/tests/TestUpdateEnv.py

@@ -9,6 +9,8 @@ ENV_KEYS = (
     "PYAPPIFY_APP_VERSION",
     "PYAPPIFY_APP_STARTING_VERSION",
     "PYAPPIFY_UPDATE_NOTE",
+    "PYAPPIFY_APP_JSON_PATH",
+    "PYAPPIFY_LOCALE",
 )
 
 
@@ -89,6 +91,10 @@ class TestUpdateEnv(unittest.TestCase):
             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()