flet-cli 1.0.2__tar.gz → 1.0.4__tar.gz

{flet_cli-1.0.2 → flet_cli-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flet-cli
-Version: 1.0.2
+Version: 1.0.4
 Summary: Flet CLI
 Author-email: "Appveyor Systems Inc." <hello@flet.dev>
 License-Expression: Apache-2.0
@@ -9,8 +9,8 @@ Project-URL: Repository, https://github.com/flet-dev/flet
 Project-URL: Documentation, https://flet.dev/docs
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: flet==1.0.2
-Requires-Dist: flet-platform-assets==1.0.2
+Requires-Dist: flet==1.0.4
+Requires-Dist: flet-platform-assets==1.0.4
 Requires-Dist: watchdog>=4.0.0
 Requires-Dist: packaging>=25.0
 Requires-Dist: qrcode>=7.4.2

{flet_cli-1.0.2 → flet_cli-1.0.4}/pyproject.toml

@@ -1,14 +1,14 @@
 [project]
 name = "flet-cli"
-version = "1.0.2"
+version = "1.0.4"
 description = "Flet CLI"
 authors = [{ name = "Appveyor Systems Inc.", email = "hello@flet.dev" }]
 license = "Apache-2.0"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-    "flet==1.0.2",
-    "flet-platform-assets==1.0.2",
+    "flet==1.0.4",
+    "flet-platform-assets==1.0.4",
     "watchdog >=4.0.0",
     "packaging >=25.0",
     "qrcode >=7.4.2",

{flet_cli-1.0.2 → flet_cli-1.0.4}/src/flet_cli/commands/build_base.py

@@ -50,6 +50,7 @@ from flet_cli.utils.android import (
 )
 from flet_cli.utils.app_excludes import find_default_excludes
 from flet_cli.utils.cli import parse_cli_bool_value
+from flet_cli.utils.flutter import get_flutter_dir
 from flet_cli.utils.hash_stamp import HashStamp
 from flet_cli.utils.merge import merge_dict
 from flet_cli.utils.plist import is_supported_plist_value, parse_cli_plist_value
@@ -159,7 +160,7 @@ class BaseBuildCommand(BaseFlutterCommand):
                 "config_platform": "windows",
                 "flutter_build_command": "windows",
                 "status_text": "Windows app",
-                "outputs": ["build/windows/x64/runner/Release/*"],
+                "outputs": ["build/windows/{arch}/runner/Release/*"],
                 "dist": "windows",
                 "can_be_run_on": ["Windows"],
             },
@@ -547,6 +548,14 @@ class BaseBuildCommand(BaseFlutterCommand):
             required=False,
             help="Default color for your web app's user interface (web only)",
         )
+        parser.add_argument(
+            "--pwa-short-name",
+            dest="pwa_short_name",
+            required=False,
+            help="Short name of your web app, shown under its icon when "
+            "installed, e.g. on the iOS Home Screen. Defaults to the product "
+            "name (web only)",
+        )
         parser.add_argument(
             "--no-wasm",
             dest="no_wasm",
@@ -1543,6 +1552,14 @@ class BaseBuildCommand(BaseFlutterCommand):
                 self.options.pwa_theme_color
                 or self.get_pyproject("tool.flet.web.pwa_theme_color")
             ),
+            # The label an installed PWA gets under its icon. It used to be
+            # the project name, a slug such as `my_app`, and iOS shows it on
+            # the Home Screen instead of the `apple-mobile-web-app-title` meta.
+            "pwa_short_name": (
+                self.options.pwa_short_name
+                or self.get_pyproject("tool.flet.web.pwa_short_name")
+                or product_name
+            ),
             "no_wasm": (
                 self.options.no_wasm
                 or self.get_pyproject("tool.flet.web.wasm") == False  # noqa: E712
@@ -3125,6 +3142,49 @@ class BaseBuildCommand(BaseFlutterCommand):
                 )
             self.cleanup(build_result.returncode if build_result.returncode else 1)
 
+    def flutter_sdk_supported(self) -> bool:
+        """
+        Check whether the Flutter SDK found can build for the target platform.
+
+        Flet's Python runtime for Windows is x64-only, so an ARM64 Flutter SDK,
+        as installed natively on Windows on ARM, would build an ARM64 app that
+        can't load it. The Flutter SDK that Flet installs is x64, runs under
+        emulation there, and builds an x64 app that runs on Windows on ARM.
+
+        Returns:
+            `False` for an ARM64 Flutter SDK when building for Windows,
+                otherwise `True`.
+        """
+
+        if (
+            self.current_platform != "Windows"
+            or self.package_platform != "Windows"
+            or self.flutter_arch() != "arm64"
+        ):
+            return True
+
+        flet_flutter_dir = get_flutter_dir(str(self.required_flutter_version))
+        if os.path.normcase(str(self.flutter_exe)).startswith(
+            os.path.normcase(flet_flutter_dir) + os.sep
+        ):
+            self.skip_flutter_doctor = True
+            self.cleanup(
+                1,
+                f"Flet's Flutter SDK at {escape(flet_flutter_dir)} builds ARM64 "
+                "Windows apps, but Flet's Python runtime for Windows is x64-only. "
+                "Delete that directory and run the build again to install the x64 "
+                "Flutter SDK.",
+            )
+
+        console.log(
+            f"The Flutter SDK at {escape(str(self.flutter_exe))} builds ARM64 "
+            "Windows apps, but Flet's Python runtime for Windows is x64-only. "
+            f"Flet will use its own Flutter {self.required_flutter_version} (x64) "
+            "to build an x64 app, which runs on Windows on ARM.",
+            style=warning_style,
+        )
+        return False
+
     def resolve_output_path(self, build_output: str) -> str:
         """
         Resolve a platform `outputs` glob to an absolute path inside the
@@ -3137,7 +3197,11 @@ class BaseBuildCommand(BaseFlutterCommand):
         assert self.flutter_dir
         assert self.template_data
 
-        arch = platform.machine().lower()
+        arch = (
+            self.package_platform == "Windows"
+            and "{arch}" in build_output
+            and self.flutter_arch()
+        ) or platform.machine().lower()
         if arch in {"x86_64", "amd64"}:
             arch = "x64"
         elif arch in {"arm64", "aarch64"}:
@@ -3183,8 +3247,11 @@ class BaseBuildCommand(BaseFlutterCommand):
 
             return ignore
 
+        searched_outputs = []
+        copied = False
         for build_output in self.platforms[self.target_platform]["outputs"]:
             build_output_dir = self.resolve_output_path(build_output)
+            searched_outputs.append(build_output_dir)
 
             if self.verbose > 0:
                 console.log(
@@ -3194,8 +3261,11 @@ class BaseBuildCommand(BaseFlutterCommand):
 
             build_output_glob = os.path.basename(build_output_dir)
             build_output_dir = os.path.dirname(build_output_dir)
-            if not os.path.exists(build_output_dir):
+            if not os.path.isdir(build_output_dir) or not any(
+                build_output_glob in ("*", f) for f in os.listdir(build_output_dir)
+            ):
                 continue
+            copied = True
 
             if self.out_dir.exists():
                 rmtree(str(self.out_dir))
@@ -3208,6 +3278,13 @@ class BaseBuildCommand(BaseFlutterCommand):
                 ignore=make_ignore_fn(build_output_dir, build_output_glob),
             )
 
+        if not copied:
+            self.cleanup(
+                1,
+                "Build output not found in "
+                + ", ".join(escape(path) for path in searched_outputs),
+            )
+
         if self.target_platform == "web":
             self.prune_cdn_assets()
             if self.assets_path.exists():

{flet_cli-1.0.2 → flet_cli-1.0.4}/src/flet_cli/commands/flutter_base.py

@@ -59,6 +59,7 @@ class BaseFlutterCommand(BaseCommand):
         self.emojis = {}
         self.dart_exe = None
         self.flutter_exe = None
+        self._flutter_arch: Optional[tuple[str, Optional[str]]] = None
         self.required_flutter_version: Optional[version.Version] = None
         self.verbose = False
         self.require_android_sdk = False
@@ -155,16 +156,16 @@ class BaseFlutterCommand(BaseCommand):
         self.flutter_exe = self.find_flutter_batch("flutter")
         self.dart_exe = self.find_flutter_batch("dart")
 
-        if (
-            not self.flutter_exe
-            or not self.dart_exe
-            or not self.flutter_version_valid()
-        ):
+        sdk_found = bool(
+            self.flutter_exe and self.dart_exe and self.flutter_version_valid()
+        )
+        if not sdk_found or not self.flutter_sdk_supported():
             if not self.assume_yes:
-                console.log(
-                    "Flutter SDK not found or invalid version installed.",
-                    style=warning_style,
-                )
+                if not sdk_found:
+                    console.log(
+                        "Flutter SDK not found or invalid version installed.",
+                        style=warning_style,
+                    )
                 prompt = (
                     f"Flutter SDK {self.required_flutter_version} is required. "
                     f"It will be installed now. Proceed? [y/n] "
@@ -227,6 +228,44 @@ class BaseFlutterCommand(BaseCommand):
             console.log(1, "Failed to validate Flutter version.")
         return False
 
+    def flutter_sdk_supported(self) -> bool:
+        """
+        Check whether the Flutter SDK found can build for this command's target.
+
+        Returns:
+            `True` when the SDK can be used, otherwise `False`, in which case the
+                required Flutter SDK is installed and used instead.
+        """
+
+        return True
+
+    def flutter_arch(self) -> Optional[str]:
+        """
+        Return the CPU architecture of the Flutter SDK's Dart, such as `x64` or
+        `arm64`. On Windows, Flutter builds desktop apps for this architecture.
+
+        Returns:
+            The architecture reported by `dart --version`, or `None` when it can't
+                be determined.
+        """
+
+        if not self.dart_exe:
+            return None
+        if self._flutter_arch and self._flutter_arch[0] == self.dart_exe:
+            return self._flutter_arch[1]
+
+        arch = None
+        result = self.run(
+            [self.dart_exe, "--version"], cwd=os.getcwd(), capture_output=True
+        )
+        output = f"{result.stdout or ''}{result.stderr or ''}"
+        # e.g. `Dart SDK version: 3.12.2 (stable) (...) on "windows_arm64"`
+        match = re.search(r'on "[a-z]+_([a-z0-9]+)"', output)
+        if match:
+            arch = match.group(1)
+        self._flutter_arch = (self.dart_exe, arch)
+        return arch
+
     def install_flutter(self):
         """
         Install required Flutter SDK and update command environment.

{flet_cli-1.0.2 → flet_cli-1.0.4}/src/flet_cli/commands/run.py

@@ -1,4 +1,5 @@
 import argparse
+import errno
 import logging
 import os
 import platform
@@ -20,6 +21,7 @@ from flet.app import DEFAULT_ASSETS_DIR
 from flet.utils import (
     get_free_tcp_port,
     get_local_ip,
+    is_linux,
     is_windows,
     open_in_browser,
     random_string,
@@ -201,8 +203,12 @@ class Command(BaseCommand):
 
         This method prepares the script/module path, selects transport
         configuration (port or UDS), resolves assets and ignore directories,
-        starts the child app process through `Handler`, and keeps the
-        observer running until termination.
+        starts file watching, then starts the child app process through
+        `Handler`, and keeps the observer running until termination.
+
+        If starting the observer raises `OSError`, for example because the
+        Linux inotify watch or instance limit is reached, a warning is printed
+        and the app runs without reloading on changes.
 
         Args:
             options: Parsed command options produced by :meth:`add_arguments`.
@@ -361,7 +367,22 @@ class Command(BaseCommand):
 
         my_observer = Observer()
         my_observer.schedule(my_event_handler, script_dir, recursive=options.recursive)
-        my_observer.start()
+        try:
+            my_observer.start()
+        except OSError as e:
+            hint = (
+                " To enable it, raise the inotify limits: "
+                "https://flet.dev/docs/getting-started/running-app#linux-inotify-limits"
+                if is_linux() and e.errno in (errno.ENOSPC, errno.EMFILE)
+                else ""
+            )
+            print(
+                f"Warning: file watching is unavailable ({e.strerror or e}), "
+                f"so the app won't reload on changes.{hint}"
+            )
+            my_observer = None
+
+        my_event_handler.start_process()
 
         try:
             while True:
@@ -377,8 +398,9 @@ class Command(BaseCommand):
 
             close_flet_view(my_event_handler.pid_file)
 
-        my_observer.stop()
-        my_observer.join()
+        if my_observer is not None:
+            my_observer.stop()
+            my_observer.join()
 
 
 class Handler(FileSystemEventHandler):
@@ -435,7 +457,6 @@ class Handler(FileSystemEventHandler):
         self.flet_app_temp_dir = flet_app_temp_dir
         self.verbose = verbose
         self.terminate = threading.Event()
-        self.start_process()
 
     def start_process(self):
         """

flet_cli-1.0.4/src/flet_cli/version.py

@@ -0,0 +1 @@
+version = "1.0.4"

{flet_cli-1.0.2 → flet_cli-1.0.4}/src/flet_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flet-cli
-Version: 1.0.2
+Version: 1.0.4
 Summary: Flet CLI
 Author-email: "Appveyor Systems Inc." <hello@flet.dev>
 License-Expression: Apache-2.0
@@ -9,8 +9,8 @@ Project-URL: Repository, https://github.com/flet-dev/flet
 Project-URL: Documentation, https://flet.dev/docs
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: flet==1.0.2
-Requires-Dist: flet-platform-assets==1.0.2
+Requires-Dist: flet==1.0.4
+Requires-Dist: flet-platform-assets==1.0.4
 Requires-Dist: watchdog>=4.0.0
 Requires-Dist: packaging>=25.0
 Requires-Dist: qrcode>=7.4.2

{flet_cli-1.0.2 → flet_cli-1.0.4}/src/flet_cli.egg-info/SOURCES.txt

@@ -55,6 +55,7 @@ src/flet_cli/utils/python_versions.py
 src/flet_cli/utils/template_cache.py
 tests/test_app_excludes.py
 tests/test_build_app_path.py
+tests/test_build_copy_output.py
 tests/test_build_icons.py
 tests/test_build_ios.py
 tests/test_build_linux.py
@@ -63,6 +64,7 @@ tests/test_build_macos_signing.py
 tests/test_build_platform_settings.py
 tests/test_build_splash.py
 tests/test_build_template.py
+tests/test_build_windows_arm64.py
 tests/test_clean.py
 tests/test_cli_pass_through_args.py
 tests/test_cli_positionals.py
@@ -75,4 +77,5 @@ tests/test_project_dependencies.py
 tests/test_python_versions.py
 tests/test_run_assets_dir.py
 tests/test_run_desktop_dependency.py
-tests/test_run_script_args.py
+tests/test_run_script_args.py
+tests/test_run_watcher_unavailable.py

{flet_cli-1.0.2 → flet_cli-1.0.4}/src/flet_cli.egg-info/requires.txt

@@ -1,5 +1,5 @@
-flet==1.0.2
-flet-platform-assets==1.0.2
+flet==1.0.4
+flet-platform-assets==1.0.4
 watchdog>=4.0.0
 packaging>=25.0
 qrcode>=7.4.2

flet_cli-1.0.4/tests/test_build_copy_output.py

@@ -0,0 +1,118 @@
+"""How `flet build` copies Flutter's build output into the output directory."""
+
+import argparse
+from pathlib import Path
+
+import pytest
+
+from flet_cli.commands.build_base import BaseBuildCommand
+
+WINDOWS_RELEASE = "build/windows/x64/runner/Release"
+MACOS_RELEASE = "build/macos/Build/Products/Release"
+
+
+def _command(
+    tmp_path: Path, target_platform: str, artifact_name: str = "MyApp"
+) -> BaseBuildCommand:
+    """
+    Build a command that copies from `tmp_path/flutter` into `tmp_path/out`.
+
+    Args:
+        tmp_path: pytest tmp dir.
+        target_platform: Key of `BaseBuildCommand.platforms`.
+        artifact_name: Value substituted for `{artifact_name}` in outputs.
+
+    Returns:
+        A command whose `cleanup` raises `SystemExit` with the exit code and
+            records the message in `cleanup_messages`.
+    """
+
+    cmd = BaseBuildCommand(argparse.ArgumentParser())
+    cmd.options = argparse.Namespace()
+    cmd.verbose = 0
+    cmd.flutter_dir = tmp_path / "flutter"
+    cmd.out_dir = tmp_path / "out"
+    cmd.rel_out_dir = "out"
+    cmd.assets_path = tmp_path / "assets"
+    cmd.target_platform = target_platform
+    cmd.package_platform = cmd.platforms[target_platform]["package_platform"]
+    cmd.template_data = {
+        "artifact_name": artifact_name,
+        "project_name": "my_app",
+        "product_name": "My App",
+    }
+    cmd.emojis = {"checkmark": ""}
+    cmd.update_status = lambda *_: None
+    cmd.flutter_arch = lambda: "x64"
+    cmd.cleanup_messages = []
+
+    def cleanup(exit_code, message=None, no_border=False):
+        cmd.cleanup_messages.append(message)
+        raise SystemExit(exit_code)
+
+    cmd.cleanup = cleanup
+    return cmd
+
+
+def test_windows_release_contents_are_copied(tmp_path):
+    """Every entry of the Windows `Release` directory lands in the output dir."""
+    release = tmp_path / "flutter" / WINDOWS_RELEASE
+    (release / "data").mkdir(parents=True)
+    (release / "my_app.exe").write_text("exe")
+    cmd = _command(tmp_path, "windows")
+
+    cmd.copy_build_output()
+
+    assert sorted(p.name for p in cmd.out_dir.iterdir()) == ["data", "my_app.exe"]
+
+
+def test_macos_copies_only_the_app_bundle(tmp_path):
+    """Only `{artifact_name}.app` is copied out of the macOS `Release` directory."""
+    release = tmp_path / "flutter" / MACOS_RELEASE
+    (release / "MyApp.app" / "Contents").mkdir(parents=True)
+    (release / "FlutterMacOS.framework").mkdir()
+    cmd = _command(tmp_path, "macos")
+
+    cmd.copy_build_output()
+
+    assert [p.name for p in cmd.out_dir.iterdir()] == ["MyApp.app"]
+
+
+def test_macos_app_name_is_matched_literally(tmp_path):
+    """An artifact name with glob characters still matches its `.app` bundle."""
+    release = tmp_path / "flutter" / MACOS_RELEASE
+    (release / "My App [Beta].app" / "Contents").mkdir(parents=True)
+    cmd = _command(tmp_path, "macos", artifact_name="My App [Beta]")
+
+    cmd.copy_build_output()
+
+    assert [p.name for p in cmd.out_dir.iterdir()] == ["My App [Beta].app"]
+
+
+@pytest.mark.parametrize(
+    ("target_platform", "make_tree"),
+    [
+        pytest.param("windows", lambda f: None, id="windows-no-release-dir"),
+        pytest.param(
+            "windows",
+            lambda f: (f / WINDOWS_RELEASE).mkdir(parents=True),
+            id="windows-empty-release-dir",
+        ),
+        pytest.param(
+            "macos",
+            lambda f: (f / MACOS_RELEASE / "Other.app").mkdir(parents=True),
+            id="macos-release-dir-without-app",
+        ),
+    ],
+)
+def test_missing_build_output_fails(tmp_path, target_platform, make_tree):
+    """The build fails, naming the searched path, when no output matches."""
+    make_tree(tmp_path / "flutter")
+    cmd = _command(tmp_path, target_platform)
+
+    with pytest.raises(SystemExit) as exc_info:
+        cmd.copy_build_output()
+
+    assert exc_info.value.code == 1
+    assert "Build output not found in" in cmd.cleanup_messages[-1]
+    assert not cmd.out_dir.exists()

{flet_cli-1.0.2 → flet_cli-1.0.4}/tests/test_build_template.py

@@ -105,3 +105,38 @@ class TestBuildTemplateContract:
         )
         parsed = yaml.safe_load(rendered)
         assert parsed["description"] == re.sub(r"[\x00-\x1f]", " ", description)
+
+    @pytest.mark.parametrize("product", ["Flet Studio", 'My "App"', "back\\slash"])
+    def test_manifest_names_come_from_product(self, product):
+        """iOS labels an installed PWA with the manifest's `short_name`, which
+        was the project name slug (`client`) instead of the product name."""
+        with open(BUILD_TEMPLATE_DIR.parent / "cookiecutter.json") as f:
+            default_short_name = json.load(f)["pwa_short_name"]
+        context = {
+            "project_name": "client",
+            "product_name": product,
+            "pwa_background_color": "#FFFFFF",
+            "pwa_theme_color": "#FF005F",
+            "project_description": "",
+        }
+        context["pwa_short_name"] = (
+            Environment().from_string(default_short_name).render(cookiecutter=context)
+        )
+        manifest = json.loads(
+            _render_template(BUILD_TEMPLATE_DIR / "web" / "manifest.json", **context)
+        )
+        assert manifest["name"] == product
+        assert manifest["short_name"] == product
+
+    def test_manifest_short_name_override(self):
+        rendered = _render_template(
+            BUILD_TEMPLATE_DIR / "web" / "manifest.json",
+            product_name="Flet Studio",
+            pwa_short_name="Studio",
+            pwa_background_color="#FFFFFF",
+            pwa_theme_color="#FF005F",
+            project_description="",
+        )
+        manifest = json.loads(rendered)
+        assert manifest["name"] == "Flet Studio"
+        assert manifest["short_name"] == "Studio"

flet_cli-1.0.4/tests/test_build_windows_arm64.py

@@ -0,0 +1,231 @@
+"""
+Flutter SDK architecture handling for `flet build windows` on Windows on ARM.
+
+Flet's Python runtime for Windows is x64-only, so an ARM64 Flutter SDK, which
+builds ARM64 Windows apps, must not be used for a Windows build. The SDK's
+architecture comes from `dart --version`, which is stubbed here, so no Flutter
+SDK is needed.
+"""
+
+import argparse
+import os
+from types import SimpleNamespace
+
+import pytest
+from packaging import version
+
+from flet_cli.commands.build import Command
+from flet_cli.utils.flutter import get_flutter_dir
+
+FLUTTER_VERSION = "3.44.8"
+EXTERNAL_FLUTTER_EXE = os.path.join(os.sep + "opt", "flutter", "bin", "flutter")
+# `dart --version` output, formatted with the `<os>_<arch>` Dart runs on.
+DART_VERSION = (
+    'Dart SDK version: 3.12.2 (stable) (Tue Jun 9 01:11:39 2026 -0700) on "{}"\n'
+)
+
+
+class Exit(Exception):
+    """Captures `cleanup(1, message)` calls, which normally sys.exit."""
+
+    def __init__(self, code, message):
+        self.code = code
+        self.message = message
+        super().__init__(f"cleanup({code}): {message}")
+
+
+def make_command(**attrs) -> Command:
+    """
+    Build a `flet build windows` command on Windows without parsing a command line.
+
+    Args:
+        attrs: Attributes to set on the command, overriding the defaults.
+
+    Returns:
+        A command whose `cleanup` raises `Exit` instead of exiting.
+    """
+
+    cmd = Command(argparse.ArgumentParser())
+    cmd.required_flutter_version = version.Version(FLUTTER_VERSION)
+    cmd.current_platform = "Windows"
+    cmd.package_platform = "Windows"
+    cmd.target_platform = "windows"
+
+    def cleanup(code, message=None, **kwargs):
+        raise Exit(code, message)
+
+    cmd.cleanup = cleanup
+    for name, value in attrs.items():
+        setattr(cmd, name, value)
+    return cmd
+
+
+def dart_version_runner(stdout="", stderr=""):
+    """
+    Return a stub for `run()` answering `dart --version`, recording its calls.
+
+    Args:
+        stdout: Standard output of the stubbed `dart --version`.
+        stderr: Standard error of the stubbed `dart --version`.
+
+    Returns:
+        A `run()` replacement whose `calls` lists the arguments of each call.
+    """
+
+    def run(args, cwd, env=None, capture_output=True):
+        run.calls.append(args)
+        return SimpleNamespace(returncode=0, stdout=stdout, stderr=stderr)
+
+    run.calls = []
+    return run
+
+
+def unexpected_dart_call():
+    """Fail the test if the SDK architecture is queried."""
+    raise AssertionError("`dart --version` must not run")
+
+
+class TestFlutterArch:
+    """How `flutter_arch()` reads the SDK architecture from `dart --version`."""
+
+    @pytest.mark.parametrize(
+        ("stdout", "stderr", "expected"),
+        [
+            (DART_VERSION.format("windows_arm64"), "", "arm64"),
+            (DART_VERSION.format("windows_x64"), "", "x64"),
+            ("", DART_VERSION.format("windows_arm64"), "arm64"),
+        ],
+        ids=["windows_arm64", "windows_x64", "on-stderr"],
+    )
+    def test_parses_dart_version(self, stdout, stderr, expected):
+        """The architecture suffix of the `on "<os>_<arch>"` part is returned."""
+        cmd = make_command(dart_exe="dart", run=dart_version_runner(stdout, stderr))
+
+        assert cmd.flutter_arch() == expected
+
+    def test_unparsable_output_is_none(self):
+        """Output without an `on "<os>_<arch>"` part gives `None`."""
+        cmd = make_command(
+            dart_exe="dart", run=dart_version_runner("Dart SDK version: 3.12.2\n")
+        )
+
+        assert cmd.flutter_arch() is None
+
+    def test_cached_per_dart_executable(self):
+        """Dart runs once per executable, so switching SDKs reads the new one."""
+        cmd = make_command(
+            dart_exe="arm64-dart",
+            run=dart_version_runner(DART_VERSION.format("windows_arm64")),
+        )
+        assert cmd.flutter_arch() == "arm64"
+        assert cmd.flutter_arch() == "arm64"
+        assert len(cmd.run.calls) == 1
+
+        cmd.dart_exe = "x64-dart"
+        cmd.run = dart_version_runner(DART_VERSION.format("windows_x64"))
+        assert cmd.flutter_arch() == "x64"
+
+
+class TestFlutterSdkSupported:
+    """Which Flutter SDKs `flet build` accepts, by host, target and architecture."""
+
+    @pytest.mark.parametrize(
+        "flutter_exe",
+        [
+            EXTERNAL_FLUTTER_EXE,
+            os.path.join(
+                get_flutter_dir(FLUTTER_VERSION) + "-custom", "bin", "flutter"
+            ),
+        ],
+        ids=["outside-home", "sibling-of-managed-dir"],
+    )
+    def test_external_arm64_sdk_is_replaced(self, flutter_exe):
+        """An ARM64 SDK outside Flet's own directory is swapped for Flet's x64 SDK."""
+        cmd = make_command(flutter_exe=flutter_exe, flutter_arch=lambda: "arm64")
+
+        assert cmd.flutter_sdk_supported() is False
+
+    def test_managed_arm64_sdk_fails(self):
+        """An ARM64 SDK in Flet's own directory fails, asking to delete it."""
+        cmd = make_command(
+            flutter_exe=os.path.join(
+                get_flutter_dir(FLUTTER_VERSION), "bin", "flutter.bat"
+            ),
+            flutter_arch=lambda: "arm64",
+            skip_flutter_doctor=False,
+        )
+
+        with pytest.raises(Exit) as exc_info:
+            cmd.flutter_sdk_supported()
+
+        assert exc_info.value.code == 1
+        assert "Delete that directory" in exc_info.value.message
+
+    def test_x64_sdk_is_supported(self):
+        """An x64 SDK builds Windows apps on any Windows host."""
+        cmd = make_command(flutter_exe=EXTERNAL_FLUTTER_EXE, flutter_arch=lambda: "x64")
+
+        assert cmd.flutter_sdk_supported() is True
+
+    @pytest.mark.parametrize(
+        ("host", "package_platform"),
+        [
+            ("Windows", "Android"),
+            ("Darwin", "Darwin"),
+            ("Linux", "Linux"),
+            ("Darwin", "Windows"),
+            ("Linux", "Windows"),
+        ],
+        ids=[
+            "android-on-windows",
+            "macos-on-macos",
+            "linux-on-linux",
+            "windows-on-macos",
+            "windows-on-linux",
+        ],
+    )
+    def test_other_builds_are_supported_without_running_dart(
+        self, host, package_platform
+    ):
+        """Builds other than Windows-on-Windows accept any SDK without asking Dart."""
+        cmd = make_command(
+            current_platform=host,
+            package_platform=package_platform,
+            flutter_exe=EXTERNAL_FLUTTER_EXE,
+            flutter_arch=unexpected_dart_call,
+        )
+
+        assert cmd.flutter_sdk_supported() is True
+
+
+class TestWindowsBuildOutput:
+    """Where `flet build windows` looks for the app Flutter built."""
+
+    @pytest.mark.parametrize(
+        ("sdk_arch", "host_machine", "expected"),
+        [
+            ("x64", "ARM64", "x64"),
+            ("arm64", "AMD64", "arm64"),
+            (None, "AMD64", "x64"),
+        ],
+        ids=["x64-sdk-on-arm64", "arm64-sdk", "unknown-sdk-arch"],
+    )
+    def test_output_follows_sdk_arch(
+        self, tmp_path, monkeypatch, sdk_arch, host_machine, expected
+    ):
+        """The output directory follows the SDK's architecture, not the host's."""
+        monkeypatch.setattr("platform.machine", lambda: host_machine)
+        cmd = make_command(
+            flutter_dir=tmp_path,
+            template_data={
+                "artifact_name": "app",
+                "project_name": "app",
+                "product_name": "app",
+            },
+            flutter_arch=lambda: sdk_arch,
+        )
+
+        (output,) = cmd.platforms["windows"]["outputs"]
+        assert cmd.resolve_output_path(output) == str(
+            tmp_path / "build" / "windows" / expected / "runner" / "Release" / "*"
+        )

{flet_cli-1.0.2 → flet_cli-1.0.4}/tests/test_run_desktop_dependency.py

@@ -92,6 +92,8 @@ def run_flet(monkeypatch, tmp_path):
                 self.terminate = threading.Event()
                 self.terminate.set()
 
+            def start_process(self): ...
+
         class StubObserver:
             def schedule(self, *args, **kwargs): ...
             def start(self): ...

flet_cli-1.0.4/tests/test_run_watcher_unavailable.py

@@ -0,0 +1,155 @@
+"""`flet run` runs the app without hot reload when file watching can't start.
+
+On Linux the watchdog observer is backed by inotify, and starting it raises
+`OSError` with `ENOSPC` or `EMFILE` once the user's inotify watch or instance
+limit is used up. `flet run` then prints a warning, links the docs on raising
+those limits, and starts the app anyway.
+"""
+
+import errno
+import inspect
+import threading
+
+import pytest
+
+from flet_cli.cli import parse_command_line
+
+DOCS_URL = "https://flet.dev/docs/getting-started/running-app#linux-inotify-limits"
+
+
+@pytest.fixture
+def run_flet(monkeypatch, tmp_path):
+    from flet_cli.commands import run as run_module
+
+    def invoke(observer_error=None, linux=None):
+        events = []
+        monkeypatch.setattr(
+            "flet.utils.pip.ensure_flet_desktop_package_installed", lambda: None
+        )
+        monkeypatch.setattr(
+            "flet.utils.pip.ensure_flet_web_package_installed", lambda: None
+        )
+        # Belt and braces: should the patches above ever stop applying, fail
+        # loudly instead of quietly pip-installing into the developer's venv.
+        monkeypatch.setattr(
+            "flet.utils.pip.install_flet_package",
+            lambda name: pytest.fail(f"test tried to install {name!r}"),
+        )
+        if linux is not None:
+            monkeypatch.setattr(run_module, "is_linux", lambda: linux)
+
+        real_signature = inspect.signature(run_module.Handler.__init__)
+
+        class StubHandler:
+            def __init__(self, **kwargs):
+                real_signature.bind(self, **kwargs)
+                self.pid_file = None
+                # Return control to `handle()` immediately.
+                self.terminate = threading.Event()
+                self.terminate.set()
+
+            def start_process(self):
+                events.append("start_process")
+
+        class StubObserver:
+            """Tears down like a watchdog observer, which is a `Thread`."""
+
+            started = False
+
+            def schedule(self, *args, **kwargs): ...
+
+            def start(self):
+                events.append("start")
+                if observer_error is not None:
+                    raise observer_error
+                self.started = True
+
+            def is_alive(self):
+                return self.started
+
+            def stop(self):
+                events.append("stop")
+
+            def join(self):
+                if not self.started:
+                    raise RuntimeError("cannot join thread before it is started")
+                events.append("join")
+
+        monkeypatch.setattr(run_module, "Handler", StubHandler)
+        monkeypatch.setattr(run_module, "Observer", StubObserver)
+
+        script = tmp_path / "main.py"
+        script.write_text("import flet as ft\n", encoding="utf-8")
+        monkeypatch.chdir(tmp_path)
+
+        args = parse_command_line([str(script)])
+        args.handler(args)
+        return events
+
+    return invoke
+
+
+class TestTheAppRunsWithoutFileWatching:
+    """An observer that fails to start costs hot reload, not the run."""
+
+    def test_app_is_started(self, run_flet):
+        """The app starts, and the never-started observer is not joined."""
+        events = run_flet(OSError(errno.ENOSPC, "inotify watch limit reached"))
+        assert "start_process" in events
+
+    def test_watching_starts_before_the_app(self, run_flet):
+        """An observer error is raised before any app process exists."""
+        events = run_flet(OSError(errno.ENOSPC, "inotify watch limit reached"))
+        assert events.index("start") < events.index("start_process")
+
+    def test_started_observer_is_torn_down(self, run_flet):
+        """An observer that did start is stopped and joined when the run ends."""
+        assert run_flet()[-2:] == ["stop", "join"]
+
+
+class TestTheWarning:
+    """The warning names the error and links the docs for inotify limits only."""
+
+    @pytest.mark.parametrize(
+        ("linux", "error", "detail", "hinted"),
+        [
+            (
+                True,
+                OSError(errno.ENOSPC, "inotify watch limit reached"),
+                "inotify watch limit reached",
+                True,
+            ),
+            (
+                True,
+                OSError(errno.EMFILE, "inotify instance limit reached"),
+                "inotify instance limit reached",
+                True,
+            ),
+            (
+                True,
+                OSError(errno.EPERM, "Operation not permitted"),
+                "Operation not permitted",
+                False,
+            ),
+            (
+                False,
+                OSError(errno.ENOSPC, "No space left on device"),
+                "No space left on device",
+                False,
+            ),
+            (True, OSError("watcher failed"), "watcher failed", False),
+        ],
+        ids=[
+            "linux-watch-limit",
+            "linux-instance-limit",
+            "linux-other-errno",
+            "not-linux",
+            "no-errno",
+        ],
+    )
+    def test_docs_link(self, run_flet, capsys, linux, error, detail, hinted):
+        """Only a Linux inotify watch or instance limit error links the docs."""
+        run_flet(error, linux=linux)
+        out = capsys.readouterr().out
+        assert f"file watching is unavailable ({detail})" in out
+        assert (DOCS_URL in out) is hinted

flet_cli-1.0.2/src/flet_cli/version.py

@@ -1 +0,0 @@
-version = "1.0.2"