flet-cli 1.0.0.dev2__py3-none-any.whl → 1.0.2__py3-none-any.whl

flet_cli/cli.py

@@ -41,6 +41,34 @@ def _render_version(as_json: bool) -> str:
     return f"Flet: {flet.version.flet_version}\nFlutter: {flet.version.flutter_version}"
 
 
+class _PositionalsFixArgumentParser(argparse.ArgumentParser):
+    """
+    An `argparse.ArgumentParser` with the fix for CPython gh-59317 backported.
+
+    Before Python 3.12.7 and 3.13.1, `argparse` gives an optional positional its
+    default as soon as the positionals typed before an option run out, so one
+    typed after the option is rejected. `get_parser()` uses this class only on
+    those interpreters, and subparsers inherit it through `add_subparsers()`.
+    """
+
+    def _match_arguments_partial(self, actions, arg_strings_pattern):
+        """
+        Match positionals as Python 3.12.7+ and 3.13.1+ do: when the typed
+        positionals end at an option, the trailing positionals that matched
+        nothing are left unfilled, so positionals after the option can fill them.
+
+        The matched counts add up to the length of the matched pattern, so the
+        result is unchanged on interpreters whose `argparse` already does this.
+        """
+
+        result = super()._match_arguments_partial(actions, arg_strings_pattern)
+        matched = sum(result)
+        if matched < len(arg_strings_pattern) and arg_strings_pattern[matched] == "O":
+            while result and not result[-1]:
+                result.pop()
+        return result
+
+
 # Source https://stackoverflow.com/a/26379693
 def set_default_subparser(
     parser: argparse.ArgumentParser, name: str, args: list
@@ -88,9 +116,11 @@ def set_default_subparser(
 
 def get_parser() -> argparse.ArgumentParser:
     """Construct and return the CLI argument parser."""
-    parser = argparse.ArgumentParser(
-        formatter_class=argparse.RawDescriptionHelpFormatter
-    )
+    parser = (
+        _PositionalsFixArgumentParser
+        if sys.version_info < (3, 12, 7) or sys.version_info[:3] == (3, 13, 0)
+        else argparse.ArgumentParser
+    )(formatter_class=argparse.RawDescriptionHelpFormatter)
 
     # add version flags
     parser.add_argument(
@@ -138,9 +168,11 @@ 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
+    Everything after the separator is meant for the program the command runs -
+    the app script of `flet run`, pytest for `flet test`, Flutter for
+    `flet build` and `flet debug`, or PyInstaller for `flet pack` - 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
+    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.
 
@@ -169,10 +201,14 @@ def parse_command_line(argv: list) -> argparse.Namespace:
 
     Returns:
         The parsed arguments. For `flet run`, `script_args` holds the arguments
-        to forward to the app script.
+        to forward to the app script, for `flet test`, `pytest_args` holds the
+        arguments to pass to pytest, for `flet build` and `flet debug`,
+        `flutter_build_args` holds the arguments to pass to Flutter, and for
+        `flet pack`, `pyinstaller_build_args` holds the arguments to pass to
+        PyInstaller.
     """
 
-    # pull off the arguments meant for the app script before the parser sees them
+    # pull off arguments meant for the program the command runs before parser sees them
     argv, script_args = split_script_args(argv)
 
     parser = get_parser()
@@ -195,14 +231,32 @@ def parse_command_line(argv: list) -> argparse.Namespace:
             )
         parser.error(message)
 
-    # forward the arguments that followed `--` to the app script
+    # forward the arguments that followed `--` to the program the command runs
     if script_args is not None:
-        if getattr(args, "command", None) != "run":
+        command = getattr(args, "command", None)
+        if command == "run":
+            args.script_args = list(args.script_args) + script_args
+        elif command == "test":
+            args.pytest_args = script_args
+        elif command in ("build", "debug"):
+            if script_args:
+                args.flutter_build_args = [
+                    *(args.flutter_build_args or []),
+                    script_args,
+                ]
+        elif command == "pack":
+            if script_args:
+                args.pyinstaller_build_args = [
+                    *(args.pyinstaller_build_args or []),
+                    script_args,
+                ]
+        else:
             parser.error(
-                "the `--` separator is only supported by `flet run`, to pass "
-                "the arguments that follow it to your app script"
+                "the `--` separator is only supported by commands that run "
+                "another program, which receives the arguments that follow it: "
+                "`flet run` (the app script), `flet test` (pytest), `flet build` "
+                "and `flet debug` (Flutter), and `flet pack` (PyInstaller)"
             )
-        args.script_args = list(args.script_args) + script_args
 
     return args
 

flet_cli/commands/build.py

@@ -43,6 +43,8 @@ class Command(BaseBuildCommand):
     Android (APK/AAB), and iOS (IPA and simulator .app), with a wide range of
     customization options for metadata, assets, splash screens, and signing.
 
+    Arguments after `--` are passed down to the underlying `flutter build`.
+
     Detailed usage guide: https://flet.dev/docs/publish
     """
 
@@ -206,11 +208,7 @@ class Command(BaseBuildCommand):
         if build_version:
             args.extend(["--build-name", build_version])
 
-        for arg in (
-            self.get_pyproject(f"tool.flet.{self.config_platform}.flutter.build_args")
-            or self.get_pyproject("tool.flet.flutter.build_args")
-            or []
-        ):
+        for arg in self.get_platform_setting("flutter.build_args", []):
             args.append(arg)
 
     def run_flutter(self):

flet_cli/commands/build_base.py

@@ -28,6 +28,7 @@ from flet_platform_assets import (
     write,
 )
 from packaging.requirements import Requirement
+from rich.markup import escape
 from rich.panel import Panel
 from rich.table import Column, Table
 
@@ -42,10 +43,12 @@ from flet_cli.commands.flutter_base import (
     verbose2_style,
     warning_style,
 )
+from flet_cli.commands.options import PassThroughArgsAction
 from flet_cli.utils.android import (
     ANDROID_ARCH_TO_FLUTTER_TARGET_PLATFORM,
     excluded_android_abis,
 )
+from flet_cli.utils.app_excludes import find_default_excludes
 from flet_cli.utils.cli import parse_cli_bool_value
 from flet_cli.utils.hash_stamp import HashStamp
 from flet_cli.utils.merge import merge_dict
@@ -358,6 +361,23 @@ class BaseBuildCommand(BaseFlutterCommand):
             help="Files and/or directories to exclude from the package"
             "; can be used multiple times",
         )
+        parser.add_argument(
+            "--include",
+            dest="include",
+            action="extend",
+            nargs="+",
+            default=[],
+            help="Files and/or directories excluded by default to package anyway "
+            "(e.g. `.env`); can be used multiple times",
+        )
+        parser.add_argument(
+            "--no-default-excludes",
+            dest="default_excludes",
+            action="store_false",
+            default=None,
+            help="Package hidden top-level files and directories, virtual "
+            "environments and `__pycache__` directories instead of excluding them",
+        )
         parser.add_argument(
             "--project",
             dest="project_name",
@@ -619,9 +639,12 @@ class BaseBuildCommand(BaseFlutterCommand):
         parser.add_argument(
             "--flutter-build-args",
             dest="flutter_build_args",
-            action="append",
+            action=PassThroughArgsAction,
+            example="--obfuscate",
             nargs="*",
-            help="Additional arguments for flutter build command",
+            help="Additional arguments for flutter build command. Attach an "
+            "argument that starts with `-` using `=`, e.g. "
+            "`--flutter-build-args=--obfuscate`, or pass the arguments after `--`",
         )
         parser.add_argument(
             "--source-packages",
@@ -634,6 +657,7 @@ class BaseBuildCommand(BaseFlutterCommand):
         parser.add_argument(
             "--android-extract-packages",
             dest="android_extract_packages",
+            action="extend",
             nargs="+",
             default=[],
             help="Android only: Python packages (relative paths) to ship extracted "
@@ -860,19 +884,25 @@ class BaseBuildCommand(BaseFlutterCommand):
         self.config_platform = self.platforms[self.target_platform]["config_platform"]
         self.require_android_sdk = self.package_platform == "Android"
 
-        super().initialize_command()
-
         self.python_app_path = Path(self.options.python_app_path).resolve()
 
-        if not (
-            os.path.exists(self.python_app_path) or os.path.isdir(self.python_app_path)
-        ):
+        # validate that the app path exists and is a directory, not a file
+        if not os.path.isdir(self.python_app_path):
+            self.skip_flutter_doctor = True
+            if os.path.isfile(self.python_app_path):
+                self.cleanup(
+                    1,
+                    f"Path to Flet app must be a directory, not a file: "
+                    f"{escape(str(self.python_app_path))}",
+                )
             self.cleanup(
                 1,
                 f"Path to Flet app does not exist or is not a directory: "
-                f"{self.python_app_path}",
+                f"{escape(str(self.python_app_path))}",
             )
 
+        super().initialize_command()
+
         self.rel_out_dir = self.options.output_dir or os.path.join(
             "build", self.platforms[self.target_platform]["dist"]
         )
@@ -1366,10 +1396,8 @@ class BaseBuildCommand(BaseFlutterCommand):
             deep_linking_scheme = self.options.deep_linking_scheme
             deep_linking_host = self.options.deep_linking_host
 
-        target_arch = (
-            self.options.target_arch
-            or self.get_pyproject(f"tool.flet.{self.config_platform}.target_arch")
-            or self.get_pyproject("tool.flet.target_arch")
+        target_arch = self.options.target_arch or self.get_platform_setting(
+            "target_arch"
         )
         target_arch = (
             target_arch
@@ -2532,11 +2560,7 @@ class BaseBuildCommand(BaseFlutterCommand):
 
         dev_packages_configured = False
         if len(toml_dependencies) > 0:
-            dev_packages = (
-                self.get_pyproject(f"tool.flet.{self.config_platform}.dev_packages")
-                or self.get_pyproject("tool.flet.dev_packages")
-                or []
-            )
+            dev_packages = self.get_platform_setting("dev_packages", {})
             if len(dev_packages) > 0:
                 for i in range(0, len(toml_dependencies)):
                     package_name = Requirement(toml_dependencies[i]).name
@@ -2616,25 +2640,63 @@ class BaseBuildCommand(BaseFlutterCommand):
         )
 
         # exclude
-        exclude_list = ["build"]
-
-        app_exclude = (
-            self.options.exclude
-            or self.get_pyproject(f"tool.flet.{self.config_platform}.app.exclude")
-            or self.get_pyproject("tool.flet.app.exclude")
+        app_exclude = self.options.exclude or self.get_platform_setting(
+            "app.exclude", []
         )
-        if app_exclude:
-            exclude_list.extend(app_exclude)
+        explicit_excludes = [
+            "build",
+            *app_exclude,
+            *(["assets"] if self.target_platform == "web" else []),
+        ]
 
-        if self.target_platform == "web":
-            exclude_list.append("assets")
-        package_args.extend(["--exclude", ",".join(exclude_list)])
+        default_excludes: list[str] = []
+        if self.get_bool_setting(
+            self.options.default_excludes, "app.default_excludes", True
+        ):
+            app_include = self.options.include or self.get_platform_setting(
+                "app.include", []
+            )
+            default_excludes = find_default_excludes(
+                self.package_app_path, app_include, explicit_excludes
+            )
+
+        exclude_list = list(dict.fromkeys(explicit_excludes + default_excludes))
+        # one flag per path: serious_python (>= 5.0.0) doesn't split values on
+        # commas, so paths containing `,` survive
+        for path in exclude_list:
+            package_args.extend(["--exclude", path])
+
+        if default_excludes:
+            console.log(
+                "Excluded from app package by default: "
+                f"{', '.join(default_excludes)} "
+                "(use --include <path> or --no-default-excludes to package them)",
+                markup=False,
+            )
+            env_files = [
+                p for p in default_excludes if p == ".env" or p.startswith(".env.")
+            ]
+            if env_files:
+                it = "it" if len(env_files) == 1 else "them"
+                console.log(
+                    f"Warning: {', '.join(env_files)} not packaged. If the app "
+                    f"loads {it} at runtime (e.g. with python-dotenv), package "
+                    f"{it} with `--include {' '.join(env_files)}` or "
+                    f"`include = {json.dumps(env_files)}` under [tool.flet.app] "
+                    "in pyproject.toml.",
+                    style=warning_style,
+                    markup=False,
+                )
+        if self.verbose > 0:
+            console.log(
+                f"App package exclude list: {exclude_list}",
+                style=verbose1_style,
+                markup=False,
+            )
 
         # source-packages
-        source_packages = (
-            self.options.source_packages
-            or self.get_pyproject(f"tool.flet.{self.config_platform}.source_packages")
-            or self.get_pyproject("tool.flet.source_packages")
+        source_packages = self.options.source_packages or self.get_platform_setting(
+            "source_packages"
         )
         if source_packages:
             package_env["SERIOUS_PYTHON_ALLOW_SOURCE_DISTRIBUTIONS"] = ",".join(
@@ -2651,11 +2713,7 @@ class BaseBuildCommand(BaseFlutterCommand):
         if self.package_platform == "Android":
             user_extract_packages = (
                 self.options.android_extract_packages
-                or self.get_pyproject(
-                    f"tool.flet.{self.config_platform}.extract_packages"
-                )
-                or self.get_pyproject("tool.flet.extract_packages")
-                or []
+                or self.get_platform_setting("extract_packages", [])
             )
             self.android_extract_packages = list(
                 dict.fromkeys(ANDROID_DEFAULT_EXTRACT_PACKAGES + user_extract_packages)
@@ -2678,42 +2736,34 @@ class BaseBuildCommand(BaseFlutterCommand):
 
         if cleanup_app_files := (
             self.options.cleanup_app_files
-            or self.get_pyproject(f"tool.flet.{self.config_platform}.cleanup.app_files")
-            or self.get_pyproject("tool.flet.cleanup.app_files")
+            or self.get_platform_setting("cleanup.app_files")
         ):
             if isinstance(cleanup_app_files, str):
                 cleanup_app_files = [
                     value.strip() for value in cleanup_app_files.split(",")
                 ]
             if isinstance(cleanup_app_files, list):
-                package_args.extend(
-                    [
-                        "--cleanup-app-files",
-                        ",".join([v.strip() for v in cleanup_app_files if v.strip()]),
-                    ]
-                )
+                for glob_pattern in cleanup_app_files:
+                    if glob_pattern.strip():
+                        package_args.extend(
+                            ["--cleanup-app-files", glob_pattern.strip()]
+                        )
                 cleanup_app = True
 
         if cleanup_package_files := (
             self.options.cleanup_package_files
-            or self.get_pyproject(
-                f"tool.flet.{self.config_platform}.cleanup.package_files"
-            )
-            or self.get_pyproject("tool.flet.cleanup.package_files")
+            or self.get_platform_setting("cleanup.package_files")
         ):
             if isinstance(cleanup_package_files, str):
                 cleanup_package_files = [
                     value for value in cleanup_package_files.split(",")
                 ]
             if isinstance(cleanup_package_files, list):
-                package_args.extend(
-                    [
-                        "--cleanup-package-files",
-                        ",".join(
-                            [v.strip() for v in cleanup_package_files if v.strip()]
-                        ),
-                    ]
-                )
+                for glob_pattern in cleanup_package_files:
+                    if glob_pattern.strip():
+                        package_args.extend(
+                            ["--cleanup-package-files", glob_pattern.strip()]
+                        )
                 cleanup_packages = True
 
         if cleanup_app:
@@ -2722,6 +2772,15 @@ class BaseBuildCommand(BaseFlutterCommand):
         if cleanup_packages:
             package_args.append("--cleanup-packages")
 
+        if self.verbose > 0:
+            console.log(
+                f"Compile app: {'--compile-app' in package_args}, "
+                f"cleanup app: {cleanup_app}, cleanup packages: {cleanup_packages} "
+                "(cleanup removes serious_python's default junk globs plus any "
+                "--cleanup-app-files/--cleanup-package-files)",
+                style=verbose1_style,
+            )
+
         if self.verbose > 1:
             package_args.append("--verbose")
 
@@ -2840,24 +2899,39 @@ class BaseBuildCommand(BaseFlutterCommand):
             Resolved boolean-like setting value.
         """
 
-        assert self.get_pyproject
         return (
             cli_option
             if cli_option is not None
-            else (
-                self.get_pyproject(f"tool.flet.{self.config_platform}.{pyproj_setting}")
-                if self.get_pyproject(
-                    f"tool.flet.{self.config_platform}.{pyproj_setting}"
-                )
-                is not None
-                else (
-                    self.get_pyproject(f"tool.flet.{pyproj_setting}")
-                    if self.get_pyproject(f"tool.flet.{pyproj_setting}") is not None
-                    else default_value
-                )
-            )
+            else self.get_platform_setting(pyproj_setting, default_value)
         )
 
+    def get_platform_setting(self, pyproj_setting, default_value=None):
+        """
+        Resolve a pyproject setting with precedence: platform, global, default.
+
+        The platform value wins whenever it is set, even when it is empty, so
+        `[]` or `{}` under `tool.flet.<platform>.` clears a global list or table
+        for that platform.
+
+        Args:
+            pyproj_setting: Relative key under `tool.flet.<platform>.` and
+                `tool.flet.`.
+            default_value: Fallback value when neither key is defined.
+
+        Returns:
+            Resolved setting value.
+        """
+
+        assert self.get_pyproject
+        for key in (
+            f"tool.flet.{self.config_platform}.{pyproj_setting}",
+            f"tool.flet.{pyproj_setting}",
+        ):
+            value = self.get_pyproject(key)
+            if value is not None:
+                return value
+        return default_value
+
     def add_flutter_command_args(self, args: list[str]):
         """
         Hook for subclasses to append command-specific Flutter arguments.
@@ -3001,10 +3075,7 @@ class BaseBuildCommand(BaseFlutterCommand):
 
         flutter_build_args = (
             self.options.flutter_build_args
-            or self.get_pyproject(
-                f"tool.flet.{self.config_platform}.flutter.build_args"
-            )
-            or self.get_pyproject("tool.flet.flutter.build_args")
+            or self.get_platform_setting("flutter.build_args")
         )
         if flutter_build_args:
             if isinstance(flutter_build_args, (list, tuple)):

flet_cli/commands/debug.py

@@ -13,6 +13,8 @@ class Command(BaseBuildCommand):
     """
     Run a Flet Python app in debug mode on a specified platform (desktop, web, mobile).
 
+    Arguments after `--` are passed down to the underlying `flutter run`.
+
     Detailed usage guide: https://flet.dev/blog/flet-debug-the-new-cli-for-testing-flet-apps-on-mobile-devices
     """
 

flet_cli/commands/options.py

@@ -32,6 +32,42 @@ class Option:
         group.add_argument(*self.args, **self.kwargs)
 
 
+class PassThroughArgsAction(argparse.Action):
+    """
+    Collect the values of each occurrence of an option that passes arguments on
+    to another program, as one list per occurrence.
+
+    A value that starts with `-` is read as an option of its own unless it is
+    attached with `=`, which leaves the occurrence without values and hands the
+    value to whichever Flet option it names. An occurrence without values is
+    therefore rejected, with a hint to attach the value or to pass it after
+    `--`.
+    """
+
+    def __init__(self, option_strings, dest, example: str, **kwargs):
+        """
+        Args:
+            option_strings: The option strings of the option.
+            dest: The attribute that receives the collected values.
+            example: A value that starts with `-`, shown in the hint.
+            **kwargs: The other `add_argument()` arguments.
+        """
+
+        super().__init__(option_strings, dest, **kwargs)
+        self.example = example
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        if not values:
+            raise argparse.ArgumentError(
+                self,
+                "expected at least one argument - attach one that starts with "
+                f"`-` using `=`, e.g. `{self.option_strings[0]}={self.example}`, "
+                "or pass it after `--`",
+            )
+        collected = getattr(namespace, self.dest, None) or []
+        setattr(namespace, self.dest, [*collected, values])
+
+
 verbose_option = Option(
     "-v",
     "--verbose",

flet_cli/commands/pack.py

@@ -13,6 +13,7 @@ from pathlib import Path
 import flet_cli.__pyinstaller.config as hook_config
 from flet.utils import is_linux, is_macos, is_windows
 from flet_cli.commands.base import BaseCommand
+from flet_cli.commands.options import PassThroughArgsAction
 
 
 class Command(BaseCommand):
@@ -20,6 +21,8 @@ class Command(BaseCommand):
     Package a Flet application into a standalone desktop executable or app bundle
     using PyInstaller.
 
+    Arguments after `--` are passed down to PyInstaller.
+
     Detailed usage guide: https://flet.dev/docs/publish/using-pyinstaller
     """
 
@@ -152,9 +155,12 @@ class Command(BaseCommand):
         parser.add_argument(
             "--pyinstaller-build-args",
             dest="pyinstaller_build_args",
-            action="append",
+            action=PassThroughArgsAction,
+            example="--clean",
             nargs="*",
-            help="Additional raw arguments to the underlying pyinstaller build command",
+            help="Additional raw arguments to the underlying pyinstaller build "
+            "command. Attach an argument that starts with `-` using `=`, e.g. "
+            "`--pyinstaller-build-args=--clean`, or pass the arguments after `--`",
         )
         parser.add_argument(
             "-y",

flet_cli/commands/publish.py

@@ -370,6 +370,7 @@ class Command(BaseCommand):
             pyodide_pre=options.pre,
             pyodide_script_path=str(script_path),
             pyodide_version=python_release.pyodide,
+            app_package_url=app_tar_gz_filename,
             # "canvaskit" default for the same reason as `flet build web`:
             # "auto" puts Chromium on dart2wasm/skwasm, whose JS <-> Dart
             # typed-data boundary costs are a large per-frame tax for

flet_cli/commands/run.py

@@ -1,4 +1,5 @@
 import argparse
+import logging
 import os
 import platform
 import signal
@@ -207,6 +208,11 @@ class Command(BaseCommand):
             options: Parsed command options produced by :meth:`add_arguments`.
         """
 
+        if options.verbose > 0:
+            logging.basicConfig(
+                level=logging.DEBUG if options.verbose > 1 else logging.INFO
+            )
+
         from flet.utils.pip import (
             ensure_flet_desktop_package_installed,
             ensure_flet_web_package_installed,
@@ -350,6 +356,7 @@ class Command(BaseCommand):
             flet_app_data_dir=str(flet_app_data_dir),
             flet_app_cache_dir=str(flet_app_cache_dir),
             flet_app_temp_dir=str(flet_app_temp_dir),
+            verbose=options.verbose,
         )
 
         my_observer = Observer()
@@ -401,6 +408,7 @@ class Handler(FileSystemEventHandler):
         flet_app_data_dir,
         flet_app_cache_dir,
         flet_app_temp_dir,
+        verbose,
     ) -> None:
         super().__init__()
         self.args = args
@@ -425,6 +433,7 @@ class Handler(FileSystemEventHandler):
         self.flet_app_data_dir = flet_app_data_dir
         self.flet_app_cache_dir = flet_app_cache_dir
         self.flet_app_temp_dir = flet_app_temp_dir
+        self.verbose = verbose
         self.terminate = threading.Event()
         self.start_process()
 
@@ -453,7 +462,16 @@ class Handler(FileSystemEventHandler):
             p_env["FLET_SERVER_UDS_PATH"] = self.uds_path
         if self.assets_dir is not None:
             p_env["FLET_ASSETS_DIR"] = self.assets_dir
+        # The app runs with its cwd set to the storage directory below, so a
+        # relative path the user typed in their shell has to be resolved here
+        # while that meaning still holds.
+        web_path = p_env.get("FLET_WEB_PATH")
+        if web_path and not Path(web_path).is_absolute():
+            p_env["FLET_WEB_PATH"] = str(Path(web_path).resolve())
+
         p_env["FLET_DISPLAY_URL_PREFIX"] = self.page_url_prefix
+        if self.verbose > 0:
+            p_env["FLET_LOG_LEVEL"] = "debug" if self.verbose > 1 else "info"
 
         p_env["FLET_APP_STORAGE_DATA"] = self.flet_app_data_dir
         p_env["FLET_APP_STORAGE_CACHE"] = self.flet_app_cache_dir

flet_cli/commands/test.py

@@ -109,6 +109,7 @@ class Command(BaseBuildCommand):
     `flet build`, in test mode) so the app runs on-device with embedded Python,
     then runs pytest. Tests in the `tests/` directory drive the app through the
     `flet_app` fixture (find controls by key, tap, take/assert screenshots).
+    Arguments after `--` are passed to pytest, e.g. `flet test -- -x`.
 
     Detailed usage guide: https://flet.dev/docs/getting-started/integration-testing
     """
@@ -123,9 +124,8 @@ class Command(BaseBuildCommand):
         self.flutter_test_host: Optional[str] = None
 
     def add_arguments(self, parser: argparse.ArgumentParser) -> None:
-        # `platform` is a positional, like `flet debug`. Register it first, then
-        # the inherited build args (which add the `python_app_path` positional),
-        # then our trailing `pytest_args` REMAINDER positional.
+        # register `platform` before the inherited build args, so that it precedes
+        # the `python_app_path` positional they add
         parser.add_argument(
             "platform",
             type=str.lower,
@@ -170,6 +170,7 @@ class Command(BaseBuildCommand):
             help="Only run tests matching the given pytest keyword expression "
             "(passed through to pytest -k).",
         )
+        parser.set_defaults(pytest_args=[])
 
     def handle(self, options: argparse.Namespace) -> None:
         super().handle(options)
@@ -191,6 +192,7 @@ class Command(BaseBuildCommand):
         self.pytest_args = []
         if options.pytest_keyword:
             self.pytest_args += ["-k", options.pytest_keyword]
+        self.pytest_args += options.pytest_args
 
         # Check for pytest availability before provisioning, since `flet test` runs
         # `sys.executable -m pytest` and pytest comes from the app’s `flet[test]`

flet_cli/utils/android_sdk.py

@@ -13,12 +13,15 @@ ANDROID_CMDLINE_TOOLS_DOWNLOAD_VERSION = "11076708"
 ANDROID_CMDLINE_TOOLS_VERSION = "12.0"
 
 MINIMAL_PACKAGES = [
-    "cmdline-tools;latest",
     "platform-tools",
     "platforms;android-35",
     "build-tools;34.0.0",
 ]
 
+# Written to the standard input of `sdkmanager`, which reads one answer line per
+# license prompt; `--licenses` also asks once before showing the licenses.
+SDKMANAGER_ANSWERS = "y\n" * 50
+
 
 class AndroidSDK:
     """
@@ -103,6 +106,11 @@ class AndroidSDK:
         """
         Return the `cmdline-tools` binary directory in an SDK installation.
 
+        The version installed by this CLI is preferred over `latest`, because
+        from version 23.0, `sdkmanager` is a wrapper around the Android CLI,
+        which ignores `--licenses`, collects usage metrics by default and fails
+        on Windows.
+
         Args:
             home_dir: Android SDK home directory.
 
@@ -111,8 +119,8 @@ class AndroidSDK:
         """
 
         for d in [
-            home_dir / "cmdline-tools" / "latest" / "bin",
             home_dir / "cmdline-tools" / ANDROID_CMDLINE_TOOLS_VERSION / "bin",
+            home_dir / "cmdline-tools" / "latest" / "bin",
         ]:
             if d.exists():
                 return d
@@ -322,36 +330,23 @@ class AndroidSDK:
             RuntimeError: If package installation fails.
         """
 
-        if home_dir.joinpath(*package_name.split(";")).exists():
+        package_dir = home_dir.joinpath(*package_name.split(";"))
+        if package_dir.exists():
             self.log(f'Android SDK package "{package_name}" is already installed')
             return 0
 
         self.log(f'Installing Android SDK package "{package_name}"')
 
         p = self.run(
-            (
-                [
-                    "sh",
-                    "-c",
-                    f'yes | "{self.sdkmanager_exe(home_dir)}" "{package_name}"',
-                ]
-                if platform.system() != "Windows"
-                else [
-                    "cmd.exe",
-                    "/C",
-                    "echo",
-                    "y",
-                    "|",
-                    self.sdkmanager_exe(home_dir),
-                    package_name,
-                ]
-            ),
+            [self.sdkmanager_exe(home_dir), package_name],
             env={"ANDROID_HOME": str(home_dir)},
             capture_output=False,
+            input=SDKMANAGER_ANSWERS,
         )
-        if p.returncode != 0:
+        # sdkmanager exits with 0 when it skips a package whose license is declined
+        if p.returncode != 0 or not package_dir.exists():
             self.log(p.stderr)
-            raise RuntimeError("Error installing Android SDK tools")
+            raise RuntimeError(f'Error installing Android SDK package "{package_name}"')
         return 1
 
     def _accept_licenses(self, home_dir: Path):
@@ -368,23 +363,14 @@ class AndroidSDK:
         self.log("Accepting Android SDK licenses")
 
         p = self.run(
-            (
-                ["sh", "-c", f'yes | "{self.sdkmanager_exe(home_dir)}" --licenses']
-                if platform.system() != "Windows"
-                else [
-                    "cmd.exe",
-                    "/C",
-                    "echo",
-                    "y",
-                    "|",
-                    self.sdkmanager_exe(home_dir),
-                    "--licenses",
-                ]
-            ),
+            [self.sdkmanager_exe(home_dir), "--licenses"],
             env={"ANDROID_HOME": str(home_dir)},
             capture_output=False,
+            input=SDKMANAGER_ANSWERS,
         )
-        if p.returncode != 0:
+        # sdkmanager exits with 0 when licenses are declined
+        license_file = home_dir / "licenses" / "android-sdk-license"
+        if p.returncode != 0 or not license_file.exists():
             self.log(p.stderr)
             raise RuntimeError("Error accepting Android SDK licenses")
 
@@ -415,7 +401,7 @@ class AndroidSDK:
             )
         return p.stdout
 
-    def run(self, args, env=None, cwd=None, capture_output=True):
+    def run(self, args, env=None, cwd=None, capture_output=True, input=None):
         """
         Run a subprocess configured for Android SDK tooling.
 
@@ -427,6 +413,8 @@ class AndroidSDK:
             env: Optional additional environment variables.
             cwd: Optional working directory. Defaults to current directory.
             capture_output: Forwarded to subprocess helper.
+            input: Optional text for the subprocess's standard input. Forwarded
+                to subprocess helper.
 
         Returns:
             Subprocess result object returned by `flet_cli.utils.processes.run`.
@@ -447,4 +435,5 @@ class AndroidSDK:
             env=cmd_env,
             capture_output=capture_output,
             log=self.log,
+            input=input,
         )

flet_cli/utils/app_excludes.py

@@ -0,0 +1,117 @@
+import os
+import stat
+import sys
+from collections.abc import Iterable
+from pathlib import Path
+
+PYVENV_CFG = "pyvenv.cfg"
+PYCACHE_DIR = "__pycache__"
+
+
+def _is_hidden(entry: os.DirEntry) -> bool:
+    """
+    Check whether a directory entry is hidden.
+
+    An entry is hidden when its name starts with `.` (on every platform) or,
+    on Windows, when it has the hidden file attribute.
+
+    Args:
+        entry: Directory entry to check.
+
+    Returns:
+        `True` if the entry is hidden, `False` otherwise.
+    """
+
+    if entry.name.startswith("."):
+        return True
+    if sys.platform != "win32":
+        return False
+    try:
+        attributes = entry.stat(follow_symlinks=False).st_file_attributes
+    except OSError:
+        return False
+    return bool(attributes & stat.FILE_ATTRIBUTE_HIDDEN)
+
+
+def _is_venv(path: str) -> bool:
+    return os.path.isfile(os.path.join(path, PYVENV_CFG))
+
+
+def _normalize(paths: Iterable[str]) -> set[str]:
+    return {os.path.normpath(p.replace("/", os.sep)) for p in paths}
+
+
+def find_default_excludes(
+    app_path: Path, include: Iterable[str] = (), exclude: Iterable[str] = ()
+) -> list[str]:
+    """
+    Find app files and directories that are excluded from the package by default.
+
+    Matched are:
+
+    - hidden files and directories directly in `app_path` (a name starting
+      with `.`, or the hidden attribute on Windows);
+    - virtual environments (directories containing `pyvenv.cfg`) at any depth;
+    - `__pycache__` directories at any depth.
+
+    Directory symlinks are followed to match the packager. Links back to an
+    ancestor are always excluded, even if included explicitly, to prevent
+    recursive copying.
+
+    Args:
+        app_path: Root directory of the Python app being packaged.
+        include: Relative paths to keep even if matched by the rules above.
+            Both `/` and `\\` separators are accepted.
+        exclude: Relative paths already excluded from the package. They are
+            not scanned and not returned.
+
+    Returns:
+        Sorted relative paths joined with `os.sep`, the form serious_python
+        compares its exclude list against.
+    """
+
+    keep = _normalize(include)
+    skip = _normalize(exclude)
+    excludes: list[str] = []
+
+    def add(rel_path: str) -> bool:
+        if rel_path in keep:
+            return False
+        excludes.append(rel_path)
+        return True
+
+    # top-level hidden entries
+    subdirs: list[str] = []
+    with os.scandir(app_path) as entries:
+        for entry in entries:
+            if entry.name in skip:
+                continue
+            if _is_hidden(entry) and add(entry.name):
+                continue
+            if entry.is_dir(follow_symlinks=True):
+                subdirs.append(entry.name)
+
+    # virtual environments and __pycache__ at any depth
+    for subdir in subdirs:
+        ancestors = [app_path.resolve()]
+        for dirpath, dirnames, _ in os.walk(app_path / subdir, followlinks=True):
+            rel_dir = os.path.relpath(dirpath, app_path)
+            # Keep only this path's ancestors, not a global visited set: the
+            # packager follows symlinks and copies each alias independently.
+            del ancestors[len(Path(rel_dir).parts) :]
+            resolved = Path(dirpath).resolve()
+            if resolved in ancestors:
+                # Even an included cycle must be excluded from the copy, or
+                # serious_python would recurse into it indefinitely.
+                excludes.append(rel_dir)
+                dirnames.clear()
+                continue
+            ancestors.append(resolved)
+            if (os.path.basename(dirpath) == PYCACHE_DIR or _is_venv(dirpath)) and add(
+                rel_dir
+            ):
+                dirnames.clear()
+                continue
+            dirnames[:] = [d for d in dirnames if os.path.join(rel_dir, d) not in skip]
+
+    return sorted(excludes)

flet_cli/utils/processes.py

@@ -1,3 +1,4 @@
+import contextlib
 import os
 import subprocess
 from typing import Optional
@@ -8,7 +9,14 @@ if is_windows():
     from ctypes import windll
 
 
-def run(args, cwd, env: Optional[dict] = None, capture_output=True, log=None):
+def run(
+    args,
+    cwd,
+    env: Optional[dict] = None,
+    capture_output=True,
+    log=None,
+    input: Optional[str] = None,
+):
     """
     Execute a subprocess command with optional streamed logging.
 
@@ -22,6 +30,9 @@ def run(args, cwd, env: Optional[dict] = None, capture_output=True, log=None):
         capture_output: If `True`, run with `subprocess.run` and
             capture output in memory. If `False`, stream combined output line by line.
         log: Optional callback receiving each output line when `capture_output=False`.
+        input: Optional text written to the command's standard input, which is
+            then closed. When `capture_output=False`, it is written before any
+            output is read, so it must fit in the OS pipe buffer.
 
     Returns:
         A completed `subprocess.CompletedProcess`
@@ -49,6 +60,7 @@ def run(args, cwd, env: Optional[dict] = None, capture_output=True, log=None):
         process = subprocess.run(
             args,
             cwd=cwd,
+            input=input,
             capture_output=True,
             text=True,
             encoding="utf-8",
@@ -68,6 +80,12 @@ def run(args, cwd, env: Optional[dict] = None, capture_output=True, log=None):
             errors="replace",
         )
 
+        if input is not None:
+            # The process may exit or close its standard input before reading it all
+            with contextlib.suppress(OSError):
+                process.stdin.write(input)
+                process.stdin.close()
+
         try:
             while True:
                 stdout_line = process.stdout.readline()

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 = "20260908"
+PYTHON_BUILD_RELEASE_DATE = "20260921"
 
 RELEASE_DATE_ENV = "FLET_PYTHON_BUILD_RELEASE_DATE"
 MANIFEST_PATH_ENV = "FLET_PYTHON_BUILD_MANIFEST"

flet_cli/version.py

@@ -1 +1 @@
-version = "1.0.0.dev2"
+version = "1.0.2"

{flet_cli-1.0.0.dev2.dist-info → flet_cli-1.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flet-cli
-Version: 1.0.0.dev2
+Version: 1.0.2
 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.0.dev2
-Requires-Dist: flet-platform-assets==1.0.0.dev2
+Requires-Dist: flet==1.0.2
+Requires-Dist: flet-platform-assets==1.0.2
 Requires-Dist: watchdog>=4.0.0
 Requires-Dist: packaging>=25.0
 Requires-Dist: qrcode>=7.4.2
@@ -29,6 +29,10 @@ Requires-Dist: flet-mcp; extra == "mcp"
 
 Flet CLI is a command-line interface tool for Flet, a framework for building interactive multi-platform applications using Python.
 
+> **[Try Flet online in Flet Studio](https://studio.flet.dev)**
+>
+> Try an idea in your browser with no installation, then use the Flet CLI locally to develop and package your app. Write your own Python code or get help from the AI agent.
+
 ## Features
 
 - Create new Flet projects

{flet_cli-1.0.0.dev2.dist-info → flet_cli-1.0.2.dist-info}/RECORD

@@ -1,5 +1,5 @@
-flet_cli/cli.py,sha256=IAHFW5kCW6KvHLthdRJqUgxc18xVNSdrSDf-MibGc-o,7544
-flet_cli/version.py,sha256=5y9WdVlv-PO-E_vksl24lRtbW31WAWKlERh977DNJRI,23
+flet_cli/cli.py,sha256=TlUPz73bL6rcSQBBH05uAljU9f-ZsuefEKYR-SbdPbE,10115
+flet_cli/version.py,sha256=tTF5v0pCQ3wj3WtOg6KXgEGkOMgBeRFQACKUYV29zxo,18
 flet_cli/__pyinstaller/__init__.py,sha256=KJsKpQ6uSVslADmFaOKaxCu-GOZZtcVKnti-ripD-ug,164
 flet_cli/__pyinstaller/config.py,sha256=MN2IPu53K1RDyh_KE4wIcQH8El_n4Z3fD6NO2iq8y74,20
 flet_cli/__pyinstaller/hook-flet.py,sha256=RbiFE8-7VBsY4Dwt7a9-9gW0gUFQGjOLY1-OBsZm_mI,506
@@ -9,25 +9,26 @@ flet_cli/__pyinstaller/utils.py,sha256=Im_XkCsnqactsQjKGBjUtQ9FDTPx-b-m2-8ZkEytq
 flet_cli/__pyinstaller/win_utils.py,sha256=wu0G98CUMkGfloZa2LTqJE7axAZPB2-TLBOHJiYUc0Q,4428
 flet_cli/__pyinstaller/rthooks/pyi_rth_localhost_fletd.py,sha256=O8lAxkHmNaXaZNzP-3VTuUhuglYwgJtzaeIKQa2neGU,2379
 flet_cli/commands/base.py,sha256=6MTAuA7kKdaKIZI4AyWPM1TJfFCxmRj7kc7z2h6E_4k,3496
-flet_cli/commands/build.py,sha256=X1yEM4KHxPA00g1Hq1ufvIR5fxQhC8OOEovHfdOZ3Wo,35824
-flet_cli/commands/build_base.py,sha256=ePV3obf3DA-YTPtTcBk0uc3IwDUNZXrYJQmJKmI_hdM,140745
+flet_cli/commands/build.py,sha256=mtiSHyfCbkwmbxx2308KAUgROcS8eg31acm07VhKtW4,35770
+flet_cli/commands/build_base.py,sha256=DJvFbWOhJUsyMih3QrlmQBni6U1oiUsCydgOlOiciJE,143782
 flet_cli/commands/clean.py,sha256=fIRr1ktoE9wzO0R-lAq985zbCH1dX6Sao5VyXiJxiOY,2250
 flet_cli/commands/create.py,sha256=gH4BZw122BcOWlAU7MJHg8epNx9K-7lCquybacHC5pE,5859
-flet_cli/commands/debug.py,sha256=dT80Z_4QEqSyleVGZdCif2u0oMrUKCraG0QmBwjYf30,6768
+flet_cli/commands/debug.py,sha256=FNw6WGSYkuZFbz0bloyDJLKX_GxoKQ812tsOlO5W1Zk,6843
 flet_cli/commands/devices.py,sha256=7kn56lrZLN5LuG_X3IyMdSfdFa421yE4R1otTJr5Yrc,7953
 flet_cli/commands/doctor.py,sha256=uG2xUAT_FASB9cnLD9G83NTYdP9iuKhaHyQLjMB_E4c,1051
 flet_cli/commands/emulators.py,sha256=2VCpu-B70JMsmqNpQoDJoXAvOV-Ex_Kkosa27D16iRk,13215
 flet_cli/commands/flutter_base.py,sha256=1YgILbM3Qn6TSPU_GVitNJ2gQjnI_buBi8Vhd09TO6U,18285
 flet_cli/commands/mcp.py,sha256=AVEnf6YjICqoBQPKqBaHp27KHXxFVjH-IRpAi6dSjcM,2065
-flet_cli/commands/options.py,sha256=tSqztnV4uvXhMEk6VhYe_szoq7CGVTrYlrkdZwMK4ek,1068
-flet_cli/commands/pack.py,sha256=Lgm-536oTJqEPtYO2kpGoMS3Be2Rk6RuJ_6bwLcIDZM,26727
-flet_cli/commands/publish.py,sha256=jBnsHIwgovER59j6a6y5pMFr3WzhRU_SBbrb48J-r20,14532
-flet_cli/commands/run.py,sha256=RcEv8f-6pY4yVgnOubBvMJKqClZmkkckohm1kU22S4I,23515
+flet_cli/commands/options.py,sha256=CD7Fw2CtUeuVrtM_oR1_OrAcMKF2EhRUoPuX9_3IsW8,2543
+flet_cli/commands/pack.py,sha256=qyDLCPM0QxET21b-25Yqmtoje4bYte5XR5tLM0_Ep8Y,27045
+flet_cli/commands/publish.py,sha256=Ra92AZ3NbBMFAnbJxBafaXvmF-3T2tXGO5V6MiHDYp8,14581
+flet_cli/commands/run.py,sha256=7hH_6M7S6R7qkc_MNvjssI5sUUg8I8IOIEvYwOOQgA0,24248
 flet_cli/commands/serve.py,sha256=YrollC80u9JvuXHbI_qQ3wxpjcqpIQwFxdD5nIOeOT4,3143
-flet_cli/commands/test.py,sha256=aMcCASJd6qI1573XJnhfZi9jBZG4RnfWnxP4OvbPXak,12742
+flet_cli/commands/test.py,sha256=mm9tp952BnTD9zWYcQWYyJX8DegKZgb8341OVDvDtQk,12814
 flet_cli/commands/test_host.py,sha256=GrRLpGJf4feJsQydKZaqGX8aY1aPXPEPWCsMqEEgA2k,394
 flet_cli/utils/android.py,sha256=aLANEliQs9B0TobjYVBYBDisr57y8Boo7ej9_KaRkx0,1635
-flet_cli/utils/android_sdk.py,sha256=ljgk0zWh4SX9UAWx7vJK6RyKRz97Y8Be_mEeQDvkli4,13889
+flet_cli/utils/android_sdk.py,sha256=8jRccd0PArpovoNVqiAyp4me_AvQLUb8lmrSQjE0Xfc,14047
+flet_cli/utils/app_excludes.py,sha256=A_QgScerUDKrBSXA4PL1_P9IPNjqRkBik2Y0uJ_W0UQ,3890
 flet_cli/utils/cli.py,sha256=wPtVyfrwOdJ35acr4nVpNiS2p4SQmFD_hDsgYBBzZng,1524
 flet_cli/utils/distros.py,sha256=q0-DOB35xY7JOf3My12sjoZUXYqNeZesBEzoc6VL0W0,3711
 flet_cli/utils/flutter.py,sha256=lcCIAAiKKAAuoGiN304mQCUAUQZYNbL4sxcMT9KSutQ,4767
@@ -38,14 +39,14 @@ flet_cli/utils/linux_deps.py,sha256=gdT3qC6gDVdaNndkb_tkq4alyv0mhru7n6O4pdqX2wc,
 flet_cli/utils/macos_sign.py,sha256=lkqHEZieroD5Nj90Cnz_dwMgaT3FJFvxaC8NV2bcP9c,53384
 flet_cli/utils/merge.py,sha256=cZcUL1z2iaGjjFifL1KCrEj2ywLR9x6eNtOj1F2Dr6U,780
 flet_cli/utils/plist.py,sha256=oqBCkeUjUqPIf5y7XaE2seSx64FEs7yc2cukvbjFoSU,1135
-flet_cli/utils/processes.py,sha256=S0ErmI5x9S6RNMe89cf5M4ROIofMtjNZRQ29foUllJ4,2885
+flet_cli/utils/processes.py,sha256=MIX05itdoYyyE1L2N9NeTciJXk4yzjVMceONhUljwsA,3452
 flet_cli/utils/project_dependencies.py,sha256=kC8gZZyaGk-coNXrh6cyPM6i9RhUaXcBIvZmQ50PufY,4064
 flet_cli/utils/pyodide.py,sha256=RhumXYuovPxgLbu99pNNhVb9SRvBvhLGiUMtb9WxC5U,5058
 flet_cli/utils/pyproject_toml.py,sha256=o4fAWKXMyK8vdnAO41BLI7Lt3ohMlVdlwrpaifq30Cs,1408
-flet_cli/utils/python_versions.py,sha256=Ma9H3m6ZRTg2xqAjEbAKv25-0PH8wdNL1Xy7dw5gYbk,8129
+flet_cli/utils/python_versions.py,sha256=SLMzyU5c-c8BIy3nZvvU5JqnnvGfBa2w1eBTbM9OuwQ,8129
 flet_cli/utils/template_cache.py,sha256=Lf_iuk30zTfaNFbRmrc8s07w1yE-PYjdovZztoiuPzc,1596
-flet_cli-1.0.0.dev2.dist-info/METADATA,sha256=ZnpYfIUOAYRKvAQtx7U4pGIe9bLKTh8qt9FPBL3yrdA,1348
-flet_cli-1.0.0.dev2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-flet_cli-1.0.0.dev2.dist-info/entry_points.txt,sha256=UZFR426y3mfr0wgikEFPbZ6wtGwfgykif9Obw6R7Wnc,65
-flet_cli-1.0.0.dev2.dist-info/top_level.txt,sha256=4_BPVAJpcNofDe3XMxajlZLBNWzWqKhRynNSBCYTKVQ,9
-flet_cli-1.0.0.dev2.dist-info/RECORD,,
+flet_cli-1.0.2.dist-info/METADATA,sha256=aUGuR5Xbr7datAJPO99gO_bjDlqUOj7cw-ZU7Q_ZAXg,1573
+flet_cli-1.0.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+flet_cli-1.0.2.dist-info/entry_points.txt,sha256=UZFR426y3mfr0wgikEFPbZ6wtGwfgykif9Obw6R7Wnc,65
+flet_cli-1.0.2.dist-info/top_level.txt,sha256=4_BPVAJpcNofDe3XMxajlZLBNWzWqKhRynNSBCYTKVQ,9
+flet_cli-1.0.2.dist-info/RECORD,,