flet-cli 0.86.2__tar.gz → 0.86.4__tar.gz

{flet_cli-0.86.2 → flet_cli-0.86.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flet-cli
-Version: 0.86.2
+Version: 0.86.4
 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.2
+Requires-Dist: flet==0.86.4
 Requires-Dist: watchdog>=4.0.0
 Requires-Dist: packaging>=25.0
 Requires-Dist: qrcode>=7.4.2

{flet_cli-0.86.2 → flet_cli-0.86.4}/pyproject.toml

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

{flet_cli-0.86.2 → flet_cli-0.86.4}/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.2 → flet_cli-0.86.4}/src/flet_cli/commands/build_base.py

@@ -2290,6 +2290,13 @@ class BaseBuildCommand(BaseFlutterCommand):
             # app here (no app.zip on native); the platform native build copies
             # it into the bundle (Android zips it as a stored asset).
             package_env["SERIOUS_PYTHON_APP"] = str(self.build_dir / "python-app")
+            # app bundle id: serious_python (>= 4.4.2) namespaces the generated
+            # iOS framework bundle identifiers under it. Without it they keep a
+            # shared `org.python.*` default that is byte-identical in every Flet
+            # app — see flet-dev/flet#6724.
+            bundle_id = (self.template_data or {}).get("bundle_id")
+            if bundle_id:
+                package_env["SERIOUS_PYTHON_BUNDLE_ID"] = bundle_id
 
         # Swift Package Manager (darwin): tell serious_python's package command to
         # do the host-side SPM staging (the podspec prepare_command doesn't run
@@ -2565,6 +2572,15 @@ class BaseBuildCommand(BaseFlutterCommand):
             # into the bundle.
             env["SERIOUS_PYTHON_APP"] = str(build_dir / "python-app")
 
+        # app bundle id: the CocoaPods `prepare_command` re-runs the darwin sync
+        # at `flutter build` time, so it needs the same value the package step
+        # got or the framework identifiers fall back to `org.python.*`. Read
+        # defensively — this method is documented as safe to call before the
+        # pipeline has populated every attribute.
+        bundle_id = (getattr(self, "template_data", None) or {}).get("bundle_id")
+        if bundle_id:
+            env["SERIOUS_PYTHON_BUNDLE_ID"] = bundle_id
+
         # Swift Package Manager (darwin): export the cache-bust key the package
         # step computed so the plugin's Package.swift re-resolves when the staged
         # native set changes (SwiftPM caches its graph on manifest text + env).
@@ -2854,11 +2870,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.
@@ -2871,21 +2890,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.2 → flet_cli-0.86.4}/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.2 → flet_cli-0.86.4}/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 = "20260720"
+PYTHON_BUILD_RELEASE_DATE = "20260727"
 
 RELEASE_DATE_ENV = "FLET_PYTHON_BUILD_RELEASE_DATE"
 MANIFEST_PATH_ENV = "FLET_PYTHON_BUILD_MANIFEST"

flet_cli-0.86.4/src/flet_cli/version.py

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

{flet_cli-0.86.2 → flet_cli-0.86.4}/src/flet_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flet-cli
-Version: 0.86.2
+Version: 0.86.4
 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.2
+Requires-Dist: flet==0.86.4
 Requires-Dist: watchdog>=4.0.0
 Requires-Dist: packaging>=25.0
 Requires-Dist: qrcode>=7.4.2

{flet_cli-0.86.2 → flet_cli-0.86.4}/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.2 → flet_cli-0.86.4}/src/flet_cli.egg-info/requires.txt

@@ -1,4 +1,4 @@
-flet==0.86.2
+flet==0.86.4
 watchdog>=4.0.0
 packaging>=25.0
 qrcode>=7.4.2

flet_cli-0.86.4/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.4/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.2/src/flet_cli/version.py

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