Conda apps working on macOS.

Author: freakboy3742

src/briefcase/commands/base.py

@@ -156,7 +156,7 @@ class BaseCommand(ABC):
     def __init__(
         self,
         console: Console,
-        tools: ToolCache = None,
+        tools: ToolCache | None = None,
         apps: dict[str, AppConfig] | None = None,
         base_path: Path | None = None,
         data_path: Path | None = None,
@@ -725,15 +725,6 @@ def verify_tools(self):
         """
         return
 
-    def verify_env_manager(self, app: AppConfig):
-        """Verify that the requested environment manager can be used."""
-        if app.env_manager not in self.supported_env_managers:
-            raise BriefcaseConfigError(
-                f"{app.app_name!r} declares the use of a {app.env_manager!r} "
-                f"environment, but {self.platform} {self.output_format} "
-                f"projects do not support environments of that type."
-            )
-
     def finalize_app_config(self, app: DraftAppConfig, **kwargs) -> FinalizedAppConfig:
         """Finalize the application config.
 
@@ -746,14 +737,21 @@ def finalize_app_config(self, app: DraftAppConfig, **kwargs) -> FinalizedAppConf
         configuration, and performs any other app-specific platform configuration and
         verification that is required as a result of command-line arguments.
 
-        Platform overrides should call ``super().finalize_app_config(app, **kwargs)``
-        to construct the ``FinalizedAppConfig``.
+        Platform overrides should call `super().finalize_app_config(app, **kwargs)`
+        to construct the `FinalizedAppConfig`.
 
         :param app: The app configuration to finalize.
         :param kwargs: Runtime attributes forwarded to the FinalizedAppConfig
-            constructor (``test_mode``, ``debugger``, etc.).
+            constructor (`test_mode`, `debugger`, etc.).
         :returns: The finalized app configuration.
         """
+        if app.env_manager not in self.supported_env_managers:
+            raise BriefcaseConfigError(
+                f"{app.app_name!r} declares the use of a {app.env_manager!r} "
+                f"environment, but {self.platform} {self.output_format} "
+                f"projects do not support environments of that type."
+            )
+
         return FinalizedAppConfig(app, **kwargs)
 
     def resolve_apps(
@@ -809,8 +807,6 @@ def finalize(
         finalized: dict[str, FinalizedAppConfig] = {}
         for app in apps:
             if not isinstance(app, FinalizedAppConfig):
-                self.verify_env_manager(app)
-
                 app = self.finalize_app_config(
                     app,
                     test_mode=test_mode,

src/briefcase/commands/create.py

@@ -120,26 +120,22 @@ def support_package_url(self, support_revision: str) -> str:
             f"{self.support_package_filename(support_revision)}"
         )
 
-    def stub_binary_filename(self, support_revision: str, is_console_app: bool) -> str:
+    def stub_binary_filename(
+        self,
+        support_revision: str,
+        app: FinalizedAppConfig,
+    ) -> str:
         """The filename for the stub binary."""
-        stub_type = "Console" if is_console_app else "GUI"
-        win_suffix = (
-            f"-{self.tools.host_arch.lower()}"
-            if self.tools.host_os == "Windows"
-            else ""
-        )
-        return (
-            f"{stub_type}-Stub-{self.python_version_tag}{win_suffix}"
-            f"-b{support_revision}.zip"
-        )
+        stub_type = "Console" if app.console_app else "GUI"
+        return f"{stub_type}-Stub-{self.python_version_tag}-b{support_revision}.zip"
 
-    def stub_binary_url(self, support_revision: str, is_console_app: bool) -> str:
+    def stub_binary_url(self, support_revision: str, app: FinalizedAppConfig) -> str:
         """The URL of the stub binary to use for apps of this type."""
         return (
             "https://briefcase-support.s3.amazonaws.com/python/"
             f"{self.python_version_tag}/"
             f"{self.platform}/"
-            f"{self.stub_binary_filename(support_revision, is_console_app)}"
+            f"{self.stub_binary_filename(support_revision, app)}"
         )
 
     def icon_targets(self, app: FinalizedAppConfig):
@@ -296,15 +292,14 @@ def app_environment(
         app: FinalizedAppConfig,
         host_arch: str | None = None,
     ) -> dict[str, VirtualEnvironment]:
-        """Create an isolated virtual environment for the."""
+        """Create an isolated virtual environment in which the app can be built."""
         if host_arch is None:
             host_arch = self.tools.host_arch
 
-        env_name = f"{app.env_manager}-{self.tools.host_os}-{self.tools.host_arch}"
-        venv = self.tools.virtual_environment(
-            env_manager=app.env_manager,
+        env_name = f"{app.env_manager}-{self.platform}-{self.tools.host_arch}"
+        venv = self.tools.virtual_environment[app.env_manager](
+            tools=self.tools,
             venv_path=self.base_path / ".briefcase/" / app.app_name / env_name,
-            isolated=True,
             platform=self.platform,
             arch=host_arch,
         )
@@ -510,9 +505,7 @@ def _download_stub_binary(self, app: FinalizedAppConfig) -> Path:
                 except AttributeError:
                     stub_binary_revision = self.stub_binary_revision(app)
 
-                stub_binary_url = self.stub_binary_url(
-                    stub_binary_revision, app.console_app
-                )
+                stub_binary_url = self.stub_binary_url(stub_binary_revision, app=app)
                 custom_stub_binary = False
                 self.console.info(f"Using stub binary {stub_binary_url}")
 
@@ -947,6 +940,7 @@ def create_app(self, app: FinalizedAppConfig, **options):
                 prefix=app.app_name,
             )
         else:
+            self.console.info("Creating app environment...", prefix=app.app_name)
             venv = self.app_environment(app=app)
 
             if not venv.provides_python:
@@ -983,7 +977,7 @@ def create_app(self, app: FinalizedAppConfig, **options):
                 self.console.info(
                     "Installing managed Python environment...", prefix=app.app_name
                 )
-                self.install_managed_python_env(app=app)
+                self.install_managed_python_env(app=app, venv=venv)
 
             self.console.info("Removing unneeded app content...", prefix=app.app_name)
             self.cleanup_app_content(app=app)

src/briefcase/commands/dev.py

@@ -291,14 +291,16 @@ def __call__(
 
         if isolated:
             self.console.info("Activating dev environment...", prefix=app.app_name)
+            env_manager = app.env_manager
+        else:
+            env_manager = None
 
-        venv = self.tools.virtual_environment(
-            env_manager=app.env_manager,
+        venv = self.tools.virtual_environment[env_manager](
+            tools=self.tools,
             venv_path=(
                 self.base_path
                 / f".briefcase/{app.app_name}/{app.env_manager}-{self.venv_name}"
             ),
-            isolated=isolated,
         )
         created = venv.prepare(recreate=update_requirements)
 

src/briefcase/integrations/virtual_environment/base.py

@@ -11,6 +11,8 @@
 class VirtualEnvironment(ABC):
     """A managed Python environment."""
 
+    provides_python: bool = False
+
     def __init__(
         self,
         tools: ToolCache,
@@ -33,10 +35,6 @@ def __init__(
         self.platform = platform
         self.arch = arch
 
-    @property
-    def provides_python(self) -> bool:
-        return False
-
     @property
     def bin_dir(self) -> Path:
         """The venv's binary directory (`bin` on POSIX, `Scripts` on Windows)."""

src/briefcase/integrations/virtual_environment/conda.py

@@ -19,9 +19,7 @@ class CondaVirtualEnvironment(VirtualEnvironment):
     (prepending the environment's binary directory to ``PATH``).
     """
 
-    @property
-    def provides_python(self) -> bool:
-        return False
+    provides_python: bool = True
 
     @property
     def python_version(self) -> str:
@@ -71,12 +69,15 @@ def prepare(self, recreate=False) -> bool:
                 )
                 if self.platform:
                     match self.platform, self.arch:
-                        case "darwin", "arm64":
+                        case "macOS", "arm64":
                             conda_subdir = "osx-arm64"
-                        case "darwin", "x86_64":
+                        case "macOS", "x86_64":
                             conda_subdir = "osx-64"
                         case _, _:
-                            raise BriefcaseCommandError("Unsupported platform")
+                            raise BriefcaseCommandError(
+                                "Briefcase cannot create a Conda environment "
+                                f"for {self.platform} {self.arch}"
+                            )
 
                     self.tools.subprocess.run(
                         [

src/briefcase/integrations/virtual_environment/pixi.py

@@ -19,9 +19,7 @@ class PixiVirtualEnvironment(VirtualEnvironment):
     directory and Python executable are resolved relative to that location.
     """
 
-    @property
-    def provides_python(self) -> bool:
-        return False
+    provides_python: bool = True
 
     @property
     def python_version(self) -> str:

src/briefcase/integrations/virtual_environment/tool.py

@@ -1,5 +1,3 @@
-from pathlib import Path
-
 from briefcase.config import EnvManagerT
 from briefcase.integrations.base import Tool, ToolCache
 from briefcase.integrations.virtual_environment.base import VirtualEnvironment
@@ -24,15 +22,10 @@ def verify_install(cls, tools: ToolCache, **kwargs) -> "VirtualEnvironmentManage
         tools.virtual_environment = VirtualEnvironmentManager(tools=tools)
         return tools.virtual_environment
 
-    def __call__(
+    def __getitem__(
         self,
-        venv_path: Path,
-        *,
-        isolated: bool = True,
-        platform: str | None = None,
-        arch: str | None = None,
-        env_manager: EnvManagerT = "venv",
-    ) -> VirtualEnvironment:
+        env_manager: EnvManagerT | None = "venv",
+    ) -> type[VirtualEnvironment]:
         """Construct and return a `VirtualEnvironment` for the requested mode.
 
         The constructor of the returned object performs the lifecycle work
@@ -52,19 +45,10 @@ def __call__(
         :raises BriefcaseCommandError: if the environment cannot be created or
             initialised.
         """
-        if not isolated:
-            env_manager = None
-
-        venv: VirtualEnvironment = {
+        return {
             None: NoOpVirtualEnvironment,
             "uv": UvVirtualEnvironment,
+            "venv": VenvVirtualEnvironment,
             "conda": CondaVirtualEnvironment,
             "pixi": PixiVirtualEnvironment,
-        }.get(env_manager, VenvVirtualEnvironment)(
-            self.tools,
-            venv_path,
-            platform=platform,
-            arch=arch,
-        )
-
-        return venv
+        }[env_manager]

src/briefcase/integrations/virtual_environment/uv.py

@@ -147,17 +147,21 @@ def install_requirements(
             that can be displayed to the user.
         """
         uv_deps = []
+        has_source_deps = False
         for req in requires:
             # Any requirement that is a local path, but *not* a reference to an archive
             # file (zip, tgz, etc) or wheel can be installed editable. If in doubt,
             # install non-editable.
             if (
-                allow_editable
-                and self.tools.file.is_local_path(req)
+                self.tools.file.is_local_path(req)
                 and not self.tools.file.is_archive(req)
                 and Path(req).suffix != ".whl"
             ):
-                uv_deps.extend(["--no-binary", req, "-e", req])
+                has_source_deps = True
+                if allow_editable:
+                    uv_deps.extend(["-e", req])
+                else:
+                    uv_deps.append(req)
             else:
                 uv_deps.append(req)
 
@@ -172,7 +176,10 @@ def install_requirements(
                     if min_os_version and self.platform == "darwin":
                         env = {"MACOSX_DEPLOYMENT_TARGET": min_os_version}
 
-            if require_binary:
+            if require_binary and not has_source_deps:
+                # uv can't install a local directory if `--only-binary` is specified.
+                # --only-binary is *required* for normal pip when --platform is used;
+                # but it's not required for uv when using `--python-platform`.
                 install_args.extend(["--only-binary", ":all:"])
 
             if not include_deps:

src/briefcase/platforms/macOS/__init__.py

@@ -206,6 +206,31 @@ def generate_app_template(self, app: FinalizedAppConfig):
         # picked up on the next run of any Briefcase command).
         self.verify_not_on_icloud(app, cleanup=True)
 
+    def output_format_template_context(self, app: FinalizedAppConfig):
+        """Additional template context required by the output format.
+
+        :param app: The config object for the app
+        """
+        # If the environment manager provides Python, it will be in `libPython3.X`
+        # format, rather than Python.XCframework format.
+        venv_class = self.tools.virtual_environment[app.env_manager]
+        return {
+            "use_framework": not venv_class.provides_python,
+        }
+
+    def stub_binary_filename(
+        self,
+        support_revision: str,
+        app: FinalizedAppConfig,
+    ) -> str:
+        """The filename for the stub binary."""
+        stub_type = "Console" if app.console_app else "GUI"
+        venv_class = self.tools.virtual_environment[app.env_manager]
+        if self.tools.host_os == "Darwin" and venv_class.provides_python:
+            stub_type = f"L{stub_type}"
+
+        return f"{stub_type}-Stub-{self.python_version_tag}-b{support_revision}.zip"
+
     def _install_app_requirements(
         self,
         app: FinalizedAppConfig,
@@ -331,6 +356,9 @@ def _install_app_requirements(
                 other_suffix=f"_{other_arch}",
             )
             if binary_packages:
+                self.console.info(
+                    f"Creating {other_arch} app environment...", prefix=app.app_name
+                )
                 other_venv = self.app_environment(app, host_arch=other_arch)
                 with self.console.wait_bar(
                     f"Installing binary app requirements for {other_arch}..."

src/briefcase/platforms/macOS/app.py

@@ -13,6 +13,7 @@
     UpdateCommand,
 )
 from briefcase.config import FinalizedAppConfig
+from briefcase.integrations.virtual_environment import VirtualEnvironment
 from briefcase.platforms.macOS import (
     SigningIdentity,
     macOSCreateMixin,
@@ -87,14 +88,18 @@ def install_app_resources(self, app: FinalizedAppConfig):
         # cache for the app, ensuring the current icon is loaded.
         self.binary_path(app).touch(exist_ok=True)
 
-    def install_managed_python_env(self, app: FinalizedAppConfig):
+    def install_managed_python_env(
+        self,
+        app: FinalizedAppConfig,
+        venv: VirtualEnvironment,
+    ):
         """Copy the managed Python environment into the app bundle."""
         runtime_support_path = self.support_path(app, runtime=True)
         if runtime_support_path.is_dir():
             self.tools.shutil.rmtree(runtime_support_path)
 
         self.tools.shutil.copytree(
-            self.venv_path(app),
+            venv.venv_path,
             runtime_support_path,
             symlinks=True,
         )