pyship 0.1.7__py3-none-any.whl → 0.3.1__py3-none-any.whl

pyship/launcher/launcher_standalone.py

@@ -0,0 +1,309 @@
+"""
+Standalone launcher script for pyship applications.
+
+This script is designed to be self-contained (stdlib only, no third-party imports)
+so it can be run by any Python interpreter without additional dependencies.
+
+It is invoked by the C# launcher stub:
+    python.exe {app_name}_launcher.py --app-dir <app_dir> [app args...]
+"""
+
+import sys
+import os
+import re
+import json
+import time
+import logging
+import subprocess
+import argparse
+from pathlib import Path
+
+# Return codes (matching pyshipupdate constants)
+OK_RETURN_CODE = 0
+ERROR_RETURN_CODE = 1
+CAN_NOT_FIND_FILE_RETURN_CODE = 2
+RESTART_RETURN_CODE = 13
+
+# Python interpreter executables by GUI mode
+PYTHON_INTERPRETER_EXES = {True: "pythonw.exe", False: "python.exe"}
+
+
+class RestartMonitor:
+    """
+    Monitor application restarts and detect excessive restart frequency.
+    """
+
+    def __init__(self):
+        self.restarts = []
+        self.max_samples = 4
+        self.quick = 60.0  # this time or less (in seconds) is considered a quick restart
+
+    def add(self):
+        self.restarts.append(time.time())
+        if len(self.restarts) > self.max_samples:
+            self.restarts.pop(0)
+
+    def excessive(self):
+        """
+        Determine if there has been excessive frequency of restarts.
+        :return: True if restarts have been excessive
+        """
+        if len(self.restarts) < self.max_samples:
+            return False
+        return all(j - i <= self.quick for i, j in zip(self.restarts[:-1], self.restarts[1:]))
+
+
+def _compare_versions(version_str):
+    """
+    Convert a version string like "1.2.3" to a tuple of ints for comparison.
+    :param version_str: version string
+    :return: tuple of ints
+    """
+    parts = []
+    for part in version_str.split("."):
+        try:
+            parts.append(int(part))
+        except ValueError:
+            parts.append(0)
+    return tuple(parts)
+
+
+def _setup_logging(app_name, is_gui):
+    """
+    Set up stdlib logging for the launcher.
+    :param app_name: application name for the log
+    :param is_gui: True for GUI app
+    """
+    log_dir = None
+    local_app_data = os.environ.get("LOCALAPPDATA")
+    if local_app_data:
+        log_dir = Path(local_app_data, app_name, "log")
+        try:
+            log_dir.mkdir(parents=True, exist_ok=True)
+        except OSError:
+            log_dir = None
+
+    logger = logging.getLogger(f"{app_name}_launcher")
+    logger.setLevel(logging.DEBUG)
+
+    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+
+    if log_dir is not None:
+        try:
+            fh = logging.FileHandler(str(Path(log_dir, f"{app_name}_launcher.log")))
+            fh.setLevel(logging.DEBUG)
+            fh.setFormatter(formatter)
+            logger.addHandler(fh)
+        except OSError:
+            pass
+
+    if not is_gui:
+        ch = logging.StreamHandler()
+        ch.setLevel(logging.ERROR)
+        ch.setFormatter(formatter)
+        logger.addHandler(ch)
+
+    return logger
+
+
+def _init_sentry():
+    """
+    Optionally initialize Sentry if sentry_sdk is available.
+    """
+    try:
+        import urllib.request
+        import sentry_sdk
+
+        try:
+            response = urllib.request.urlopen("https://api.pyship.org/resources/pyship/sentry", timeout=5)
+            if response.status == 200:
+                data = json.loads(response.read().decode())
+                sentry_dsn = data.get("dsn")
+                if sentry_dsn:
+                    sentry_sdk.init(sentry_dsn, default_integrations=False)
+        except Exception:
+            pass
+    except ImportError:
+        pass
+
+
+def launch(app_dir=None, additional_path=None):
+    """
+    Launch the pyship application.
+    :param app_dir: override app dir (mainly for testing)
+    :param additional_path: additional search path for app (mainly for testing)
+    :return: exit code (0 if no error)
+    """
+    return_code = None
+
+    clip_regex = re.compile(r"([_a-z0-9]*)_([.0-9]+)", flags=re.IGNORECASE)
+
+    # Default values in case metadata file is not found
+    is_gui = False
+    report_exceptions = True
+    target_app_name = None
+    target_app_author = "unknown"
+
+    if app_dir is not None:
+        app_dir = Path(app_dir).resolve()
+
+    # Read metadata
+    if app_dir is not None:
+        for metadata_file_path in app_dir.glob("*_metadata.json"):
+            try:
+                with metadata_file_path.open() as metadata_file:
+                    metadata = json.load(metadata_file)
+                    target_app_name = metadata.get("app")
+                    target_app_author = metadata.get("author", target_app_author)
+                    is_gui = metadata.get("is_gui", is_gui)
+                    report_exceptions = metadata.get("report_exceptions", report_exceptions)
+            except (json.JSONDecodeError, OSError):
+                pass
+
+    if target_app_name is None:
+        # Try to derive app name from CLIP directories
+        if app_dir is not None:
+            for d in app_dir.iterdir():
+                if d.is_dir():
+                    m = clip_regex.match(d.name)
+                    if m and Path(d, "Scripts", "python.exe").exists():
+                        target_app_name = m.group(1)
+                        break
+
+    log = _setup_logging(target_app_name or "pyship", is_gui)
+
+    if report_exceptions:
+        _init_sentry()
+
+    log.info(f"app_dir={app_dir}")
+
+    if target_app_name is None:
+        log.error(f"could not derive target app name in {app_dir}")
+        return ERROR_RETURN_CODE
+
+    log.info(f"target_app_name={target_app_name}")
+
+    glob_string = f"{target_app_name}_*"
+
+    restart_monitor = RestartMonitor()
+
+    while (return_code is None or return_code == RESTART_RETURN_CODE) and not restart_monitor.excessive():
+        restart_monitor.add()
+
+        search_dirs = []
+        if app_dir is not None:
+            search_dirs.append(app_dir)
+
+        # Also search user data dir (matches platformdirs.user_data_dir layout)
+        local_app_data = os.environ.get("LOCALAPPDATA")
+        if local_app_data:
+            user_data_dir = Path(local_app_data, target_app_author, target_app_name)
+            if user_data_dir.exists():
+                search_dirs.append(user_data_dir)
+
+        if additional_path is not None:
+            search_dirs.append(Path(additional_path))
+
+        candidate_dirs = []
+        for search_dir in search_dirs:
+            for d in Path(search_dir).glob(glob_string):
+                if d.is_dir():
+                    candidate_dirs.append(d)
+
+        versions = {}
+        for candidate_dir in candidate_dirs:
+            matches = clip_regex.match(candidate_dir.name)
+            if matches is not None:
+                version_str = matches.group(2)
+                version_tuple = _compare_versions(version_str)
+                if any(v > 0 for v in version_tuple):
+                    versions[version_tuple] = candidate_dir
+                else:
+                    log.error(f"could not get version out of {candidate_dir}")
+
+        if len(versions) > 0:
+            latest_version = sorted(versions.keys())[-1]
+            log.info(f"latest_version={'.'.join(str(v) for v in latest_version)}")
+
+            python_exe_path = Path(versions[latest_version], "Scripts", PYTHON_INTERPRETER_EXES[is_gui])
+
+            if python_exe_path.exists():
+                cmd = [str(python_exe_path), "-m", target_app_name]
+                # Forward any extra arguments (skip --app-dir and its value)
+                forwarded_args = _get_forwarded_args()
+                cmd.extend(forwarded_args)
+
+                log.info(f"cmd={cmd}")
+                try:
+                    target_process = subprocess.run(cmd, cwd=str(python_exe_path.parent), capture_output=True, text=True)
+                    return_code = target_process.returncode
+
+                    std_out = target_process.stdout
+                    std_err = target_process.stderr
+
+                    if (std_err and std_err.strip()) or (return_code != OK_RETURN_CODE and return_code != RESTART_RETURN_CODE):
+                        if std_out and std_out.strip():
+                            log.warning(std_out)
+                        if std_err and std_err.strip():
+                            log.error(std_err)
+
+                    for name, std_x, sys_f in [("stdout", std_out, sys.stdout), ("stderr", std_err, sys.stderr)]:
+                        if std_x and std_x.strip():
+                            for so_line in std_x.splitlines():
+                                so_line_strip = so_line.strip()
+                                if so_line_strip:
+                                    log.info(f"{name}:{so_line_strip}")
+                            print(std_x, file=sys_f)
+
+                    log.info(f"return_code={return_code}")
+
+                except FileNotFoundError as e:
+                    log.error(f"{e} {cmd}")
+                    return_code = ERROR_RETURN_CODE
+            else:
+                log.error(f"python exe not found at {python_exe_path}")
+                return_code = CAN_NOT_FIND_FILE_RETURN_CODE
+        else:
+            log.error(f"could not find any expected application version in {search_dirs} ({glob_string=})")
+            return_code = ERROR_RETURN_CODE
+            break
+
+    if restart_monitor.excessive():
+        log.error(f"excessive restarts restarts={restart_monitor.restarts}")
+
+    if return_code is None:
+        return_code = ERROR_RETURN_CODE
+
+    log.info(f"returning : return_code={return_code}")
+
+    return return_code
+
+
+def _get_forwarded_args():
+    """
+    Parse sys.argv to extract arguments that should be forwarded to the target app.
+    Strips out --app-dir and its value.
+    """
+    args = []
+    skip_next = False
+    for i, arg in enumerate(sys.argv[1:], 1):
+        if skip_next:
+            skip_next = False
+            continue
+        if arg == "--app-dir":
+            skip_next = True
+            continue
+        args.append(arg)
+    return args
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="pyship standalone launcher")
+    parser.add_argument("--app-dir", type=str, default=None, help="application directory")
+    known_args, _ = parser.parse_known_args()
+
+    exit_app_dir = None
+    if known_args.app_dir:
+        exit_app_dir = Path(known_args.app_dir)
+
+    sys.exit(launch(app_dir=exit_app_dir))

pyship/launcher/metadata.py

@@ -20,8 +20,13 @@ def calculate_metadata(target_app_name: str, target_app_author: str, target_app_
         "icon_sha256": get_file_sha256(icon_path),
         "is_gui": is_gui,
     }
+    # Hash launcher Python sources
     for p in launcher_source_dir.glob("*.py"):
         launcher_metadata[f"{p.name}_sha256"] = get_file_sha256(p)
+    # Hash the C# stub template (in the parent pyship package)
+    launcher_stub_path = launcher_source_dir.parent / "launcher_stub.py"
+    if launcher_stub_path.exists():
+        launcher_metadata["launcher_stub.py_sha256"] = get_file_sha256(launcher_stub_path)
     return launcher_metadata
 
 

pyship/launcher_stub.py

@@ -0,0 +1,198 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Union
+
+from typeguard import typechecked
+from balsa import get_logger
+
+from pyship import __application_name__
+
+log = get_logger(__application_name__)
+
+# C# source template for the launcher stub.
+# Placeholders: {app_name}
+# The stub finds the latest CLIP directory and runs the standalone Python launcher script.
+CS_LAUNCHER_TEMPLATE = r"""
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+
+class Program
+{{
+    static int Main(string[] args)
+    {{
+        string appName = "{app_name}";
+        string exePath = Assembly.GetEntryAssembly().Location;
+        string launcherDir = Path.GetDirectoryName(exePath);
+        string appDir = Directory.GetParent(launcherDir).FullName;
+
+        // Find CLIP directories matching appName_version pattern
+        string searchPattern = appName + "_*";
+        string[] clipDirs;
+        try
+        {{
+            clipDirs = Directory.GetDirectories(appDir, searchPattern);
+        }}
+        catch (Exception)
+        {{
+            clipDirs = new string[0];
+        }}
+
+        // Filter to directories that contain Scripts\python.exe
+        var validClips = clipDirs
+            .Where(d => File.Exists(Path.Combine(d, "Scripts", "python.exe")))
+            .ToArray();
+
+        if (validClips.Length == 0)
+        {{
+            string msg = "No Python environment found for " + appName + " in " + appDir;
+            {error_handler}
+            return 1;
+        }}
+
+        // Sort by version (directory name after appName_) and pick the latest
+        Array.Sort(validClips, (a, b) =>
+        {{
+            string verA = Path.GetFileName(a).Substring(appName.Length + 1);
+            string verB = Path.GetFileName(b).Substring(appName.Length + 1);
+            return CompareVersions(verA, verB);
+        }});
+
+        string latestClip = validClips[validClips.Length - 1];
+        string pythonExe = Path.Combine(latestClip, "Scripts", "python.exe");
+        string launcherScript = Path.Combine(launcherDir, appName + "_launcher.py");
+
+        if (!File.Exists(launcherScript))
+        {{
+            string msg = "Launcher script not found: " + launcherScript;
+            {error_handler}
+            return 1;
+        }}
+
+        // Build arguments: launcher script path + forwarded args
+        string arguments = "\"" + launcherScript + "\" --app-dir \"" + appDir + "\"";
+        foreach (string arg in args)
+        {{
+            arguments += " \"" + arg + "\"";
+        }}
+
+        ProcessStartInfo psi = new ProcessStartInfo();
+        psi.FileName = pythonExe;
+        psi.Arguments = arguments;
+        psi.UseShellExecute = false;
+        psi.WorkingDirectory = launcherDir;
+
+        try
+        {{
+            Process process = Process.Start(psi);
+            process.WaitForExit();
+            return process.ExitCode;
+        }}
+        catch (Exception ex)
+        {{
+            string msg = "Failed to start: " + ex.Message;
+            {error_handler}
+            return 1;
+        }}
+    }}
+
+    static int CompareVersions(string a, string b)
+    {{
+        string[] partsA = a.Split('.');
+        string[] partsB = b.Split('.');
+        int maxLen = Math.Max(partsA.Length, partsB.Length);
+        for (int i = 0; i < maxLen; i++)
+        {{
+            int numA = 0, numB = 0;
+            if (i < partsA.Length) int.TryParse(partsA[i], out numA);
+            if (i < partsB.Length) int.TryParse(partsB[i], out numB);
+            if (numA != numB) return numA.CompareTo(numB);
+        }}
+        return 0;
+    }}
+}}
+"""
+
+CLI_ERROR_HANDLER = "Console.Error.WriteLine(msg);"
+GUI_ERROR_HANDLER = "System.Windows.Forms.MessageBox.Show(msg, appName, System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);"
+
+
+@typechecked
+def _find_csc_exe() -> Union[Path, None]:
+    """
+    Locate the C# compiler (csc.exe) from .NET Framework.
+    :return: path to csc.exe or None if not found
+    """
+    candidates = [
+        Path(r"C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe"),
+        Path(r"C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe"),
+    ]
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+    return None
+
+
+@typechecked
+def compile_launcher_stub(app_name: str, icon_path: Union[Path, None], is_gui: bool, output_path: Path) -> Path:
+    """
+    Compile the C# launcher stub into an .exe using csc.exe.
+    :param app_name: target application name
+    :param icon_path: path to .ico file (or None for no icon)
+    :param is_gui: True for GUI app (winexe target), False for CLI (exe target)
+    :param output_path: directory where the .exe will be written
+    :return: path to the compiled .exe
+    """
+    csc_exe = _find_csc_exe()
+    if csc_exe is None:
+        raise FileNotFoundError("Could not find csc.exe (.NET Framework C# compiler). Ensure .NET Framework 4.x is installed.")
+
+    error_handler = GUI_ERROR_HANDLER if is_gui else CLI_ERROR_HANDLER
+
+    cs_source = CS_LAUNCHER_TEMPLATE.format(
+        app_name=app_name,
+        error_handler=error_handler,
+    )
+
+    output_path.mkdir(parents=True, exist_ok=True)
+    exe_path = Path(output_path, f"{app_name}.exe")
+
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".cs", delete=False, dir=str(output_path)) as cs_file:
+        cs_file.write(cs_source)
+        cs_file_path = cs_file.name
+
+    try:
+        target = "/target:winexe" if is_gui else "/target:exe"
+        cmd = [
+            str(csc_exe),
+            target,
+            "/optimize+",
+            "/nologo",
+            f"/out:{exe_path}",
+            "/reference:System.Core.dll",  # required for LINQ
+        ]
+
+        if icon_path is not None and icon_path.exists():
+            cmd.append(f"/win32icon:{icon_path}")
+
+        if is_gui:
+            cmd.append("/reference:System.Windows.Forms.dll")
+
+        cmd.append(cs_file_path)
+
+        log.info(f"compiling launcher stub: {cmd}")
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.returncode != 0:
+            log.error(f"csc.exe compilation failed:\nstdout: {result.stdout}\nstderr: {result.stderr}")
+            raise RuntimeError(f"C# compilation failed: {result.stderr}")
+        log.info(f"launcher stub compiled: {exe_path}")
+    finally:
+        try:
+            Path(cs_file_path).unlink()
+        except OSError:
+            pass
+
+    return exe_path

pyship/nsis.py

@@ -7,9 +7,11 @@ import shutil
 from typeguard import typechecked
 from balsa import get_logger
 
+from typing import Union
+
 from pyshipupdate import mkdirs, get_target_os
 from pyship import __application_name__, AppInfo, subprocess_run, pyship_print, get_icon, PyshipLicenseFileDoesNotExist
-
+from pyship.constants import is_ci
 
 log = get_logger(__application_name__)
 
@@ -29,13 +31,13 @@ def get_folder_size(folder_path: Path) -> int:
 
 
 @typechecked
-def run_nsis(target_app_info: AppInfo, target_app_version: VersionInfo, app_dir: Path) -> Path:
+def run_nsis(target_app_info: AppInfo, target_app_version: VersionInfo, app_dir: Path) -> Union[Path, None]:
     """
     run nsis
     :param target_app_info: target app info
     :param target_app_version: target app version
     :param app_dir: application dir
-    :return: path to installer exe, or None if could not be created
+    :return: path to installer exe, or None if NSIS not available (e.g. in CI)
     """
 
     # basic format is from:
@@ -97,6 +99,7 @@ def run_nsis(target_app_info: AppInfo, target_app_version: VersionInfo, app_dir:
         nsis_lines.append('Name "${COMPANYNAME} - ${APPNAME}"')
         nsis_lines.append(f"Icon {icon_path}")
         nsis_lines.append(f'outFile "{installer_exe_path}"')
+        nsis_lines.append("SetCompressor LZMA")
         nsis_lines.append("")
         nsis_lines.append("!include LogicLib.nsh")
 
@@ -214,8 +217,12 @@ def run_nsis(target_app_info: AppInfo, target_app_version: VersionInfo, app_dir:
         if os.path.exists(make_nsis_path):
             subprocess_run([make_nsis_path, nsis_file_path], target_app_info.project_dir)
         else:
-            log.fatal(f"{make_nsis_path} not found - see http://nsis.sourceforge.net to get NSIS (Nullsoft Scriptable Install System)")
-            raise FileNotFoundError(make_nsis_path)
+            if is_ci():
+                log.warning(f"{make_nsis_path} not found - skipping installer creation (running in CI)")
+                return None
+            else:
+                log.fatal(f"{make_nsis_path} not found - see http://nsis.sourceforge.net to get NSIS (Nullsoft Scriptable Install System)")
+                raise FileNotFoundError(make_nsis_path)
 
     else:
         log.error(f"{license_file_name} file does not exist at {target_app_info.project_dir}")

pyship/pyship.py

@@ -2,7 +2,7 @@ from pathlib import Path
 from datetime import datetime
 from typing import Union
 
-import appdirs
+import platformdirs
 from attr import attrs
 from typeguard import typechecked
 from awsimple import S3Access
@@ -25,7 +25,7 @@ class PyShip:
     project_dir: Path = Path()  # target app project dir, e.g. the "home" directory of the project.  If not set, current working directory is used.
     dist_dir: Path = Path(DEFAULT_DIST_DIR_NAME)  # many packaging tools (e.g filt, etc.) use "dist" as the package destination directory
     find_links: list = list()  # extra dirs for pip to use for packages not yet on PyPI (e.g. under local development)
-    cache_dir: Path = Path(appdirs.user_cache_dir(pyship_application_name, pyship_author))  # used to cache things like the embedded Python zip (to keep us off the python.org servers)
+    cache_dir: Path = Path(platformdirs.user_cache_dir(pyship_application_name, pyship_author))  # used to cache things like the embedded Python zip (to keep us off the python.org servers)
 
     # cloud credentials, locations, etc.
     cloud_bucket: Union[str, None] = None  # e.g. AWS S3 bucket
@@ -36,16 +36,16 @@ class PyShip:
     upload: bool = True  # set to False in order to tell pyship to not attempt to perform file upload to the cloud (e.g. installer, clip files to AWS S3)
 
     @typechecked
-    def ship(self) -> Path:
+    def ship(self) -> Union[Path, None]:
         """
         Perform all the steps to ship the app, including creating the installer.
-        :return: the path to the created installer or None if it could not be created
+        :return: the path to the created installer, or None if installer could not be created (e.g. NSIS not available in CI)
         """
 
         start_time = datetime.now()
         pyship_print(f"{pyship_application_name} starting (pyship={str(pyship_version)},pyshipupdate={str(pyshipupdate_version)})")
 
-        target_app_info = get_app_info(self.project_dir, self.dist_dir)
+        target_app_info = get_app_info(self.project_dir, self.dist_dir, self.cache_dir)
 
         if self.project_dir is None:
             assert isinstance(self.project_dir, Path)
@@ -61,13 +61,13 @@ class PyShip:
 
             create_pyship_launcher(target_app_info, app_dir)  # create the OS specific launcher executable
 
-            clip_dir = create_clip(target_app_info, app_dir, True, Path(self.project_dir, self.dist_dir), self.cache_dir, self.find_links)
+            clip_dir = create_clip(target_app_info, app_dir, Path(self.project_dir, self.dist_dir), self.cache_dir, self.find_links)
 
             clip_file_path = create_clip_file(clip_dir)  # create clip file
             assert isinstance(target_app_info.version, VersionInfo)
-            installer_exe_path = run_nsis(target_app_info, target_app_info.version, app_dir)  # create installer
+            installer_exe_path = run_nsis(target_app_info, target_app_info.version, app_dir)  # create installer (may be None in CI)
 
-            if self.upload:
+            if self.upload and installer_exe_path is not None:
                 if self.cloud_profile is None and self.cloud_id is None:
                     pyship_print("no cloud access provided - will not attempt upload")
                 else:

pyship/pyship_custom_print.py

@@ -16,7 +16,6 @@ window.withdraw()  # no main window
 def pyship_print(s: str, is_gui: bool = False):
     log.info(s)
     if is_gui:
-        global window
         label = Label(window, text=s)  # adds to the window each time
         label.grid()
         label.update()

pyship/pyship_get_icon.py

@@ -10,7 +10,7 @@ import pyship
 log = get_logger(__application_name__)
 
 
-@typechecked()
+@typechecked
 def get_icon(target_app_info: AppInfo, ui_print: Callable) -> Path:
     """
     find either the target project's icon or the provided icon from pyship
@@ -48,4 +48,6 @@ def get_icon(target_app_info: AppInfo, ui_print: Callable) -> Path:
         log.info(s)
         ui_print(s)
 
+    assert icon_path is not None
+
     return icon_path