pyappify 1.0.8__tar.gz → 1.0.10__tar.gz

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

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

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

@@ -44,6 +44,7 @@ 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
+_DOWNLOAD_IO_TIMEOUT_SECONDS = 2
 
 try:
     pid = int(os.environ.get("PYAPPIFY_PID"))
@@ -57,13 +58,14 @@ except ImportError:
 
 
 def find_pyappify_executable(start_dir=None, environ=None):
-    """Find the launcher configured by PyAppify or in a parent directory."""
+    """Find the configured launcher or an app launcher above ``working``."""
     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())
+        return None
 
     current = Path(start_dir or os.getcwd()).expanduser()
     if current.is_file():
@@ -73,12 +75,52 @@ def find_pyappify_executable(start_dir=None, environ=None):
     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())
+    working_directory = next(
+        (
+            directory
+            for directory in (current,) + tuple(current.parents)
+            if directory.name.casefold() == "working" and directory.parent.name
+        ),
+        None,
+    )
+    if working_directory is None:
+        return None
+
+    app_name = working_directory.parent.name
+    apps_directory = working_directory.parent.parent
+    data_directory = apps_directory.parent
+    if apps_directory.name.casefold() != "apps" or data_directory.name.casefold() != "data":
+        return None
+
+    app_root = data_directory.parent
+    exact_launcher_name = "{} Launcher.exe".format(app_name).casefold()
+    search_directories = []
+    directory = working_directory
+    while True:
+        search_directories.append(directory)
+        if directory == app_root:
+            break
+        directory = directory.parent
+
+    for directory in search_directories:
+        try:
+            candidates = [
+                candidate
+                for candidate in directory.iterdir()
+                if candidate.is_file()
+                and candidate.suffix.casefold() == ".exe"
+                and candidate.name.casefold().startswith(app_name.casefold())
+            ]
+        except OSError:
+            continue
+        if candidates:
+            candidates.sort(
+                key=lambda candidate: (
+                    candidate.name.casefold() != exact_launcher_name,
+                    candidate.name.casefold(),
+                )
+            )
+            return str(candidates[0].resolve())
     return None
 
 
@@ -139,13 +181,13 @@ def bring_window_to_front_by_pid(pid):
     return False
 
 
-def kill_pyappify(timeout=30):
+def kill_pyappify(timeout=30, exit_event=None):
     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):
+            if not _wait_for_process_exit(pid, timeout, exit_event=exit_event):
                 log.warning(f"Timed out waiting for process with PID {pid} to exit.")
                 return False
             log.info(f'_wait_for_process_exit success {pid}')
@@ -156,11 +198,11 @@ def kill_pyappify(timeout=30):
     return False
 
 
-def kill_pyappify_exe(timeout=30):
-    return kill_pyappify(timeout)
+def kill_pyappify_exe(timeout=30, exit_event=None):
+    return kill_pyappify(timeout, exit_event=exit_event)
 
 
-def _wait_for_process_exit(process_pid, timeout=30):
+def _wait_for_process_exit(process_pid, timeout=30, exit_event=None):
     if sys.platform == "win32" and ctypes:
         synchronize = 0x00100000
         wait_timeout = 0x00000102
@@ -181,22 +223,32 @@ def _wait_for_process_exit(process_pid, timeout=30):
         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
+                deadline = time.monotonic() + timeout
+                while time.monotonic() < deadline:
+                    if _exit_requested(exit_event):
+                        return False
+                    remaining_ms = max(0, int((deadline - time.monotonic()) * 1000))
+                    result = ctypes.windll.kernel32.WaitForSingleObject(
+                        handle, min(100, remaining_ms)
+                    )
+                    if result == wait_failed:
+                        return False
+                    if result != wait_timeout:
+                        return True
+                return False
             finally:
                 ctypes.windll.kernel32.CloseHandle(handle)
 
     deadline = time.monotonic() + timeout
     while time.monotonic() < deadline:
+        if _exit_requested(exit_event):
+            return False
         try:
             os.kill(process_pid, 0)
         except OSError:
             return True
-        time.sleep(0.1)
+        if _wait_for_exit(exit_event, 0.1):
+            return False
     return False
 
 
@@ -280,12 +332,38 @@ def _require_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."
+            "existing executable or place an executable whose name starts with the app name "
+            "in the working directory or a parent directory."
         )
     return pyappify_executable
 
 
-def _run_launcher_api(arguments, timeout=300):
+def _exit_requested(*events):
+    return any(event is not None and event.is_set() for event in events)
+
+
+def _wait_for_exit(exit_event, timeout):
+    if exit_event is not None:
+        return exit_event.wait(timeout)
+    time.sleep(timeout)
+    return False
+
+
+def _raise_if_exit_requested(exit_event):
+    if _exit_requested(exit_event):
+        raise InterruptedError("PyAppify operation cancelled because exit_event was set")
+
+
+def _terminate_process(process):
+    try:
+        if process.poll() is None:
+            process.terminate()
+    except (AttributeError, OSError):
+        pass
+
+
+def _run_launcher_api(arguments, timeout=300, exit_event=None):
+    _raise_if_exit_requested(exit_event)
     executable = _require_pyappify_executable()
     response_path = os.path.join(
         tempfile.gettempdir(),
@@ -293,7 +371,7 @@ def _run_launcher_api(arguments, timeout=300):
     )
     command = list(arguments) + ["--response-file", response_path]
     try:
-        subprocess.Popen(
+        process = subprocess.Popen(
             [executable] + command,
             cwd=os.path.dirname(executable) or None,
             stdout=subprocess.DEVNULL,
@@ -305,8 +383,13 @@ def _run_launcher_api(arguments, timeout=300):
         )
 
     deadline = time.monotonic() + timeout
+    cancelled = False
     try:
         while time.monotonic() < deadline:
+            if _exit_requested(exit_event):
+                cancelled = True
+                _terminate_process(process)
+                break
             try:
                 with open(response_path, "r", encoding="utf-8") as response_file:
                     response = json.load(response_file)
@@ -318,18 +401,25 @@ def _run_launcher_api(arguments, timeout=300):
             except json.JSONDecodeError:
                 # The running launcher may still be completing the response write.
                 pass
-            time.sleep(0.05)
+            if _wait_for_exit(exit_event, 0.05):
+                cancelled = True
+                _terminate_process(process)
+                break
     finally:
         try:
             os.remove(response_path)
         except FileNotFoundError:
             pass
 
+    if cancelled:
+        raise InterruptedError("PyAppify operation cancelled because exit_event was set")
     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."""
+def get_version_list(
+    number_versions=10, release_only=True, timeout=120, exit_event=None
+):
+    """Return version details, cancelling with InterruptedError on exit_event."""
     if isinstance(number_versions, bool) or not isinstance(number_versions, int):
         raise TypeError("number_versions must be an integer")
     if number_versions <= 0:
@@ -338,7 +428,8 @@ def get_version_list(number_versions=10, release_only=True, timeout=120):
         raise TypeError("release_only must be a boolean")
 
     if "PYAPPIFY_PYTHON_TEST" in os.environ:
-        time.sleep(5)
+        if _wait_for_exit(exit_event, 5):
+            _raise_if_exit_requested(exit_event)
         return _get_mock_version_list(number_versions)
 
     response = _run_launcher_api(
@@ -350,15 +441,16 @@ def get_version_list(number_versions=10, release_only=True, timeout=120):
             str(release_only).lower(),
         ],
         timeout=timeout,
+        exit_event=exit_event,
     )
     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):
+def get_versions(number_versions=10, release_only=True, timeout=120, exit_event=None):
     """Alias for get_version_list."""
-    return get_version_list(number_versions, release_only, timeout)
+    return get_version_list(number_versions, release_only, timeout, exit_event)
 
 
 def calculate_update_notes(update_notes, current_version, target_version):
@@ -401,15 +493,17 @@ def calculate_update_notes(update_notes, current_version, target_version):
     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."""
+def update_to_version(version, timeout=300, exit_event=None):
+    """Update the app, cancelling with InterruptedError on exit_event."""
     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:
+        _raise_if_exit_requested(exit_event)
         return {"updated": True, "version": version, "mocked": True}
     response = _run_launcher_api(
         ["--update-to-version", version],
         timeout=timeout,
+        exit_event=exit_event,
     )
     if not isinstance(response, dict) or not response.get("updated"):
         raise RuntimeError("PyAppify returned an invalid update response")
@@ -463,10 +557,11 @@ def _get_mock_version_list(number_versions):
     return versions[:number_versions]
 
 
-def _replace_executable(source_path, target_path, timeout=30):
+def _replace_executable(source_path, target_path, timeout=30, exit_event=None):
     deadline = time.monotonic() + timeout
     last_error = None
     while True:
+        _raise_if_exit_requested(exit_event)
         try:
             shutil.move(source_path, target_path)
             return
@@ -474,7 +569,8 @@ def _replace_executable(source_path, target_path, timeout=30):
             last_error = e
             if time.monotonic() >= deadline:
                 raise last_error
-            time.sleep(0.25)
+            if _wait_for_exit(exit_event, 0.25):
+                _raise_if_exit_requested(exit_event)
 
 
 def hide_pyappify():
@@ -487,7 +583,13 @@ def hide_pyappify():
             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):
+def upgrade(
+    to_version,
+    executable_sha256,
+    executable_zip_urls,
+    stop_event=None,
+    exit_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}")
@@ -497,17 +599,23 @@ 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:
+            if _exit_requested(stop_event, exit_event):
+                return
             os.makedirs(tmp_dir, exist_ok=True)
             downloaded_zip_path = None
             for url in executable_zip_urls:
+                if _exit_requested(stop_event, exit_event):
+                    return
                 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:
+                    with urllib.request.urlopen(
+                        url, timeout=_DOWNLOAD_IO_TIMEOUT_SECONDS
+                    ) 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.")
+                            if _exit_requested(stop_event, exit_event):
+                                log.info("pyappify Upgrade download cancelled.")
                                 return
                             chunk = response.read(8192)
                             if not chunk:
@@ -526,11 +634,16 @@ def upgrade(to_version, executable_sha256, executable_zip_urls, stop_event=None)
                 return
 
             with zipfile.ZipFile(downloaded_zip_path, 'r') as zip_ref:
-                zip_ref.extractall(tmp_dir)
+                for member in zip_ref.infolist():
+                    if _exit_requested(stop_event, exit_event):
+                        return
+                    zip_ref.extract(member, tmp_dir)
 
             new_executable_name = os.path.basename(pyappify_executable)
             found_executable_path = None
             for root, _, files in os.walk(tmp_dir):
+                if _exit_requested(stop_event, exit_event):
+                    return
                 if new_executable_name in files:
                     found_executable_path = os.path.join(root, new_executable_name)
                     break
@@ -541,15 +654,26 @@ def upgrade(to_version, executable_sha256, executable_zip_urls, stop_event=None)
 
             sha256_hash = hashlib.sha256()
             with open(found_executable_path, "rb") as f:
-                for byte_block in iter(lambda: f.read(4096), b""):
+                while True:
+                    if _exit_requested(stop_event, exit_event):
+                        return
+                    byte_block = f.read(4096)
+                    if not byte_block:
+                        break
                     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)
+            if _exit_requested(stop_event, exit_event):
+                return
+            kill_pyappify(exit_event=exit_event or stop_event)
+            _replace_executable(
+                found_executable_path,
+                pyappify_executable,
+                exit_event=exit_event or stop_event,
+            )
             log.info(f"pyappify Upgrade success")
         except Exception as e:
             log.error(f"pyappify Upgrade failed: {e}")
@@ -560,6 +684,7 @@ def upgrade(to_version, executable_sha256, executable_zip_urls, stop_event=None)
     thread = threading.Thread(target=_do_upgrade)
     thread.daemon = True
     thread.start()
+    return thread
 
 
 def is_app_updated():

{pyappify-1.0.8 → pyappify-1.0.10}/pyappify/app_config.py

@@ -22,7 +22,7 @@ _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):
+    def __init__(self, path=None, watch=False, watch_interval=0.5, exit_event=None):
         self._lock = threading.RLock()
         self._path = None
         self._preferences = {
@@ -31,22 +31,29 @@ class AppConfigAPI:
         }
         self._listeners = set()
         self._watch_interval = watch_interval
+        self._exit_event = exit_event
         self._watch_stop = None
         self._watch_thread = None
         if path:
-            self.configure(path, watch=watch, watch_interval=watch_interval)
+            self.configure(
+                path,
+                watch=watch,
+                watch_interval=watch_interval,
+                exit_event=exit_event,
+            )
 
     @property
     def path(self):
         with self._lock:
             return self._path
 
-    def configure(self, path, watch=True, watch_interval=0.5):
+    def configure(self, path, watch=True, watch_interval=0.5, exit_event=None):
         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._exit_event = exit_event
             self._preferences = {
                 "auto_start": False,
                 "update_method": UPDATE_METHOD_AUTO,
@@ -153,17 +160,19 @@ class AppConfigAPI:
         with self._lock:
             self._listeners.discard(listener)
 
-    def start_watcher(self):
+    def start_watcher(self, exit_event=None):
         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
+            if exit_event is not None:
+                self._exit_event = exit_event
             stop_event = threading.Event()
             self._watch_stop = stop_event
             thread = threading.Thread(
                 target=self._watch_loop,
-                args=(stop_event,),
+                args=(stop_event, self._exit_event),
                 name="pyappify-app-config-watch",
                 daemon=True,
             )
@@ -182,8 +191,12 @@ class AppConfigAPI:
         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):
+    def _watch_loop(self, stop_event, exit_event=None):
+        if exit_event is not None and exit_event.is_set():
+            return
         while not stop_event.wait(self._watch_interval):
+            if exit_event is not None and exit_event.is_set():
+                return
             try:
                 self.refresh()
             except (OSError, ValueError, json.JSONDecodeError):
@@ -193,8 +206,13 @@ class AppConfigAPI:
 _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 configure_app_json(path=None, watch=True, watch_interval=0.5, exit_event=None):
+    return _api.configure(
+        path,
+        watch=watch,
+        watch_interval=watch_interval,
+        exit_event=exit_event,
+    )
 
 
 def get_app_json_path():
@@ -233,8 +251,8 @@ def remove_app_config_listener(listener):
     _api.remove_listener(listener)
 
 
-def start_app_config_watcher():
-    return _api.start_watcher()
+def start_app_config_watcher(exit_event=None):
+    return _api.start_watcher(exit_event=exit_event)
 
 
 def stop_app_config_watcher():

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

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

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

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