Initial MSI implementation, based on Briefcase

.gitignore

@@ -150,8 +150,13 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
+
+# VS Code
 .vscode/
 
+# macOS
+.DS_Store
+
 # Rever
 rever/
 

constructor/briefcase.py

@@ -0,0 +1,150 @@
+"""
+Logic to build installers using Briefcase.
+"""
+
+import logging
+import re
+import shutil
+import sysconfig
+import tempfile
+from pathlib import Path
+from subprocess import run
+
+import tomli_w
+
+from . import preconda
+from .utils import DEFAULT_REVERSE_DOMAIN_ID, copy_conda_exe, filename_dist
+
+BRIEFCASE_DIR = Path(__file__).parent / "briefcase"
+EXTERNAL_PACKAGE_PATH = "external"
+
+logger = logging.getLogger(__name__)
+
+
+def get_name_version(info):
+    name = info["name"]
+    if not name:
+        raise ValueError("Name is empty")
+
+    # Briefcase requires version numbers to be in the canonical Python format, and some
+    # installer types use the version to distinguish between upgrades, downgrades and
+    # reinstalls. So try to produce a consistent ordering by extracting the last valid
+    # version from the Constructor version string.
+    #
+    # Hyphens aren't allowed in this format, but for compatibility with Miniconda's
+    # version format, we treat them as dots.
+    matches = list(
+        re.finditer(
+            r"(\d+!)?\d+(\.\d+)*((a|b|rc)\d+)?(\.post\d+)?(\.dev\d+)?",
+            info["version"].lower().replace("-", "."),
+        )
+    )
+    if not matches:
+        raise ValueError(
+            f"Version {info['version']!r} contains no valid version numbers: see "
+            f"https://packaging.python.org/en/latest/specifications/version-specifiers/"
+        )
+    match = matches[-1]
+    version = match.group()
+
+    # Treat anything else in the version string as part of the name.
+    start, end = match.span()
+    strip_chars = " .-_"
+    before = info["version"][:start].strip(strip_chars)
+    after = info["version"][end:].strip(strip_chars)
+    name = " ".join(s for s in [name, before, after] if s)
+
+    return name, version
+
+
+# Some installer types use the reverse domain ID to detect when the product is already
+# installed, so it should be both unique between different products, and stable between
+# different versions of a product.
+def get_bundle_app_name(info, name):
+    # If reverse_domain_identifier is provided, use it as-is, but verify that the last
+    # component is a valid Python package name, as Briefcase requires.
+    if (rdi := info.get("reverse_domain_identifier")) is not None:
+        if "." not in rdi:
+            raise ValueError(f"reverse_domain_identifier {rdi!r} contains no dots")
+        bundle, app_name = rdi.rsplit(".", 1)
+
+        if not re.fullmatch(
+            r"[A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9]", app_name, flags=re.IGNORECASE
+        ):
+            raise ValueError(
+                f"reverse_domain_identifier {rdi!r} doesn't end with a valid package "
+                f"name: see "
+                f"https://packaging.python.org/en/latest/specifications/name-normalization/"
+            )
+
+    # If reverse_domain_identifier isn't provided, generate it from the name.
+    else:
+        bundle = DEFAULT_REVERSE_DOMAIN_ID
+        app_name = re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")
+        if not app_name:
+            raise ValueError(f"Name {name!r} contains no alphanumeric characters")
+
+    return bundle, app_name
+
+
+# Create a Briefcase configuration file. Using a full TOML writer rather than a Jinja
+# template allows us to avoid escaping strings everywhere.
+def write_pyproject_toml(tmp_dir, info):
+    name, version = get_name_version(info)
+    bundle, app_name = get_bundle_app_name(info, name)
+
+    config = {
+        "project_name": name,
+        "bundle": bundle,
+        "version": version,
+        "license": ({"file": info["license_file"]} if "license_file" in info else {"text": ""}),
+        "app": {
+            app_name: {
+                "formal_name": f"{info['name']} {info['version']}",
+                "description": "",  # Required, but not used in the installer.
+                "external_package_path": EXTERNAL_PACKAGE_PATH,
+                "external_package_executable_path": "",
+                "use_full_install_path": False,
+                "post_install_script": str(BRIEFCASE_DIR / "run_installation.bat"),
+            }
+        },
+    }
+
+    if "company" in info:
+        config["author"] = info["company"]
+
+    (tmp_dir / "pyproject.toml").write_text(tomli_w.dumps({"tool": {"briefcase": config}}))
+
+
+def create(info, verbose=False):
+    tmp_dir = Path(tempfile.mkdtemp())
+    write_pyproject_toml(tmp_dir, info)
+
+    external_dir = tmp_dir / EXTERNAL_PACKAGE_PATH
+    external_dir.mkdir()
+    preconda.write_files(info, external_dir)
+    preconda.copy_extra_files(info.get("extra_files", []), external_dir)
+
+    download_dir = Path(info["_download_dir"])
+    pkgs_dir = external_dir / "pkgs"
+    for dist in info["_dists"]:
+        shutil.copy(download_dir / filename_dist(dist), pkgs_dir)
+
+    copy_conda_exe(external_dir, "_conda.exe", info["_conda_exe"])
+
+    briefcase = Path(sysconfig.get_path("scripts")) / "briefcase.exe"
+    logger.info("Building installer")
+    run(
+        [briefcase, "package"] + (["-v"] if verbose else []),
+        cwd=tmp_dir,
+        check=True,
+    )
+
+    dist_dir = tmp_dir / "dist"
+    msi_paths = list(dist_dir.glob("*.msi"))
+    if len(msi_paths) != 1:
+        raise RuntimeError(f"Found {len(msi_paths)} MSI files in {dist_dir}")
+    shutil.copy(msi_paths[0], info["_outpath"])
+
+    if not info.get("_debug"):
+        shutil.rmtree(tmp_dir)

constructor/briefcase/run_installation.bat

@@ -0,0 +1,9 @@
+_conda constructor --prefix . --extract-conda-pkgs
+
+set CONDA_PROTECT_FROZEN_ENVS=0
+set CONDA_ROOT_PREFIX=%cd%
+set CONDA_SAFETY_CHECKS=disabled
+set CONDA_EXTRA_SAFETY_CHECKS=no
+set CONDA_PKGS_DIRS=%cd%\pkgs
+
+_conda install --offline --file conda-meta\initial-state.explicit.txt -yp .

constructor/data/construct.schema.json

@@ -224,6 +224,7 @@
       "enum": [
         "all",
         "exe",
+        "msi",
         "pkg",
         "sh"
       ],

constructor/main.py

@@ -38,7 +38,7 @@
 def get_installer_type(info):
     osname, unused_arch = info["_platform"].split("-")
 
-    os_allowed = {"linux": ("sh",), "osx": ("sh", "pkg"), "win": ("exe",)}
+    os_allowed = {"linux": ("sh",), "osx": ("sh", "pkg"), "win": ("exe", "msi")}
     all_allowed = set(sum(os_allowed.values(), ("all",)))
 
     itype = info.get("installer_type")
@@ -317,6 +317,10 @@ def is_conda_meta_frozen(path_str: str) -> bool:
             from .winexe import create as winexe_create
 
             create = winexe_create
+        elif itype == "msi":
+            from .briefcase import create as briefcase_create
+
+            create = briefcase_create
         info["installer_type"] = itype
         info["_outpath"] = abspath(join(output_dir, get_output_filename(info)))
         create(info, verbose=verbose)

constructor/osxpkg.py

@@ -21,6 +21,7 @@
 from .jinja import render_template
 from .signing import CodeSign
 from .utils import (
+    DEFAULT_REVERSE_DOMAIN_ID,
     add_condarc,
     approx_size_kb,
     copy_conda_exe,
@@ -390,7 +391,7 @@ def fresh_dir(dir_path):
 def pkgbuild(name, identifier=None, version=None, install_location=None):
     "see `man pkgbuild` for the meaning of optional arguments"
     if identifier is None:
-        identifier = "io.continuum"
+        identifier = DEFAULT_REVERSE_DOMAIN_ID
     args = [
         "pkgbuild",
         "--root",

constructor/utils.py

@@ -26,6 +26,8 @@
 from conda.models.version import VersionOrder
 from ruamel.yaml import YAML
 
+DEFAULT_REVERSE_DOMAIN_ID = "io.continuum"
+
 logger = logging.getLogger(__name__)
 yaml = YAML(typ="rt")
 yaml.default_flow_style = False

dev/environment.yml

@@ -10,3 +10,4 @@ dependencies:
   - jinja2
   - jsonschema >=4
   - pydantic 2.11.*
+  - tomli-w >=1.2.0

docs/source/construct-yaml.md

@@ -235,6 +235,7 @@ The type of the installer being created. Possible values are:
 - `sh`: shell-based installer for Linux or macOS
 - `pkg`: macOS GUI installer built with Apple's `pkgbuild`
 - `exe`: Windows GUI installer built with NSIS
+- `msi`: Windows GUI installer built with Briefcase and WiX
 
 The default type is `sh` on Linux and macOS, and `exe` on Windows. A special
 value of `all` builds _both_ `sh` and `pkg` installers on macOS, as well
@@ -317,8 +318,11 @@ Name of the company/entity responsible for the installer.
 ### `reverse_domain_identifier`
 
 Unique identifier for this package, formatted with reverse domain notation. This is
-used internally in the PKG installers to handle future updates and others. If not
-provided, it will default to `io.continuum`. (MacOS only)
+used internally in the MSI and PKG installers to handle future updates and others. If
+not provided, it will default to:
+
+* In MSI installers: `io.continuum` followed by an ID derived from the `name`.
+* In PKG installers: `io.continuum`.
 
 ### `uninstall_name`
 

docs/source/howto.md

@@ -7,10 +7,12 @@ which it is running. In other words, if you run constructor on a Windows
 computer, you can only generate Windows installers. This is largely because
 OS-native tools are needed to generate the Windows `.exe` files and macOS `.pkg`
 files. There is a key in `construct.yaml`, `installer_type`, which dictates
-the type of installer that gets generated. This is primarily only useful for
-macOS, where you can generate either `.pkg` or `.sh` installers. When not set in
-`construct.yaml`, this value defaults to `.sh` on Unix platforms, and `.exe` on
-Windows. Using this key is generally done with selectors.  For example, to
+the type of installer that gets generated. This is useful for macOS, where you can
+generate either `.pkg` or `.sh` installers, and Windows, where you can generate
+either `.exe` or `.msi` installers.
+
+When not set in`construct.yaml`, this value defaults to `.sh` on Unix platforms, and
+`.exe` on Windows. Using this key is generally done with selectors.  For example, to
 build a `.pkg` installer on MacOS, but fall back to default behavior on other
 platforms:
 

pyproject.toml

@@ -16,7 +16,8 @@ dependencies = [
     "ruamel.yaml >=0.11.14,<0.19",
     "pillow >=3.1 ; platform_system=='Windows' or platform_system=='Darwin'",
     "jinja2",
-    "jsonschema >=4"
+    "jsonschema >=4",
+    "tomli-w >=1.2.0",
 ]
 
 [project.optional-dependencies]

recipe/meta.yaml

@@ -30,6 +30,7 @@ requirements:
     - jsonschema >=4
     - pillow >=3.1     # [win or osx]
     - nsis >=3.08      # [win]
+    - tomli-w >=1.2.0
   run_constrained:     # [unix]
     - nsis >=3.08      # [unix]
     - conda-libmamba-solver !=24.11.0

tests/test_briefcase.py

@@ -0,0 +1,101 @@
+import pytest
+
+from constructor.briefcase import get_bundle_app_name, get_name_version
+
+
+@pytest.mark.parametrize(
+    "name_in, version_in, name_expected, version_expected",
+    [
+        # Valid versions
+        ("Miniconda", "1", "Miniconda", "1"),
+        ("Miniconda", "1.2", "Miniconda", "1.2"),
+        ("Miniconda", "1.2.3", "Miniconda", "1.2.3"),
+        ("Miniconda", "1.2a1", "Miniconda", "1.2a1"),
+        ("Miniconda", "1.2b2", "Miniconda", "1.2b2"),
+        ("Miniconda", "1.2rc3", "Miniconda", "1.2rc3"),
+        ("Miniconda", "1.2.post4", "Miniconda", "1.2.post4"),
+        ("Miniconda", "1.2.dev5", "Miniconda", "1.2.dev5"),
+        ("Miniconda", "1.2rc3.post4.dev5", "Miniconda", "1.2rc3.post4.dev5"),
+        # Hyphens are treated as dots
+        ("Miniconda", "1.2-3", "Miniconda", "1.2.3"),
+        ("Miniconda", "1.2-3.4-5.6", "Miniconda", "1.2.3.4.5.6"),
+        # Additional text before and after the last valid version should be treated as
+        # part of the name.
+        ("Miniconda", "1.2 3.4 5.6", "Miniconda 1.2 3.4", "5.6"),
+        ("Miniconda", "1.2_3.4_5.6", "Miniconda 1.2_3.4", "5.6"),
+        ("Miniconda", "1.2c3", "Miniconda 1.2c", "3"),
+        ("Miniconda", "1.2rc3.dev5.post4", "Miniconda 1.2rc3.dev5.post", "4"),
+        ("Miniconda", "py313", "Miniconda py", "313"),
+        ("Miniconda", "py.313", "Miniconda py", "313"),
+        ("Miniconda", "py3.13", "Miniconda py", "3.13"),
+        ("Miniconda", "py313_1.2", "Miniconda py313", "1.2"),
+        ("Miniconda", "1.2 and more", "Miniconda and more", "1.2"),
+        ("Miniconda", "1.2! and more", "Miniconda ! and more", "1.2"),
+        ("Miniconda", "py313 1.2 and more", "Miniconda py313 and more", "1.2"),
+        # Numbers in the name are not added to the version.
+        ("Miniconda3", "1", "Miniconda3", "1"),
+    ],
+)
+def test_name_version(name_in, version_in, name_expected, version_expected):
+    name_actual, version_actual = get_name_version(
+        {"name": name_in, "version": version_in},
+    )
+    assert (name_actual, version_actual) == (name_expected, version_expected)
+
+
+def test_name_empty():
+    with pytest.raises(ValueError, match="Name is empty"):
+        get_name_version({"name": ""})
+
+
+@pytest.mark.parametrize("version_in", ["", ".", "hello"])
+def test_version_invalid(version_in):
+    with pytest.raises(
+        ValueError, match=f"Version {version_in!r} contains no valid version numbers"
+    ):
+        get_name_version(
+            {"name": "Miniconda3", "version": version_in},
+        )
+
+
+@pytest.mark.parametrize(
+    "rdi, name, bundle_expected, app_name_expected",
+    [
+        ("org.conda", "ignored", "org", "conda"),
+        ("org.Conda", "ignored", "org", "Conda"),
+        ("org.conda-miniconda", "ignored", "org", "conda-miniconda"),
+        ("org.conda_miniconda", "ignored", "org", "conda_miniconda"),
+        ("org-conda.miniconda", "ignored", "org-conda", "miniconda"),
+        ("org.conda.miniconda", "ignored", "org.conda", "miniconda"),
+        (None, "x", "io.continuum", "x"),
+        (None, "X", "io.continuum", "x"),
+        (None, "Miniconda", "io.continuum", "miniconda"),
+        (None, "Miniconda3", "io.continuum", "miniconda3"),
+        (None, "Miniconda3 py313", "io.continuum", "miniconda3-py313"),
+        (None, "Hello, world!", "io.continuum", "hello-world"),
+    ],
+)
+def test_bundle_app_name(rdi, name, bundle_expected, app_name_expected):
+    bundle_actual, app_name_actual = get_bundle_app_name({"reverse_domain_identifier": rdi}, name)
+    assert (bundle_actual, app_name_actual) == (bundle_expected, app_name_expected)
+
+
+@pytest.mark.parametrize("rdi", ["", "org"])
+def test_rdi_no_dots(rdi):
+    with pytest.raises(ValueError, match=f"reverse_domain_identifier '{rdi}' contains no dots"):
+        get_bundle_app_name({"reverse_domain_identifier": rdi}, "ignored")
+
+
+@pytest.mark.parametrize("rdi", ["org.hello-", "org.-hello", "org.hello world", "org.hello!world"])
+def test_rdi_invalid_package(rdi):
+    with pytest.raises(
+        ValueError,
+        match=f"reverse_domain_identifier '{rdi}' doesn't end with a valid package name",
+    ):
+        get_bundle_app_name({"reverse_domain_identifier": rdi}, "ignored")
+
+
+@pytest.mark.parametrize("name", ["", " ", "!", "-", "---"])
+def test_name_no_alphanumeric(name):
+    with pytest.raises(ValueError, match=f"Name '{name}' contains no alphanumeric characters"):
+        get_bundle_app_name({}, name)