flet-cli 1.1.0.dev1__py3-none-any.whl → 1.1.0.dev3__py3-none-any.whl

flet_cli/__pyinstaller/__init__.py

@@ -1,7 +1,7 @@
 import os
 
 
-def get_hook_dirs():
+def get_hook_dirs() -> list[str]:
     """
     Return directories containing PyInstaller hook modules for `flet-cli`.
     """

flet_cli/__pyinstaller/config.py

@@ -1 +1,15 @@
 temp_bin_dir = None
+
+verbose = 0
+"""
+Number of `-v` flags `flet pack` runs with.
+"""
+
+
+def log_progress(*args) -> None:
+    """
+    Print a progress message of `flet pack`, shown with `-v` only.
+    """
+
+    if verbose > 0:
+        print(*args)

flet_cli/__pyinstaller/extensions.py

@@ -0,0 +1,177 @@
+import ast
+import importlib.metadata
+import re
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+_PACKAGE_URI = re.compile(rb"package:([a-z][a-z0-9_]*)/")
+
+# Directories that hold no app code, skipped when looking for the app's imports.
+_SKIPPED_DIRS = {"__pycache__", "build", "dist", "node_modules", "site-packages"}
+
+
+@dataclass
+class InstalledExtension:
+    """
+    A Flet extension installed in the current environment.
+    """
+
+    package: str
+    """
+    Name of the extension's Flutter package.
+    """
+
+    distribution: Optional[str]
+    """
+    Name of the distribution that installed it, if known.
+    """
+
+    modules: set[str]
+    """
+    Top-level Python modules the extension provides.
+    """
+
+
+def get_client_extensions(snapshot_path: str) -> Optional[set[str]]:
+    """
+    Return the Flutter packages compiled into a prebuilt Flet client.
+
+    Release builds keep the `package:<name>/` URI of every Dart library in the
+    app's AOT snapshot: `data/app.so` on Windows, `lib/libapp.so` on Linux and
+    `Contents/Frameworks/App.framework/App` in a macOS app bundle.
+
+    Args:
+        snapshot_path: Path to the client's AOT snapshot.
+
+    Returns:
+        Names of the packages, or `None` when the snapshot is missing or names no
+            `flet` library, so the client's extensions can't be told.
+    """
+
+    path = Path(snapshot_path)
+    if not path.is_file():
+        return None
+    packages = {m.decode() for m in _PACKAGE_URI.findall(path.read_bytes())}
+    return packages if "flet" in packages else None
+
+
+def find_installed_extensions() -> list[InstalledExtension]:
+    """
+    Return the Flet extensions installed in the current environment.
+
+    An extension is a distribution that installs a `flutter/<package>/pubspec.yaml`
+    file. Editable installs list no such file in their `RECORD`, so a
+    `flutter/<package>` folder on `sys.path` that no distribution owns is reported
+    too when the same `sys.path` entry has a Python module named `<package>`.
+    """
+
+    extensions: dict[str, InstalledExtension] = {}
+    for dist in importlib.metadata.distributions():
+        files = dist.files or []
+        packages = {
+            f.parts[1]
+            for f in files
+            if len(f.parts) == 3
+            and f.parts[0] == "flutter"
+            and f.parts[2] == "pubspec.yaml"
+        }
+        if not packages:
+            continue
+        modules = {
+            Path(f.parts[0]).stem
+            for f in files
+            if f.parts[0] not in ("flutter", "..", "__pycache__")
+            and not f.parts[0].endswith((".dist-info", ".data", ".pth"))
+            and (len(f.parts) > 1 or f.suffix == ".py")
+        }
+        for package in packages:
+            extensions.setdefault(
+                package,
+                InstalledExtension(package, dist.metadata["Name"], modules),
+            )
+
+    for entry in sys.path:
+        entry_dir = Path(entry or ".")
+        if not (entry_dir / "flutter").is_dir():
+            continue
+        for pubspec in sorted((entry_dir / "flutter").glob("*/pubspec.yaml")):
+            package = pubspec.parent.name
+            if (entry_dir / package).is_dir() or (
+                entry_dir / f"{package}.py"
+            ).is_file():
+                extensions.setdefault(
+                    package, InstalledExtension(package, None, {package})
+                )
+
+    return sorted(extensions.values(), key=lambda e: e.package)
+
+
+def find_imported_modules(app_dir: Path) -> set[str]:
+    """
+    Return the top-level modules the app's Python files import.
+
+    Virtual environments, hidden folders, build output and symlinked folders in
+    `app_dir` are skipped, as are files that can't be read or don't parse.
+
+    Args:
+        app_dir: Directory of the app's main script.
+    """
+
+    modules: set[str] = set()
+    for path in _iter_app_files(app_dir):
+        try:
+            tree = ast.parse(path.read_bytes(), filename=str(path))
+        except (OSError, SyntaxError, ValueError):
+            continue
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                modules.update(alias.name.split(".")[0] for alias in node.names)
+            elif isinstance(node, ast.ImportFrom) and node.module and not node.level:
+                modules.add(node.module.split(".")[0])
+    return modules
+
+
+def find_missing_extensions(
+    app_dir: Path, client_extensions: set[str]
+) -> list[InstalledExtension]:
+    """
+    Return the installed extensions the app imports but the client lacks.
+
+    Args:
+        app_dir: Directory of the app's main script.
+        client_extensions: Flutter packages compiled into the client, as
+            returned by `get_client_extensions()`.
+    """
+
+    candidates = [
+        e for e in find_installed_extensions() if e.package not in client_extensions
+    ]
+    if not candidates:
+        return []
+    imported = find_imported_modules(app_dir)
+    return [e for e in candidates if e.modules & imported]
+
+
+def _iter_app_files(directory: Path):
+    """
+    Yield the Python files of an app folder, recursively.
+    """
+
+    try:
+        paths = sorted(directory.iterdir())
+    except OSError:
+        return
+    for path in paths:
+        if path.is_dir():
+            if (
+                path.is_symlink()
+                or path.name.startswith(".")
+                or path.name in _SKIPPED_DIRS
+                or (path / "pyvenv.cfg").exists()
+            ):
+                continue
+            yield from _iter_app_files(path)
+        elif path.suffix == ".py":
+            yield path

flet_cli/__pyinstaller/hook-flet_desktop.py

@@ -0,0 +1,3 @@
+from flet.utils import is_windows
+
+excludedimports = [] if is_windows() else ["flet_desktop.win_taskbar"]

flet_cli/__pyinstaller/macos_utils.py

@@ -5,14 +5,16 @@ import shutil
 import subprocess
 import tarfile
 from pathlib import Path
+from typing import Any, Optional
 
 from PyInstaller.building.icon import normalize_icon_type
 
+import flet_cli.__pyinstaller.config as hook_config
 from flet.utils import safe_tar_extractall
 from flet_cli.__pyinstaller.utils import normalize_tar_entry
 
 
-def unpack_app_bundle(tar_path):
+def unpack_app_bundle(tar_path: str) -> str:
     """
     Extract a macOS app bundle archive and remove the source tarball.
 
@@ -32,7 +34,7 @@ def unpack_app_bundle(tar_path):
     return os.path.join(bin_dir, "Flet.app")
 
 
-def update_flet_view_icon(app_path, icon_path):
+def update_flet_view_icon(app_path: str, icon_path: str) -> None:
     """
     Replace app icon in a macOS app bundle and update Info.plist metadata.
 
@@ -41,7 +43,7 @@ def update_flet_view_icon(app_path, icon_path):
         icon_path: Path to source icon file.
     """
 
-    print("Updating Flet View icon", app_path, icon_path)
+    hook_config.log_progress("Updating Flet View icon", app_path, icon_path)
 
     icon_file = "AppIcon.icns"
 
@@ -51,7 +53,7 @@ def update_flet_view_icon(app_path, icon_path):
     )
 
     # patch icon
-    print("Copying icons from", normalized_icon_path)
+    hook_config.log_progress("Copying icons from", normalized_icon_path)
     shutil.copy(
         normalized_icon_path,
         os.path.join(app_path, "Contents", "Resources", icon_file),
@@ -65,12 +67,12 @@ def update_flet_view_icon(app_path, icon_path):
 
 
 def update_flet_view_version_info(
-    app_path,
-    bundle_id,
-    product_name,
-    product_version,
-    copyright,
-):
+    app_path: str,
+    bundle_id: Optional[str],
+    product_name: Optional[str],
+    product_version: Optional[str],
+    copyright: Optional[str],
+) -> str:
     """
     Update selected Info.plist metadata fields in a macOS app bundle.
 
@@ -85,7 +87,7 @@ def update_flet_view_version_info(
         Final app bundle path (may change when app bundle is renamed).
     """
 
-    print("Updating Flet View plist", app_path)
+    hook_config.log_progress("Updating Flet View plist", app_path)
 
     pl = __load_info_plist(app_path)
 
@@ -109,7 +111,7 @@ def update_flet_view_version_info(
     return app_path
 
 
-def assemble_app_bundle(app_path, tar_path):
+def assemble_app_bundle(app_path: str, tar_path: str) -> None:
     """
     Code-sign a macOS app bundle, package it as tar.gz, and remove unpacked bundle.
 
@@ -122,7 +124,7 @@ def assemble_app_bundle(app_path, tar_path):
     """
 
     # sign app bundle
-    print(f"Signing file {app_path}")
+    hook_config.log_progress(f"Signing file {app_path}")
     cmd_args = [
         "codesign",
         "-s",
@@ -162,7 +164,7 @@ def assemble_app_bundle(app_path, tar_path):
     shutil.rmtree(app_path, ignore_errors=True)
 
 
-def __load_info_plist(app_path):
+def __load_info_plist(app_path: str) -> dict[str, Any]:
     """
     Load Info.plist content from a macOS app bundle.
     """
@@ -171,7 +173,7 @@ def __load_info_plist(app_path):
         return plistlib.load(fp)
 
 
-def __save_info_plist(app_path, pl):
+def __save_info_plist(app_path: str, pl: dict[str, Any]) -> None:
     """
     Save Info.plist content to a macOS app bundle.
 
@@ -184,7 +186,7 @@ def __save_info_plist(app_path, pl):
         plistlib.dump(pl, fp)
 
 
-def __get_plist_path(app_path):
+def __get_plist_path(app_path: str) -> str:
     """
     Return path to `Info.plist` inside a macOS app bundle.
     """

flet_cli/__pyinstaller/utils.py

@@ -3,12 +3,13 @@ import tarfile
 import tempfile
 import uuid
 from pathlib import Path
+from typing import Optional
 
 from flet.utils import copy_tree
 from flet_desktop import ensure_client_cached
 
 
-def get_flet_bin_path():
+def get_flet_bin_path() -> Optional[str]:
     """
     Return path to Flet desktop binaries, if available.
 
@@ -52,7 +53,7 @@ def normalize_tar_entry(tarinfo: tarfile.TarInfo) -> tarfile.TarInfo:
     return tarinfo
 
 
-def copy_flet_bin():
+def copy_flet_bin() -> Optional[str]:
     """
     Copy packaged Flet desktop binaries into a temporary directory.
 

flet_cli/__pyinstaller/win_utils.py

@@ -1,26 +1,34 @@
 import os
+import shutil
 import tempfile
 import uuid
 from pathlib import Path
+from typing import Optional
 
 import pefile
 from packaging import version
-from PyInstaller.building.icon import normalize_icon_type
 from PyInstaller.compat import win32api
 from PyInstaller.utils.win32 import versioninfo
 from PyInstaller.utils.win32.icon import IconFile, normalize_icon_type
 
+import flet_cli.__pyinstaller.config as hook_config
 
-def update_flet_view_icon(exe_path, icon_path):
+
+def update_flet_view_icon(exe_path: str, icon_path: str) -> None:
     """
     Replace icon resources in a Windows executable.
 
+    When the icon is an `.ico` file, or an image converted to one, it is also
+    written to `data/app_icon.ico` next to the executable: Windows shows the icon
+    of an app without package identity on its notifications from an image file,
+    not from the executable's resources.
+
     Args:
         exe_path: Path to target executable file.
         icon_path: Path to source icon file or executable resource.
     """
 
-    print("Updating Flet View icon", exe_path, icon_path)
+    hook_config.log_progress("Updating Flet View icon", exe_path, icon_path)
 
     RT_ICON = 3
     RT_GROUP_ICON = 14
@@ -29,7 +37,7 @@ def update_flet_view_icon(exe_path, icon_path):
         icon_path, ("exe", "ico"), "ico", os.getcwd()
     )
     icon = IconFile(normalized_icon_path)
-    print("Copying icons from", normalized_icon_path)
+    hook_config.log_progress("Copying icons from", normalized_icon_path)
 
     hdst = win32api.BeginUpdateResource(exe_path, 0)
 
@@ -40,23 +48,34 @@ def update_flet_view_icon(exe_path, icon_path):
     data = icon.grp_icon_dir()
     data = data + icon.grp_icondir_entries(iconid)
     win32api.UpdateResource(hdst, RT_GROUP_ICON, i, data, 1033)
-    print("Writing RT_GROUP_ICON %d resource with %d bytes", i, len(data))
+    hook_config.log_progress(
+        f"Writing RT_GROUP_ICON {i} resource with {len(data)} bytes"
+    )
     for data in icon.images:
         win32api.UpdateResource(hdst, RT_ICON, iconid, data, 1033)
-        print("Writing RT_ICON %d resource with %d bytes", iconid, len(data))
+        hook_config.log_progress(
+            f"Writing RT_ICON {iconid} resource with {len(data)} bytes"
+        )
         iconid = iconid + 1
 
     win32api.EndUpdateResource(hdst, 0)
 
+    # Copy the icon only when normalize_icon_type() produced an .ico file.
+    if Path(normalized_icon_path).suffix.lower() == ".ico":
+        icon_file = Path(exe_path).parent / "data" / "app_icon.ico"
+        icon_file.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(normalized_icon_path, icon_file)
+        hook_config.log_progress("Writing", icon_file)
+
 
 def update_flet_view_version_info(
-    exe_path,
-    product_name,
-    file_description,
-    product_version,
-    file_version,
-    company_name,
-    copyright,
+    exe_path: str,
+    product_name: Optional[str],
+    file_description: Optional[str],
+    product_version: Optional[str],
+    file_version: Optional[str],
+    company_name: Optional[str],
+    copyright: Optional[str],
 ) -> str:
     """
     Update VERSIONINFO resources in a Windows executable.
@@ -74,7 +93,7 @@ def update_flet_view_version_info(
         Path to a temporary text file containing serialized version info.
     """
 
-    print("Updating Flet View version info", exe_path)
+    hook_config.log_progress("Updating Flet View version info", exe_path)
 
     # load versioninfo from exe
     if versioninfo.read_version_info_from_executable:

flet_cli/commands/build.py

@@ -109,6 +109,7 @@ class Command(BaseBuildCommand):
                 self.update_flutter_dependencies()
             self.customize_icons()
             self.customize_splash_images()
+            self.copy_android_resources()
             self.run_flutter()
             self.copy_build_output()
             if self.target_platform == "macos":
@@ -178,14 +179,14 @@ class Command(BaseBuildCommand):
 
         if (
             self.target_platform in ("apk", "aab")
-            and self.template_data["options"]["target_arch"]
+            and self.template_data["_options"]["target_arch"]
         ):
             args.extend(
                 [
                     "--target-platform",
                     ",".join(
                         flutter_target_platforms(
-                            self.template_data["options"]["target_arch"]
+                            self.template_data["_options"]["target_arch"]
                         )
                     ),
                 ]
@@ -575,7 +576,7 @@ class Command(BaseBuildCommand):
             # The authoritative check reads the built app's Info.plist; this
             # one catches the common case — the key not configured at all —
             # before the build.
-            if not self.template_data["options"]["info_plist"].get(
+            if not self.template_data["_options"]["info_plist"].get(
                 "LSApplicationCategoryType"
             ):
                 self.cleanup(