ci: read Flutter version from .fvmrc and update version.py

Author: ndonkoHenri

.github/scripts/common.sh

@@ -10,6 +10,13 @@ function patch_python_package_versions() {
       uv version --package "$pkg" "$PYPI_VER"
       echo "Patched version for $pkg to $PYPI_VER"
     done
+
+    # Get Flutter version from .fvmrc and set it in version.py
+    FLUTTER_VERSION="$(
+      uv run --no-default-groups "$SCRIPTS/read_fvmrc.py" "${ROOT}/.fvmrc" 2>/dev/null || true
+    )"
+    sed -i -e "s/FLUTTER_VERSION = \"\"/FLUTTER_VERSION = \"$FLUTTER_VERSION\"/g" packages/flet/src/flet/version.py
+    echo "Patched Flutter SDK version to $FLUTTER_VERSION"
 }
 
 

.github/scripts/read_fvmrc.py

@@ -0,0 +1,25 @@
+"""
+Reads the Flutter version from a .fvmrc file and prints it.
+
+Usage:
+    uv run read_fvmrc.py <fvmrc_file>
+"""
+
+import json
+import sys
+
+
+def main() -> None:
+    try:
+        with open(sys.argv[1], encoding="utf-8") as f:
+            v = json.load(f)["flutter"].strip()
+            if not v:
+                raise ValueError("Empty 'flutter' value in .fvmrc")
+            print(v)
+    except Exception as e:
+        print(f"Error parsing {sys.argv[1]}: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

.github/workflows/macos-integration-tests.yml

@@ -1,22 +1,22 @@
 name: macOS Integration Tests
 
 on:
-  push:
-    paths:
-      - '.github/workflows/macos-integration-tests.yml'
-      - 'sdk/python/packages/flet/src/**'
-      - 'sdk/python/packages/flet/integration_tests/**'
-      - 'packages/flet/**'
-      - 'client/**'
-      - '.fvmrc'
-  pull_request:
-    paths:
-      - '.github/workflows/macos-integration-tests.yml'
-      - 'sdk/python/packages/flet/src/**'
-      - 'sdk/python/packages/flet/integration_tests/**'
-      - 'packages/flet/**'
-      - 'client/**'
-      - '.fvmrc'
+#  push:
+#    paths:
+#      - '.github/workflows/macos-integration-tests.yml'
+#      - 'sdk/python/packages/flet/src/**'
+#      - 'sdk/python/packages/flet/integration_tests/**'
+#      - 'packages/flet/**'
+#      - 'client/**'
+#      - '.fvmrc'
+#  pull_request:
+#    paths:
+#      - '.github/workflows/macos-integration-tests.yml'
+#      - 'sdk/python/packages/flet/src/**'
+#      - 'sdk/python/packages/flet/integration_tests/**'
+#      - 'packages/flet/**'
+#      - 'client/**'
+#      - '.fvmrc'
   workflow_dispatch:
 
 # Ensure only one run per branch (PR or push), cancel older ones

sdk/python/packages/flet-cli/src/flet_cli/commands/build.py

@@ -22,7 +22,7 @@ def add_arguments(self, parser: argparse.ArgumentParser) -> None:
         parser.add_argument(
             "--flutter-version",
             action="version",
-            version=flet.version.FLUTTER_VERSION,
+            version=flet.version.get_flutter_version() or "Unknown",
             help="Print the required Flutter SDK version and exit.",
         )
         parser.add_argument(

sdk/python/packages/flet-cli/src/flet_cli/commands/devices.py

@@ -34,7 +34,7 @@ def add_arguments(self, parser: argparse.ArgumentParser) -> None:
             type=int,
             default=10,
             dest="device_timeout",
-            help="Time (in seconds) to wait for devices to attach (default: 10).",
+            help="Time (in seconds) to wait for devices to attach (default: 10)",
         )
         parser.add_argument(
             "--device-connection",
@@ -43,7 +43,7 @@ def add_arguments(self, parser: argparse.ArgumentParser) -> None:
             default="both",
             dest="device_connection",
             help="Filter devices by connection type: attached (USB) or wireless "
-            "(default: both).",
+            "(default: both)",
         )
         super().add_arguments(parser)
 

sdk/python/packages/flet-cli/src/flet_cli/commands/flutter_base.py

@@ -21,8 +21,13 @@
 from flet_cli.commands.base import BaseCommand
 from flet_cli.utils.flutter import get_flutter_dir, install_flutter
 
-FLUTTER_VERSION = version.Version(flet_version.FLUTTER_VERSION)
-print(f"Flutter version: {FLUTTER_VERSION}")
+
+def get_flutter_version() -> Optional[version.Version]:
+    flutter_version_str = flet_version.get_flutter_version()
+    if not flutter_version_str:
+        return None
+    return version.Version(flutter_version_str)
+
 
 no_rich_output = get_bool_env_var("FLET_CLI_NO_RICH_OUTPUT")
 
@@ -50,6 +55,7 @@ def __init__(self, parser: argparse.ArgumentParser) -> None:
         self.emojis = {}
         self.dart_exe = None
         self.flutter_exe = None
+        self.required_flutter_version: Optional[version.Version] = None
         self.verbose = False
         self.require_android_sdk = False
         self.skip_flutter_doctor = get_bool_env_var("FLET_CLI_SKIP_FLUTTER_DOCTOR")
@@ -98,6 +104,14 @@ def handle(self, options: argparse.Namespace) -> None:
 
     def initialize_command(self):
         assert self.options
+        self.required_flutter_version = get_flutter_version()
+        if not self.required_flutter_version:
+            self.cleanup(
+                1,
+                "Cannot determine required Flutter SDK version. "
+                "In a development checkout ensure `.fvmrc` exists.",
+            )
+
         self.emojis = {
             "checkmark": "[green]OK[/]" if self.no_rich_output else "✅",
             "loading": "" if self.no_rich_output else "⏳",
@@ -125,7 +139,7 @@ def initialize_command(self):
                 )
                 prompt = (
                     "Flutter SDK "
-                    f"{FLUTTER_VERSION} is required. It will be installed now. "
+                    f"{self.required_flutter_version} is required. It will be installed now. "
                     "Proceed? [y/n] "
                 )
 
@@ -154,6 +168,7 @@ def initialize_command(self):
             self.install_android_sdk()
 
     def flutter_version_valid(self):
+        assert self.required_flutter_version
         version_results = self.run(
             [
                 self.flutter_exe,
@@ -171,18 +186,21 @@ def flutter_version_valid(self):
 
                 # validate installed Flutter version
                 return (
-                    flutter_version.major == FLUTTER_VERSION.major
-                    and flutter_version.minor == FLUTTER_VERSION.minor
+                    flutter_version.major == self.required_flutter_version.major
+                    and flutter_version.minor == self.required_flutter_version.minor
                 )
         else:
             console.log(1, "Failed to validate Flutter version.")
         return False
 
     def install_flutter(self):
-        self.update_status(f"[bold blue]Installing Flutter {FLUTTER_VERSION}...")
+        assert self.required_flutter_version
+        self.update_status(
+            f"[bold blue]Installing Flutter {self.required_flutter_version}..."
+        )
 
         flutter_dir = install_flutter(
-            str(FLUTTER_VERSION), self.log_stdout, progress=self.progress
+            str(self.required_flutter_version), self.log_stdout, progress=self.progress
         )
         ext = ".bat" if platform.system() == "Windows" else ""
         self.flutter_exe = os.path.join(flutter_dir, "bin", f"flutter{ext}")
@@ -222,7 +240,7 @@ def install_flutter(self):
 
         if self.verbose > 0:
             console.log(
-                f"Flutter {FLUTTER_VERSION} installed {self.emojis['checkmark']}"
+                f"Flutter {self.required_flutter_version} installed {self.emojis['checkmark']}"
             )
 
     def install_jdk(self):
@@ -300,7 +318,8 @@ def _prompt_input(self, prompt: str) -> bool:
             self.live.start()
 
     def find_flutter_batch(self, exe_filename: str):
-        install_dir = get_flutter_dir(str(FLUTTER_VERSION))
+        assert self.required_flutter_version
+        install_dir = get_flutter_dir(str(self.required_flutter_version))
         ext = ".bat" if is_windows() else ""
         batch_path = os.path.join(install_dir, "bin", f"{exe_filename}{ext}")
         if os.path.exists(batch_path):

sdk/python/packages/flet-cli/src/flet_cli/commands/serve.py

@@ -65,7 +65,8 @@ def handler(*args, **kwargs):
         try:
             with socketserver.TCPServer(("", options.port), handler) as httpd:
                 console.print(
-                    f"Serving [green]{directory}[/green] at [cyan]http://localhost:{options.port}[/cyan] (Press Ctrl+C to stop)\n"
+                    f"Serving [green]{directory}[/green] at [cyan]"
+                    f"http://localhost:{options.port}[/cyan] (Press Ctrl+C to stop)\n"
                 )
                 httpd.serve_forever()
         except KeyboardInterrupt:

sdk/python/packages/flet/src/flet/version.py

@@ -1,28 +1,29 @@
 """Provide the current Flet version."""
 
+import json
 import os
 import subprocess as sp
 from pathlib import Path
 
-import flet
 from flet.utils import is_mobile, is_windows, which
 
 __all__ = [
-    "DEFAULT_VERSION",
     "FLUTTER_VERSION",
     "PYODIDE_VERSION",
     "find_repo_root",
     "from_git",
+    "get_flutter_version",
     "version",
 ]
 
-DEFAULT_VERSION = "0.1.0"
+DEFAULT_FLET_VERSION = "0.1.0"
 
-# will be replaced by CI
+# set by CI
 version = ""
 
 
-FLUTTER_VERSION = "3.38.3"
+# set by CI
+FLUTTER_VERSION = ""
 """
 The Flutter SDK version used when building the flet client or packaging
 apps with [`flet build`](https://docs.flet.dev/cli/flet-build/).
@@ -35,12 +36,63 @@
 """
 
 
+def _find_upwards(start_dir: Path, file_name: str) -> Path | None:
+    current_dir = start_dir.resolve()
+    while current_dir != current_dir.parent:
+        candidate = current_dir / file_name
+        if candidate.is_file():
+            return candidate
+        current_dir = current_dir.parent
+    return None
+
+
+def _flutter_version_from_fvmrc(fvmrc_path: Path) -> str | None:
+    try:
+        raw = fvmrc_path.read_text(encoding="utf-8").strip()
+    except OSError:
+        return None
+    if not raw:
+        return None
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError:
+        return raw.strip().strip('"')
+    if isinstance(data, dict):
+        value = data.get("flutter")
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    return None
+
+
+def get_flutter_version() -> str:
+    """
+    Return the required Flutter SDK version.
+
+    In CI/release builds the value is stamped into `FLUTTER_VERSION`.
+    In a local development checkout (where `FLUTTER_VERSION == ""`), it is
+    resolved from the repository's `.fvmrc`.
+    """
+
+    if FLUTTER_VERSION:
+        return FLUTTER_VERSION
+    if is_mobile():
+        return ""
+
+    start_dirs = [Path.cwd(), Path(__file__).resolve().parent]
+    for start_dir in start_dirs:
+        fvmrc_path = _find_upwards(start_dir, ".fvmrc")
+        if fvmrc_path:
+            v = _flutter_version_from_fvmrc(fvmrc_path)
+            if v:
+                return v
+    return ""
+
+
 def from_git():
     """Try to get the version from Git tags."""
     working = Path().absolute()
     try:
-        version_file_path = Path(flet.__file__).absolute().parent / "version.py"
-        repo_root = find_repo_root(version_file_path.parent)
+        repo_root = find_repo_root(Path(__file__).resolve().parent)
 
         if repo_root:
             os.chdir(repo_root)
@@ -86,11 +138,11 @@ def find_repo_root(start_path: Path) -> Path | None:
 if not version and not is_mobile():
     # Only try to get the version from Git if the pre-set version is empty
     # This is more likely to happen in a development/source environment
-    version = from_git() or DEFAULT_VERSION  # Fallback to a default if Git fails
+    version = from_git() or DEFAULT_FLET_VERSION  # Fallback to a default if Git fails
 
 # If 'version' is still empty after the above (e.g., in a built package
 # where CI didn't replace it), it might be appropriate to have another
 # default or a way to set it during the build process. However, the
 # CI replacement is the standard way for packaged versions.
 if not version:
-    version = DEFAULT_VERSION  # Final fallback
+    version = DEFAULT_FLET_VERSION  # Final fallback