pyappify 1.0.3__tar.gz → 1.0.5__tar.gz

{pyappify-1.0.3 → pyappify-1.0.5}/PKG-INFO

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

{pyappify-1.0.3 → pyappify-1.0.5}/pyappify/__init__.py

@@ -1,13 +1,15 @@
-# 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
 
 app_version = os.environ.get("PYAPPIFY_APP_VERSION")
 app_starting_version = os.environ.get("PYAPPIFY_APP_STARTING_VERSION") or app_version
@@ -15,20 +17,20 @@ 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
+
+try:
+    pid = int(os.environ.get("PYAPPIFY_PID"))
+except (ValueError, TypeError):
+    pid = None
+
+import sys
+
+try:
+    import ctypes
 except ImportError:
     ctypes = None
 
@@ -49,38 +51,186 @@ 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, 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):
+    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 _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
+    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:
@@ -102,7 +252,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:
@@ -114,10 +264,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}")
@@ -129,39 +279,39 @@ 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
 
             kill_pyappify()
-            shutil.move(found_executable_path, pyappify_executable)
+            _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)
-
+        finally:
+            if os.path.exists(tmp_dir):
+                shutil.rmtree(tmp_dir)
+
     thread = threading.Thread(target=_do_upgrade)
     thread.daemon = True
     thread.start()
@@ -202,20 +352,20 @@ def get_update_note():
 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.3 → pyappify-1.0.5}/pyappify.egg-info/PKG-INFO

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

{pyappify-1.0.3 → pyappify-1.0.5}/pyappify.egg-info/SOURCES.txt

@@ -7,6 +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/TestProcessControls.py
 tests/TestUpdateEnv.py
 tests/TestUpgrade.py
 tests/TestUpgradeOnline.py

{pyappify-1.0.3 → pyappify-1.0.5}/pyproject.toml

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

pyappify-1.0.5/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()