pyappify 1.0.13__tar.gz → 1.0.14__tar.gz

{pyappify-1.0.13 → pyappify-1.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyappify
-Version: 1.0.13
+Version: 1.0.14
 Summary: My awesome Python application
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
@@ -10,3 +10,5 @@ Description-Content-Type: text/markdown
 Provides-Extra: dev
 Requires-Dist: twine; extra == "dev"
 Requires-Dist: build; extra == "dev"
+Provides-Extra: standalone
+Requires-Dist: dulwich>=1.2; python_version >= "3.10" and extra == "standalone"

pyappify-1.0.14/pyappify/__init__.py

@@ -0,0 +1,100 @@
+# pyappify/__init__.py
+"""Python API for apps run by the PyAppify launcher.
+
+Runtime state below is read from the environment the launcher sets. It stays
+on the package so apps can override it (``pyappify.logger = my_logger``);
+the submodules read it from here at call time.
+"""
+import json
+import os
+
+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,
+)
+from ._process import bring_window_to_front_by_pid, minimize_window_by_pid
+from .launcher import (
+    find_pyappify_executable,
+    hide_pyappify,
+    kill_pyappify,
+    kill_pyappify_exe,
+    show_pyappify,
+)
+from .self_upgrade import upgrade
+from .shortcut import create_shortcut, refresh_shortcuts
+from .updates import get_version_list, get_versions, update_to_version
+from .versions import calculate_update_notes, is_greater_version
+
+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")
+app_json_path = configure_app_json(os.environ.get("PYAPPIFY_APP_JSON_PATH"))
+
+pyappify_upgradeable = os.environ.get("PYAPPIFY_UPGRADEABLE") == '1'
+logger = None
+
+try:
+    pid = int(os.environ.get("PYAPPIFY_PID"))
+except (ValueError, TypeError):
+    pid = None
+
+pyappify_executable = find_pyappify_executable()
+
+if app_version is None and not pyappify_version and not pyappify_executable:
+    # Running from a git clone without the launcher: use the version tag at HEAD.
+    from .standalone import detect_app_version
+
+    app_version = detect_app_version()
+    app_starting_version = app_starting_version or app_version
+
+
+def is_app_updated():
+    return is_greater_version(app_version, app_starting_version)
+
+
+def is_app_downgraded():
+    return is_greater_version(app_starting_version, app_version)
+
+
+def is_updated():
+    return is_app_updated()
+
+
+def is_downgrade():
+    return is_app_downgraded()
+
+
+def get_update_notes():
+    if not update_note:
+        return []
+    try:
+        notes = json.loads(update_note)
+    except (TypeError, ValueError):
+        return []
+    if isinstance(notes, list):
+        return [str(note) for note in notes]
+    return []
+
+
+def get_update_note():
+    return get_update_notes()
+
+
+def get_locale():
+    return app_locale

pyappify-1.0.14/pyappify/_process.py

@@ -0,0 +1,144 @@
+"""Process, window and cancellation helpers shared by the other modules."""
+import os
+import sys
+import time
+
+try:
+    import ctypes
+except ImportError:
+    ctypes = None
+
+_SYNCHRONIZE = 0x00100000
+_WAIT_TIMEOUT = 0x00000102
+_WAIT_FAILED = 0xFFFFFFFF
+_SW_MINIMIZE = 6
+_SW_RESTORE = 9
+
+
+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 _kernel32():
+    """Return kernel32 with the signatures used here, or None off Windows."""
+    if sys.platform != "win32" or not ctypes:
+        return None
+    kernel32 = ctypes.windll.kernel32
+    kernel32.OpenProcess.argtypes = (ctypes.c_uint, ctypes.c_bool, ctypes.c_ulong)
+    kernel32.OpenProcess.restype = ctypes.c_void_p
+    kernel32.WaitForSingleObject.argtypes = (ctypes.c_void_p, ctypes.c_uint)
+    kernel32.WaitForSingleObject.restype = ctypes.c_uint
+    kernel32.CloseHandle.argtypes = (ctypes.c_void_p,)
+    kernel32.CloseHandle.restype = ctypes.c_bool
+    return kernel32
+
+
+def _wait_for_process_exit(process_pid, timeout=30, exit_event=None):
+    kernel32 = _kernel32()
+    handle = kernel32.OpenProcess(_SYNCHRONIZE, False, process_pid) if kernel32 else None
+    if handle:
+        try:
+            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 = kernel32.WaitForSingleObject(handle, min(100, remaining_ms))
+                if result == _WAIT_FAILED:
+                    return False
+                if result != _WAIT_TIMEOUT:
+                    return True
+            return False
+        finally:
+            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
+        if _wait_for_exit(exit_event, 0.1):
+            return False
+    return False
+
+
+def _is_process_running(process_pid):
+    if not process_pid:
+        return False
+
+    kernel32 = _kernel32()
+    if kernel32:
+        handle = kernel32.OpenProcess(_SYNCHRONIZE, False, process_pid)
+        if not handle:
+            return False
+        try:
+            return kernel32.WaitForSingleObject(handle, 0) == _WAIT_TIMEOUT
+        finally:
+            kernel32.CloseHandle(handle)
+
+    try:
+        os.kill(process_pid, 0)
+    except OSError:
+        return False
+    return True
+
+
+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):
+    hwnd = _find_visible_window_by_pid(pid)
+    if hwnd:
+        ctypes.windll.user32.ShowWindow(hwnd, _SW_MINIMIZE)
+        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, _SW_RESTORE)
+        return bool(ctypes.windll.user32.SetForegroundWindow(hwnd))
+
+    return False

pyappify-1.0.14/pyappify/_state.py

@@ -0,0 +1,33 @@
+"""Access to the runtime state kept on the ``pyappify`` package.
+
+Public state such as ``pid``, ``logger`` and ``pyappify_executable`` lives on
+the package itself so applications (and tests) can assign it directly, for
+example ``pyappify.logger = my_logger``. Submodules look it up through
+:func:`pkg` at call time instead of copying it at import time.
+"""
+import logging
+import sys
+
+_console_logger = None
+
+
+def pkg():
+    return sys.modules[__package__]
+
+
+def get_logger():
+    """Return the logger assigned to ``pyappify.logger`` or a console logger."""
+    global _console_logger
+
+    logger = getattr(pkg(), "logger", None)
+    if logger is not None:
+        return logger
+    if _console_logger is None:
+        _console_logger = logging.getLogger("pyappify")
+        if not _console_logger.handlers:
+            handler = logging.StreamHandler()
+            handler.setFormatter(logging.Formatter("%(levelname)s: %(message)s"))
+            _console_logger.addHandler(handler)
+        _console_logger.setLevel(logging.INFO)
+        _console_logger.propagate = False
+    return _console_logger

pyappify-1.0.14/pyappify/launcher.py

@@ -0,0 +1,201 @@
+"""Talking to and controlling the PyAppify launcher executable."""
+import json
+import os
+import signal
+import subprocess
+import tempfile
+import time
+import uuid
+from pathlib import Path
+
+from . import _process
+from ._state import get_logger, pkg
+
+
+def find_pyappify_executable(start_dir=None, environ=None):
+    """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():
+        current = current.parent
+    try:
+        current = current.resolve()
+    except OSError:
+        current = current.absolute()
+
+    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
+    executable_name = "{}.exe".format(app_name)
+    search_directories = []
+    directory = working_directory
+    while True:
+        search_directories.append(directory)
+        if directory == app_root:
+            break
+        directory = directory.parent
+
+    for directory in search_directories:
+        candidate = directory / executable_name
+        if candidate.is_file():
+            return str(candidate.resolve())
+    return None
+
+
+def _require_pyappify_executable():
+    state = pkg()
+    if state.pyappify_executable and os.path.isfile(state.pyappify_executable):
+        return os.path.abspath(state.pyappify_executable)
+    state.pyappify_executable = find_pyappify_executable()
+    if not state.pyappify_executable:
+        raise FileNotFoundError(
+            "PyAppify executable was not found. Set PYAPPIFY_EXECUTABLE to an "
+            "existing executable or place <app_name>.exe between the working directory "
+            "and the app root."
+        )
+    return state.pyappify_executable
+
+
+def kill_pyappify(timeout=30, exit_event=None):
+    pid = pkg().pid
+    if pid:
+        log = get_logger()
+        log.info(f"Attempting to terminate process with PID: {pid}")
+        try:
+            os.kill(pid, signal.SIGTERM)
+            if not _process._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}')
+            return True
+        except Exception as e:
+            log.error(f"Failed to terminate process with PID {pid}: {e}")
+            return False
+    return False
+
+
+def kill_pyappify_exe(timeout=30, exit_event=None):
+    return kill_pyappify(timeout, exit_event=exit_event)
+
+
+def show_pyappify(args=None, cwd=None, env=None):
+    state = pkg()
+    log = get_logger()
+    already_running = _process._is_process_running(state.pid)
+    if already_running and not args:
+        log.info(f"PyAppify is already running with PID: {state.pid}")
+        _process.bring_window_to_front_by_pid(state.pid)
+        return state.pid
+
+    executable = state.pyappify_executable or find_pyappify_executable()
+    if not executable:
+        log.error("PyAppify executable was not found.")
+        return None
+
+    command = [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(executable) or None,
+            env=env,
+        )
+        if not already_running:
+            state.pid = process.pid
+        return state.pid
+    except Exception as e:
+        log.error(f"Failed to start PyAppify executable {executable}: {e}")
+        return None
+
+
+def hide_pyappify():
+    pid = pkg().pid
+    if pid:
+        log = get_logger()
+        log.info(f"Attempting to minimize window for process with PID: {pid}")
+        try:
+            _process.minimize_window_by_pid(pid)
+        except Exception as e:
+            log.error(f"Failed to minimize window for process with PID {pid}: {e}")
+
+
+def _run_launcher_api(arguments, timeout=300, exit_event=None):
+    """Run a launcher API command and return its JSON response."""
+    _process._raise_if_exit_requested(exit_event)
+    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:
+        process = 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
+    cancelled = False
+    try:
+        while time.monotonic() < deadline:
+            if _process._exit_requested(exit_event):
+                cancelled = True
+                _process._terminate_process(process)
+                break
+            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
+            if _process._wait_for_exit(exit_event, 0.05):
+                cancelled = True
+                _process._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")

pyappify-1.0.14/pyappify/self_upgrade.py

@@ -0,0 +1,154 @@
+"""Replacing the PyAppify launcher executable with a newer release."""
+import hashlib
+import os
+import shutil
+import threading
+import time
+import urllib.request
+import zipfile
+
+from . import _process, launcher
+from ._state import get_logger, pkg
+from .versions import is_greater_version
+
+_DOWNLOAD_IO_TIMEOUT_SECONDS = 2
+_TMP_DIR_NAME = "pyappify_tmp"
+
+
+class _Cancelled(Exception):
+    """Raised inside the upgrade worker when stop_event or exit_event is set."""
+
+
+def upgrade(
+    to_version,
+    executable_sha256,
+    executable_zip_urls,
+    stop_event=None,
+    exit_event=None,
+):
+    state = pkg()
+    log = get_logger()
+    if not state.pyappify_upgradeable or not is_greater_version(to_version, state.pyappify_version):
+        log.info(f"pyappify no need to upgrade {state.pyappify_upgradeable} {to_version} {executable_sha256} {executable_zip_urls}")
+        return
+    log.info(
+        f"pyappify start to upgrade {state.pyappify_upgradeable} {to_version} {executable_sha256} {executable_zip_urls}")
+
+    thread = threading.Thread(
+        target=_run_upgrade,
+        args=(executable_sha256, executable_zip_urls, stop_event, exit_event),
+    )
+    thread.daemon = True
+    thread.start()
+    return thread
+
+
+def _run_upgrade(executable_sha256, executable_zip_urls, stop_event, exit_event):
+    log = get_logger()
+    tmp_dir = os.path.join(os.getcwd(), _TMP_DIR_NAME)
+
+    def check_cancelled():
+        if _process._exit_requested(stop_event, exit_event):
+            raise _Cancelled()
+
+    try:
+        check_cancelled()
+        os.makedirs(tmp_dir, exist_ok=True)
+
+        zip_path = _download_first(executable_zip_urls, tmp_dir, check_cancelled)
+        if not zip_path:
+            log.error("pyappify Failed to download upgrade.")
+            return
+
+        _extract_zip(zip_path, tmp_dir, check_cancelled)
+
+        target_executable = pkg().pyappify_executable
+        new_executable = _find_file(tmp_dir, os.path.basename(target_executable), check_cancelled)
+        if not new_executable:
+            log.error("pyappify Executable not found in zip.")
+            return
+
+        if executable_sha256 and _sha256_file(new_executable, check_cancelled) != executable_sha256:
+            log.error("pyappify SHA256 checksum mismatch.")
+            return
+
+        check_cancelled()
+        cancel_event = exit_event or stop_event
+        launcher.kill_pyappify(exit_event=cancel_event)
+        _replace_executable(new_executable, target_executable, exit_event=cancel_event)
+        log.info("pyappify Upgrade success")
+    except _Cancelled:
+        pass
+    except Exception as e:
+        log.error(f"pyappify Upgrade failed: {e}")
+    finally:
+        if os.path.exists(tmp_dir):
+            shutil.rmtree(tmp_dir)
+
+
+def _download_first(urls, directory, check_cancelled):
+    """Download the first URL that succeeds into ``directory`` and return its path."""
+    log = get_logger()
+    for url in urls:
+        check_cancelled()
+        try:
+            log.info(f"pyappify start to download {url}")
+            local_path = os.path.join(directory, os.path.basename(url))
+            with urllib.request.urlopen(
+                url, timeout=_DOWNLOAD_IO_TIMEOUT_SECONDS
+            ) as response, open(local_path, 'wb') as out_file:
+                while True:
+                    check_cancelled()
+                    chunk = response.read(8192)
+                    if not chunk:
+                        break
+                    out_file.write(chunk)
+            log.info(f"pyappify download success {url}")
+            return local_path
+        except _Cancelled:
+            log.info("pyappify Upgrade download cancelled.")
+            raise
+        except Exception as e:
+            log.warning(f"pyappify Failed to download from {url}: {e}")
+    return None
+
+
+def _extract_zip(zip_path, directory, check_cancelled):
+    with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+        for member in zip_ref.infolist():
+            check_cancelled()
+            zip_ref.extract(member, directory)
+
+
+def _find_file(directory, file_name, check_cancelled):
+    for root, _, files in os.walk(directory):
+        check_cancelled()
+        if file_name in files:
+            return os.path.join(root, file_name)
+    return None
+
+
+def _sha256_file(path, check_cancelled):
+    sha256_hash = hashlib.sha256()
+    with open(path, "rb") as f:
+        while True:
+            check_cancelled()
+            byte_block = f.read(4096)
+            if not byte_block:
+                break
+            sha256_hash.update(byte_block)
+    return sha256_hash.hexdigest()
+
+
+def _replace_executable(source_path, target_path, timeout=30, exit_event=None):
+    deadline = time.monotonic() + timeout
+    while True:
+        _process._raise_if_exit_requested(exit_event)
+        try:
+            shutil.move(source_path, target_path)
+            return
+        except PermissionError:
+            if time.monotonic() >= deadline:
+                raise
+            if _process._wait_for_exit(exit_event, 0.25):
+                _process._raise_if_exit_requested(exit_event)