flet-cli 0.86.1__tar.gz → 0.86.3__tar.gz

{flet_cli-0.86.1 → flet_cli-0.86.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flet-cli
-Version: 0.86.1
+Version: 0.86.3
 Summary: Flet CLI
 Author-email: "Appveyor Systems Inc." <hello@flet.dev>
 License-Expression: Apache-2.0
@@ -9,7 +9,7 @@ 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==0.86.1
+Requires-Dist: flet==0.86.3
 Requires-Dist: watchdog>=4.0.0
 Requires-Dist: packaging>=25.0
 Requires-Dist: qrcode>=7.4.2

{flet_cli-0.86.1 → flet_cli-0.86.3}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "flet-cli"
-version = "0.86.1"
+version = "0.86.3"
 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==0.86.1",
+    "flet==0.86.3",
     "watchdog >=4.0.0",
     "packaging >=25.0",
     "qrcode >=7.4.2",

{flet_cli-0.86.1 → flet_cli-0.86.3}/src/flet_cli/cli.py

@@ -1,6 +1,7 @@
 import argparse
 import json
 import sys
+from typing import Optional
 
 import flet.version
 import flet_cli.commands.build
@@ -41,23 +42,25 @@ def _render_version(as_json: bool) -> str:
 
 # Source https://stackoverflow.com/a/26379693
 def set_default_subparser(
-    parser: argparse.ArgumentParser, name: str, args: list = None, index: int = 0
-):
+    parser: argparse.ArgumentParser, name: str, args: list
+) -> list:
     """
-    Set a default subparser when no subparser is provided.
+    Prepend a default subparser name when the command line doesn't name one.
     This should be called after setting up the argument parser but before
     `parse_args()`.
 
     Args:
+        parser: The root argument parser.
         name: The name of the default subparser to use.
-        args: A list of arguments passed to `parse_args()`.
-        index: Position in `sys.argv` where the default subparser should be
-            inserted.
+        args: The command-line arguments, without the program name.
+
+    Returns:
+        `args`, with the default subparser name prepended when applicable.
     """
 
-    # exit if help or version flags are present
-    if any(flag in sys.argv[1:] for flag in {"-h", "--help", "-V", "--version"}):
-        return
+    # exit if no arguments, or help or version flags are present
+    if not args or any(flag in args for flag in {"-h", "--help", "-V", "--version"}):
+        return args
 
     # all subparser actions
     subparser_actions = [
@@ -72,19 +75,14 @@ def set_default_subparser(
     ]
 
     # if an existing subparser is provided, skip setting a default
-    if any(arg in subparser_names for arg in sys.argv[1:]):
-        return
+    if any(arg in subparser_names for arg in args):
+        return args
 
     # if the default subparser doesn't exist, register it in the first subparser action
     if (name not in subparser_names) and subparser_actions:
         subparser_actions[0].add_parser(name)
 
-    # insert the default subparser into the appropriate argument list
-    if args is None:
-        if len(sys.argv) > 1:
-            sys.argv.insert(index, name)
-    else:
-        args.insert(index, name)
+    return [name, *args]
 
 
 def get_parser() -> argparse.ArgumentParser:
@@ -132,22 +130,86 @@ def get_parser() -> argparse.ArgumentParser:
     except ImportError:
         pass
 
-    # set "run" as the default subparser
-    set_default_subparser(parser, name="run", index=1)
-
     return parser
 
 
-def main():
+def split_script_args(argv: list) -> tuple[list, Optional[list]]:
+    """
+    Split a command line at the first bare `--` separator.
+
+    Everything after the separator is meant for the app script, not for Flet
+    itself, so it must be removed before the parser (and `set_default_subparser`)
+    sees it - otherwise `flet run app.py -- --web` would be read as Flet's own
+    `--web` option, and `flet app.py -- build` would suppress the default `run`
+    subcommand.
+
+    Args:
+        argv: Command-line arguments, without the program name.
+
+    Returns:
+        A `(argv, script_args)` tuple, where `script_args` is `None` when no
+        `--` separator is present.
+    """
+    try:
+        index = argv.index("--")
+    except ValueError:
+        return argv, None
+    return argv[:index], argv[index + 1 :]
+
+
+def parse_command_line(argv: list) -> argparse.Namespace:
+    """
+    Parse a Flet command line into the namespace passed to a command handler.
+
+    Exits the process with a usage message when the command line is invalid.
+
+    Args:
+        argv: Command-line arguments, without the program name.
+
+    Returns:
+        The parsed arguments. For `flet run`, `script_args` holds the arguments
+        to forward to the app script.
+    """
+
+    # pull off the arguments meant for the app script before the parser sees them
+    argv, script_args = split_script_args(argv)
+
     parser = get_parser()
 
+    # "run" is the default subcommand
+    argv = set_default_subparser(parser, name="run", args=argv)
+
+    args, unrecognized = parser.parse_known_args(argv)
+
+    if unrecognized:
+        message = f"unrecognized arguments: {' '.join(unrecognized)}"
+        if getattr(args, "command", None) == "run":
+            message += (
+                "\nIf these are arguments for your app script, put them after "
+                "a `--` separator, e.g. "
+                f"`flet run {args.script} -- {' '.join(unrecognized)}`"
+            )
+        parser.error(message)
+
+    # forward the arguments that followed `--` to the app script
+    if script_args is not None:
+        if getattr(args, "command", None) != "run":
+            parser.error(
+                "the `--` separator is only supported by `flet run`, to pass "
+                "the arguments that follow it to your app script"
+            )
+        args.script_args = list(args.script_args) + script_args
+
+    return args
+
+
+def main():
     # print usage/help if called without arguments
     if len(sys.argv) == 1:
-        parser.print_help(sys.stdout)
+        get_parser().print_help(sys.stdout)
         sys.exit(1)
 
-    # parse arguments
-    args = parser.parse_args()
+    args = parse_command_line(sys.argv[1:])
 
     # handle `flet --version [--json]` (no subcommand/handler is set)
     if getattr(args, "version", False):

{flet_cli-0.86.1 → flet_cli-0.86.3}/src/flet_cli/commands/build_base.py

@@ -474,6 +474,17 @@ class BaseBuildCommand(BaseFlutterCommand):
             default=None,
             help="Split the APKs per ABIs (Android only)",
         )
+        parser.add_argument(
+            "--android-legacy-packaging",
+            dest="android_legacy_packaging",
+            action=argparse.BooleanOptionalAction,
+            default=None,
+            help="Use legacy Android native-library packaging: extract `.so` to disk "
+            "at install time instead of memory-mapping them directly from the APK. Off "
+            "by default (modern packaging). Enabling it makes the raw `.apk` file "
+            "smaller for side-loading, at the cost of a larger on-device install size "
+            "and slower native-library loading (Android only)",
+        )
         parser.add_argument(
             "--compile-app",
             dest="compile_app",
@@ -920,6 +931,16 @@ class BaseBuildCommand(BaseFlutterCommand):
             )
         )
 
+        android_legacy_packaging = (
+            self.options.android_legacy_packaging
+            if self.options.android_legacy_packaging is not None
+            else (
+                self.get_pyproject("tool.flet.android.legacy_packaging")
+                if self.get_pyproject("tool.flet.android.legacy_packaging") is not None
+                else False
+            )
+        )
+
         info_plist = {}
         macos_entitlements = {
             "com.apple.security.app-sandbox": False,
@@ -1375,6 +1396,7 @@ class BaseBuildCommand(BaseFlutterCommand):
                     or self.get_pyproject("tool.flet.android.signing.key_store")
                     or os.getenv("FLET_ANDROID_SIGNING_KEY_STORE")
                 ),
+                "android_legacy_packaging": bool(android_legacy_packaging),
             },
             "flutter": {"dependencies": list(self.flutter_dependencies.keys())},
             "boot_screen": self._resolve_boot_screen(),
@@ -2832,11 +2854,14 @@ class BaseBuildCommand(BaseFlutterCommand):
         """
         Find the best matching image file for the current target platform.
 
-        When multiple files share the same base name (e.g. `icon.icns`,
-        `icon.ico`, `icon.png`), the method filters out formats that are
-        incompatible with the build target before selecting the first match.
-        For example, `.icns` is skipped on Windows builds because
-        `flutter_launcher_icons` cannot decode it.
+        When multiple files share the same base name (e.g. `icon.png` and
+        `icon.svg`), incompatible formats are filtered out and the rest are
+        ranked so a raster image (`.png` first) always wins, making the
+        choice deterministic regardless of filesystem ordering. Formats the
+        icon/splash generators cannot decode are dropped: `.svg` (vector,
+        never supported), `.icns` (macOS-only) and `.ico` (Windows-only). If
+        the only candidate is a vector image, a warning is logged and `None`
+        is returned so the default icon is used.
 
         Args:
             src_path: Source assets directory.
@@ -2849,21 +2874,54 @@ class BaseBuildCommand(BaseFlutterCommand):
             File name of matched image, or `None` if not found.
         """
 
-        # .icns is macOS-only and .ico is Windows-only; filter out
-        # incompatible formats so flutter_launcher_icons gets a decodable file.
-        images = list(
-            filter(
-                lambda p: not (
-                    (ext := Path(p).suffix.lower()) == ".icns"
-                    and self.target_platform != "macos"
-                    or ext == ".ico"
-                    and self.target_platform != "windows"
-                ),
-                glob.glob(str(src_path.joinpath(f"{image_name}.*"))),
-            )
+        # flutter_launcher_icons / flutter_native_splash decode raster images
+        # only, so drop any candidate they can't read: .svg is vector (never
+        # supported), .icns is macOS-only and .ico is Windows-only.
+        def _incompatible(p: str) -> bool:
+            ext = Path(p).suffix.lower()
+            return (
+                ext == ".svg"
+                or (ext == ".icns" and self.target_platform != "macos")
+                or (ext == ".ico" and self.target_platform != "windows")
+            )
+
+        # glob order is filesystem-dependent — sort so the choice is
+        # deterministic across machines, then rank by format so a raster
+        # icon (.png first) always wins when several candidates share a base
+        # name (e.g. both icon.png and icon.svg present).
+        ext_priority = {
+            ".png": 0,
+            ".webp": 1,
+            ".jpg": 2,
+            ".jpeg": 2,
+            ".gif": 3,
+            ".bmp": 4,
+            ".tif": 5,
+            ".tiff": 5,
+            ".ico": 6,
+            ".icns": 6,
+        }
+        candidates = sorted(glob.glob(str(src_path.joinpath(f"{image_name}.*"))))
+        images = sorted(
+            (p for p in candidates if not _incompatible(p)),
+            key=lambda p: (ext_priority.get(Path(p).suffix.lower(), 99), p),
         )
 
         if not images:
+            # Nothing usable. If the only candidate was a vector image (e.g.
+            # an icon.svg with no raster sibling), say why it's ignored
+            # instead of silently falling back to the default icon.
+            svg = next(
+                (p for p in candidates if Path(p).suffix.lower() == ".svg"), None
+            )
+            if svg:
+                console.log(
+                    f'Warning: "{Path(svg).name}" is a vector (SVG) image and '
+                    f'cannot be used for "{image_name}". Provide a raster '
+                    f'"{image_name}.png" to customize it — using the default '
+                    f"for now.",
+                    style=warning_style,
+                )
             return None
 
         best = images[0]

{flet_cli-0.86.1 → flet_cli-0.86.3}/src/flet_cli/commands/flutter_base.py

@@ -21,14 +21,26 @@ from flet.utils.platform_utils import get_bool_env_var
 from flet_cli.commands.base import BaseCommand
 from flet_cli.utils.flutter import get_flutter_dir, install_flutter
 
-no_rich_output = get_bool_env_var("FLET_CLI_NO_RICH_OUTPUT")
+# Detect the plain-output request BEFORE building the shared console: the
+# `--no-rich-output` argparse flag is parsed per-command, too late to
+# affect this module-level console, so check sys.argv for it here too
+# (alongside the env var). Without this, the flag only suppressed emojis
+# while the color + Live spinner kept going.
+no_rich_output = (
+    get_bool_env_var("FLET_CLI_NO_RICH_OUTPUT") or "--no-rich-output" in sys.argv
+)
 
 error_style = Style(color="red", bold=True)
 warning_style = Style(color="yellow", bold=True)
 console = Console(
     log_path=False,
     theme=Theme({"log.message": "green bold"}),
-    force_terminal=not no_rich_output,
+    # no_rich_output forces fully plain output (no color, no animation).
+    # Otherwise auto-detect the terminal (force_terminal=None): a real TTY
+    # gets the animated Live spinner, but piped output (CI, cloud build)
+    # must NOT be fed one line per animation frame — forcing the terminal
+    # on there floods non-TTY logs with thousands of spinner redraws.
+    force_terminal=False if no_rich_output else None,
 )
 verbose1_style = Style(dim=True, bold=False)
 verbose2_style = Style(color="bright_black", bold=False)

{flet_cli-0.86.1 → flet_cli-0.86.3}/src/flet_cli/commands/run.py

@@ -47,6 +47,16 @@ class Command(BaseCommand):
             default=".",
             help="Path to the Python script that starts your Flet app",
         )
+        parser.add_argument(
+            "script_args",
+            type=str,
+            nargs="*",
+            default=[],
+            metavar="args",
+            help="Arguments to pass to your app script, available there as "
+            "`sys.argv[1:]`. Separate them from Flet's own options with `--`, "
+            "e.g. `flet run --web app.py -- --verbose`",
+        )
         parser.add_argument(
             "-p",
             "--port",
@@ -287,7 +297,8 @@ class Command(BaseCommand):
         my_event_handler = Handler(
             args=[sys.executable, "-u"]
             + ["-m"] * options.module
-            + [options.script if options.module else script_path],
+            + [options.script if options.module else script_path]
+            + list(options.script_args),
             watch_directory=options.directory or options.recursive,
             script_path=str(script_path),
             port=port,

{flet_cli-0.86.1 → flet_cli-0.86.3}/src/flet_cli/utils/python_versions.py

@@ -28,7 +28,7 @@ from flet_cli.utils.template_cache import get_cache_root
 # python-build release this flet pins. Keep in sync with serious_python's
 # `pythonReleaseDate` (lib/src/python_versions.dart) — both should track the
 # same python-build release.
-PYTHON_BUILD_RELEASE_DATE = "20260714"
+PYTHON_BUILD_RELEASE_DATE = "20260726"
 
 RELEASE_DATE_ENV = "FLET_PYTHON_BUILD_RELEASE_DATE"
 MANIFEST_PATH_ENV = "FLET_PYTHON_BUILD_MANIFEST"

flet_cli-0.86.3/src/flet_cli/version.py

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

{flet_cli-0.86.1 → flet_cli-0.86.3}/src/flet_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flet-cli
-Version: 0.86.1
+Version: 0.86.3
 Summary: Flet CLI
 Author-email: "Appveyor Systems Inc." <hello@flet.dev>
 License-Expression: Apache-2.0
@@ -9,7 +9,7 @@ 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==0.86.1
+Requires-Dist: flet==0.86.3
 Requires-Dist: watchdog>=4.0.0
 Requires-Dist: packaging>=25.0
 Requires-Dist: qrcode>=7.4.2

{flet_cli-0.86.1 → flet_cli-0.86.3}/src/flet_cli.egg-info/SOURCES.txt

@@ -50,6 +50,8 @@ src/flet_cli/utils/pyproject_toml.py
 src/flet_cli/utils/python_versions.py
 src/flet_cli/utils/template_cache.py
 tests/test_clean.py
+tests/test_find_platform_image.py
 tests/test_plist.py
 tests/test_project_dependencies.py
-tests/test_python_versions.py
+tests/test_python_versions.py
+tests/test_run_script_args.py

{flet_cli-0.86.1 → flet_cli-0.86.3}/src/flet_cli.egg-info/requires.txt

@@ -1,4 +1,4 @@
-flet==0.86.1
+flet==0.86.3
 watchdog>=4.0.0
 packaging>=25.0
 qrcode>=7.4.2

flet_cli-0.86.3/tests/test_find_platform_image.py

@@ -0,0 +1,67 @@
+"""Icon/splash image selection in `flet build`.
+
+`find_platform_image` must pick a *decodable* image deterministically when
+several files share a base name — otherwise the choice depends on filesystem
+glob order and an `icon.svg` can slip through to `flutter_launcher_icons`,
+which crashes with `NoDecoderForImageFormatException`.
+"""
+
+from types import SimpleNamespace
+
+from flet_cli.commands.build_base import BaseBuildCommand
+
+
+class _FakeHash:
+    def update(self, *_):
+        pass
+
+
+def _find(tmp_path, filenames, *, image_name="icon", target_platform="web"):
+    assets = tmp_path / "assets"
+    assets.mkdir(exist_ok=True)
+    for name in filenames:
+        (assets / name).write_bytes(b"x")
+    dest = tmp_path / "images"
+    dest.mkdir(exist_ok=True)
+    fake_self = SimpleNamespace(target_platform=target_platform, verbose=0)
+    copy_ops: list = []
+    result = BaseBuildCommand.find_platform_image(
+        fake_self, assets, dest, image_name, copy_ops, _FakeHash()
+    )
+    return result, copy_ops
+
+
+def test_prefers_raster_over_svg(tmp_path):
+    # Both present: the raster png must win regardless of glob order.
+    result, copy_ops = _find(tmp_path, ["icon.svg", "icon.png"])
+    assert result == "icon.png"
+    assert copy_ops and str(copy_ops[0][0]).endswith("icon.png")
+
+
+def test_png_preferred_over_other_raster(tmp_path):
+    # Ranking, not alphabetical order (jpg < png alphabetically).
+    result, _ = _find(tmp_path, ["icon.jpg", "icon.png"])
+    assert result == "icon.png"
+
+
+def test_svg_only_returns_none_with_warning(tmp_path, capsys):
+    result, copy_ops = _find(tmp_path, ["icon.svg"])
+    assert result is None
+    assert copy_ops == []
+    combined = capsys.readouterr()
+    assert "icon.svg" in (combined.out + combined.err)
+
+
+def test_no_candidates_is_silent_none(tmp_path, capsys):
+    result, copy_ops = _find(tmp_path, [])
+    assert result is None
+    assert copy_ops == []
+    combined = capsys.readouterr()
+    assert "Warning" not in (combined.out + combined.err)
+
+
+def test_ico_is_windows_only(tmp_path):
+    # ico is incompatible on web (no raster sibling) -> default icon.
+    assert _find(tmp_path, ["icon.ico"], target_platform="web")[0] is None
+    # ...but valid on a windows build.
+    assert _find(tmp_path, ["icon.ico"], target_platform="windows")[0] == "icon.ico"

flet_cli-0.86.3/tests/test_run_script_args.py

@@ -0,0 +1,103 @@
+import pytest
+
+from flet_cli.cli import parse_command_line
+
+
+def _parse(*argv):
+    """Parse a Flet command line given as separate arguments."""
+    return parse_command_line(list(argv))
+
+
+def test_no_script_args():
+    """A plain `flet run app.py` passes nothing to the script."""
+    args = _parse("run", "app.py")
+
+    assert args.script == "app.py"
+    assert args.script_args == []
+
+
+def test_script_args_after_separator():
+    """Arguments after `--` are forwarded to the script, options and all."""
+    args = _parse("run", "app.py", "--", "--manual", "-x", "1")
+
+    assert args.script == "app.py"
+    assert args.script_args == ["--manual", "-x", "1"]
+
+
+def test_flet_options_are_not_forwarded():
+    """Flet's own options before `--` stay with Flet."""
+    args = _parse("run", "-w", "app.py", "--", "--web")
+
+    assert args.web is True
+    assert args.script == "app.py"
+    assert args.script_args == ["--web"]
+
+
+def test_flet_options_between_script_and_separator():
+    """Flet's options may follow the script path and precede `--`."""
+    args = _parse("run", "app.py", "--web", "--port", "8080", "--", "--manual")
+
+    assert args.web is True
+    assert args.port == 8080
+    assert args.script_args == ["--manual"]
+
+
+def test_positional_script_args_need_no_separator():
+    """Arguments that don't look like options are forwarded without `--`."""
+    args = _parse("run", "app.py", "foo", "bar")
+
+    assert args.script == "app.py"
+    assert args.script_args == ["foo", "bar"]
+
+
+def test_positional_and_separated_script_args_are_combined():
+    """Arguments before and after `--` are forwarded in command-line order."""
+    args = _parse("run", "app.py", "foo", "--", "--manual")
+
+    assert args.script_args == ["foo", "--manual"]
+
+
+def test_script_args_with_module():
+    """`-m` module invocations forward script arguments too."""
+    args = _parse("run", "-m", "my_app.main", "--", "--manual")
+
+    assert args.module is True
+    assert args.script == "my_app.main"
+    assert args.script_args == ["--manual"]
+
+
+def test_script_args_with_implicit_run_command():
+    """The default `run` subcommand is applied even with a `--` separator."""
+    args = _parse("app.py", "--", "--manual")
+
+    assert args.command == "run"
+    assert args.script == "app.py"
+    assert args.script_args == ["--manual"]
+
+
+def test_script_args_named_like_a_subcommand():
+    """A script argument matching a subcommand name doesn't select it."""
+    args = _parse("app.py", "--", "build", "test")
+
+    assert args.command == "run"
+    assert args.script == "app.py"
+    assert args.script_args == ["build", "test"]
+
+
+def test_unknown_flet_option_is_rejected(capsys):
+    """A mistyped Flet option still errors instead of reaching the script."""
+    with pytest.raises(SystemExit):
+        _parse("run", "app.py", "--wev")
+
+    err = capsys.readouterr().err
+    assert "unrecognized arguments: --wev" in err
+    # ...and the error suggests the `--` separator
+    assert "flet run app.py -- --wev" in err
+
+
+def test_separator_rejected_for_other_commands(capsys):
+    """Only `flet run` accepts a `--` separator."""
+    with pytest.raises(SystemExit):
+        _parse("build", "apk", "--", "--manual")
+
+    assert "only supported by `flet run`" in capsys.readouterr().err

flet_cli-0.86.1/src/flet_cli/version.py

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