flet-cli 0.81.0.dev7148__tar.gz

flet_cli-0.81.0.dev7148/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: flet-cli
+Version: 0.81.0.dev7148
+Summary: Flet CLI
+Author-email: "Appveyor Systems Inc." <hello@flet.dev>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://flet.dev
+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
+Requires-Dist: watchdog>=4.0.0
+Requires-Dist: packaging>=25.0
+Requires-Dist: qrcode>=7.4.2
+Requires-Dist: tomli>=1.1.0; python_version < "3.11"
+Requires-Dist: cookiecutter>=2.6.0
+
+# Flet CLI
+
+Flet CLI is a command-line interface tool for Flet, a framework for building interactive multi-platform applications using Python.
+
+## Features
+
+- Create new Flet projects
+- Run Flet applications
+- Package and deploy Flet apps
+
+## Basic Usage
+
+To create a new Flet project:
+
+```
+flet create myapp
+```

flet_cli-0.81.0.dev7148/README.md

@@ -0,0 +1,17 @@
+# Flet CLI
+
+Flet CLI is a command-line interface tool for Flet, a framework for building interactive multi-platform applications using Python.
+
+## Features
+
+- Create new Flet projects
+- Run Flet applications
+- Package and deploy Flet apps
+
+## Basic Usage
+
+To create a new Flet project:
+
+```
+flet create myapp
+```

flet_cli-0.81.0.dev7148/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "flet-cli"
+version = "0.81.0.dev7148"
+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",
+    "watchdog >=4.0.0",
+    "packaging >=25.0",
+    "qrcode >=7.4.2",
+    "tomli >= 1.1.0 ; python_version < '3.11'",
+    "cookiecutter >=2.6.0"
+]
+
+[project.urls]
+Homepage = "https://flet.dev"
+Repository = "https://github.com/flet-dev/flet"
+Documentation = "https://flet.dev/docs"
+
+[project.entry-points."pyinstaller40"]
+hook-dirs = "flet_cli.__pyinstaller:get_hook_dirs"
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"

flet_cli-0.81.0.dev7148/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

flet_cli-0.81.0.dev7148/src/flet_cli/__pyinstaller/__init__.py

@@ -0,0 +1,5 @@
+import os
+
+
+def get_hook_dirs():
+    return [os.path.dirname(__file__)]

flet_cli-0.81.0.dev7148/src/flet_cli/__pyinstaller/config.py

@@ -0,0 +1 @@
+temp_bin_dir = None

flet_cli-0.81.0.dev7148/src/flet_cli/__pyinstaller/hook-flet.py

@@ -0,0 +1,9 @@
+import flet_cli.__pyinstaller.config as hook_config
+from flet_cli.__pyinstaller.utils import get_flet_bin_path
+
+bin_path = hook_config.temp_bin_dir
+if not bin_path:
+    bin_path = get_flet_bin_path()
+
+if bin_path:
+    datas = [(bin_path, "flet_desktop/app")]

flet_cli-0.81.0.dev7148/src/flet_cli/__pyinstaller/macos_utils.py

@@ -0,0 +1,120 @@
+import os
+import plistlib
+import shutil
+import subprocess
+import tarfile
+from pathlib import Path
+
+from flet.utils import safe_tar_extractall
+from PyInstaller.building.icon import normalize_icon_type
+
+
+def unpack_app_bundle(tar_path):
+    bin_dir = str(Path(tar_path).parent)
+
+    with tarfile.open(tar_path, "r:gz") as tar_arch:
+        safe_tar_extractall(tar_arch, bin_dir)
+    os.remove(tar_path)
+
+    return os.path.join(bin_dir, "Flet.app")
+
+
+def update_flet_view_icon(app_path, icon_path):
+    print("Updating Flet View icon", app_path, icon_path)
+
+    icon_file = "AppIcon.icns"
+
+    # normalize icon
+    normalized_icon_path = normalize_icon_type(
+        icon_path, ("icns",), "icns", os.getcwd()
+    )
+
+    # patch icon
+    print("Copying icons from", normalized_icon_path)
+    shutil.copy(
+        normalized_icon_path,
+        os.path.join(app_path, "Contents", "Resources", icon_file),
+    )
+
+    # update icon file name
+    pl = __load_info_plist(app_path)
+    pl["CFBundleIconFile"] = icon_file
+    del pl["CFBundleIconName"]
+    __save_info_plist(app_path, pl)
+
+
+def update_flet_view_version_info(
+    app_path,
+    bundle_id,
+    product_name,
+    product_version,
+    copyright,
+):
+    print("Updating Flet View plist", app_path)
+
+    pl = __load_info_plist(app_path)
+
+    if bundle_id:
+        pl["CFBundleIdentifier"] = bundle_id
+    if product_name:
+        pl["CFBundleName"] = product_name
+        pl["CFBundleDisplayName"] = product_name
+
+        # rename app bundle
+        new_app_path = os.path.join(Path(app_path).parent, f"{product_name}.app")
+        os.rename(app_path, new_app_path)
+        app_path = new_app_path
+    if product_version:
+        pl["CFBundleShortVersionString"] = product_version
+    if copyright:
+        pl["NSHumanReadableCopyright"] = copyright
+
+    __save_info_plist(app_path, pl)
+
+    return app_path
+
+
+def assemble_app_bundle(app_path, tar_path):
+    # sign app bundle
+    print(f"Signing file {app_path}")
+    cmd_args = [
+        "codesign",
+        "-s",
+        "-",
+        "--force",
+        "--all-architectures",
+        "--timestamp",
+        "--deep",
+        app_path,
+    ]
+    p = subprocess.run(
+        cmd_args,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        universal_newlines=True,
+    )
+    if p.returncode:
+        raise SystemError(
+            f"codesign command ({cmd_args}) failed with error code {p.returncode}!\noutput: {p.stdout}"
+        )
+
+    # pack tar
+    with tarfile.open(tar_path, "w:gz") as tar:
+        tar.add(app_path, arcname=os.path.basename(app_path))
+
+    # cleanup
+    shutil.rmtree(app_path, ignore_errors=True)
+
+
+def __load_info_plist(app_path):
+    with open(__get_plist_path(app_path), "rb") as fp:
+        return plistlib.load(fp)
+
+
+def __save_info_plist(app_path, pl):
+    with open(__get_plist_path(app_path), "wb") as fp:
+        plistlib.dump(pl, fp)
+
+
+def __get_plist_path(app_path):
+    return os.path.join(app_path, "Contents", "Info.plist")

flet_cli-0.81.0.dev7148/src/flet_cli/__pyinstaller/rthooks/pyi_rth_localhost_fletd.py

@@ -0,0 +1,9 @@
+import logging
+import os
+
+logger = logging.getLogger("flet")
+
+
+logger.info("Running PyInstaller runtime hook for Flet...")
+
+os.environ["FLET_SERVER_IP"] = "127.0.0.1"

flet_cli-0.81.0.dev7148/src/flet_cli/__pyinstaller/utils.py

@@ -0,0 +1,25 @@
+import os
+import tempfile
+import uuid
+from pathlib import Path
+
+from flet.utils import copy_tree
+from flet_desktop import get_package_bin_dir
+
+
+def get_flet_bin_path():
+    bin_path = get_package_bin_dir()
+    if not os.path.exists(bin_path):
+        return None
+    return bin_path
+
+
+def copy_flet_bin():
+    bin_path = get_flet_bin_path()
+    if not bin_path:
+        return None
+
+    # create temp bin dir
+    temp_bin_dir = Path(tempfile.gettempdir()).joinpath(str(uuid.uuid4()))
+    copy_tree(bin_path, str(temp_bin_dir))
+    return str(temp_bin_dir)

flet_cli-0.81.0.dev7148/src/flet_cli/__pyinstaller/win_utils.py

@@ -0,0 +1,109 @@
+import os
+import tempfile
+import uuid
+from pathlib import Path
+
+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
+
+
+def update_flet_view_icon(exe_path, icon_path):
+    print("Updating Flet View icon", exe_path, icon_path)
+
+    RT_ICON = 3
+    RT_GROUP_ICON = 14
+
+    normalized_icon_path = normalize_icon_type(
+        icon_path, ("exe", "ico"), "ico", os.getcwd()
+    )
+    icon = IconFile(normalized_icon_path)
+    print("Copying icons from", normalized_icon_path)
+
+    hdst = win32api.BeginUpdateResource(exe_path, 0)
+
+    iconid = 1
+    # Each step in the following enumerate() will instantiate an IconFile object, as a result of deferred execution
+    # of the map() above.
+    i = 101
+    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))
+    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))
+        iconid = iconid + 1
+
+    win32api.EndUpdateResource(hdst, 0)
+
+
+def update_flet_view_version_info(
+    exe_path,
+    product_name,
+    file_description,
+    product_version,
+    file_version,
+    company_name,
+    copyright,
+):
+    print("Updating Flet View version info", exe_path)
+
+    # load versioninfo from exe
+    if versioninfo.read_version_info_from_executable:
+        vs = versioninfo.read_version_info_from_executable(exe_path)
+    else:
+        vs = versioninfo.decode(exe_path)
+
+    # update file version
+    if file_version:
+        pv = version.parse(file_version)
+        filevers = (pv.major, pv.minor, pv.micro, 0)
+        vs.ffi.fileVersionMS = (filevers[0] << 16) | (filevers[1] & 0xFFFF)
+        vs.ffi.fileVersionLS = (filevers[2] << 16) | (filevers[3] & 0xFFFF)
+
+    # update string props
+    for k in vs.kids[0].kids[0].kids:
+        if k.name == "ProductName":
+            k.val = product_name if product_name else ""
+        elif k.name == "FileDescription":
+            k.val = file_description if file_description else ""
+        if k.name == "ProductVersion":
+            k.val = product_version if product_version else ""
+        if k.name == "FileVersion" and file_version:
+            k.val = file_version if file_version else ""
+        if k.name == "CompanyName":
+            k.val = company_name if company_name else ""
+        if k.name == "LegalCopyright":
+            k.val = copyright if copyright else ""
+
+    version_info_path = str(Path(tempfile.gettempdir()).joinpath(str(uuid.uuid4())))
+    with open(version_info_path, "w", encoding="utf-8") as f:
+        f.write(str(vs))
+
+    # Remember overlay
+    pe = pefile.PE(exe_path, fast_load=True)
+    overlay_before = pe.get_overlay()
+    pe.close()
+
+    hdst = win32api.BeginUpdateResource(exe_path, 0)
+    win32api.UpdateResource(
+        hdst, pefile.RESOURCE_TYPE["RT_VERSION"], 1, vs.toRaw(), 1033
+    )
+    win32api.EndUpdateResource(hdst, 0)
+
+    if overlay_before:
+        # Check if the overlay is still present
+        pe = pefile.PE(exe_path, fast_load=True)
+        overlay_after = pe.get_overlay()
+        pe.close()
+
+        # If the update removed the overlay data, re-append it
+        if not overlay_after:
+            with open(exe_path, "ab", encoding="utf-8") as exef:
+                exef.write(overlay_before)
+
+    return version_info_path

flet_cli-0.81.0.dev7148/src/flet_cli/cli.py

@@ -0,0 +1,119 @@
+import argparse
+import sys
+
+import flet.version
+import flet_cli.commands.build
+import flet_cli.commands.create
+import flet_cli.commands.debug
+import flet_cli.commands.devices
+import flet_cli.commands.doctor
+import flet_cli.commands.emulators
+import flet_cli.commands.pack
+import flet_cli.commands.publish
+import flet_cli.commands.run
+import flet_cli.commands.serve
+
+
+# Source https://stackoverflow.com/a/26379693
+def set_default_subparser(
+    parser: argparse.ArgumentParser, name: str, args: list = None, index: int = 0
+):
+    """
+    Set a default subparser when no subparser is provided.
+    This should be called after setting up the argument parser but before
+    `parse_args()`.
+
+    Args:
+        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.
+    """
+
+    # exit if help or version flags are present
+    if any(flag in sys.argv[1:] for flag in {"-h", "--help", "-V", "--version"}):
+        return
+
+    # all subparser actions
+    subparser_actions = [
+        action
+        for action in parser._subparsers._actions
+        if isinstance(action, argparse._SubParsersAction)
+    ]
+
+    # all subparser names
+    subparser_names = [
+        sp_name for action in subparser_actions for sp_name in action._name_parser_map
+    ]
+
+    # if an existing subparser is provided, skip setting a default
+    if any(arg in subparser_names for arg in sys.argv[1:]):
+        return
+
+    # 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)
+
+
+def get_parser() -> argparse.ArgumentParser:
+    """Construct and return the CLI argument parser."""
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+
+    # add version flag
+    parser.add_argument(
+        "--version",
+        "-V",
+        action="version",
+        version=(
+            f"Flet: {flet.version.flet_version}\n"
+            f"Flutter: {flet.version.flutter_version}\n"
+            f"Pyodide: {flet.version.pyodide_version}"
+        ),
+    )
+
+    sp = parser.add_subparsers(dest="command")
+
+    # register subcommands
+    flet_cli.commands.create.Command.register_to(sp, "create")
+    flet_cli.commands.run.Command.register_to(sp, "run")
+    flet_cli.commands.build.Command.register_to(sp, "build")
+    flet_cli.commands.debug.Command.register_to(sp, "debug")
+    flet_cli.commands.pack.Command.register_to(sp, "pack")
+    flet_cli.commands.publish.Command.register_to(sp, "publish")
+    flet_cli.commands.serve.Command.register_to(sp, "serve")
+    flet_cli.commands.emulators.Command.register_to(sp, "emulators")
+    flet_cli.commands.devices.Command.register_to(sp, "devices")
+    flet_cli.commands.doctor.Command.register_to(sp, "doctor")
+
+    # set "run" as the default subparser
+    set_default_subparser(parser, name="run", index=1)
+
+    return parser
+
+
+def main():
+    parser = get_parser()
+
+    # print usage/help if called without arguments
+    if len(sys.argv) == 1:
+        parser.print_help(sys.stdout)
+        sys.exit(1)
+
+    # parse arguments
+    args = parser.parse_args()
+
+    # execute command
+    args.handler(args)
+
+
+if __name__ == "__main__":
+    main()

flet_cli-0.81.0.dev7148/src/flet_cli/commands/base.py

@@ -0,0 +1,91 @@
+import argparse
+from typing import Any, Optional
+
+from flet_cli.commands.options import Option, verbose_option
+
+
+class CustomArgumentDefaultsHelpFormatter(argparse.HelpFormatter):
+    """
+    An argparse help formatter that appends default values to help text
+    selectively.
+
+    Defaults are added only when they are informative and not already
+    present in the help string. Noisy or redundant defaults (such as
+    None, empty lists, booleans for flag arguments, or suppressed values)
+    are omitted.
+    """
+
+    def _get_help_string(self, action: argparse.Action) -> str:
+        help_text = action.help or ""
+        default = action.default
+
+        # skip appending a default
+        if (
+            default is None
+            or default == []
+            or isinstance(default, bool)  # store_true / store_false flags
+            or default is argparse.SUPPRESS
+            or any(token in help_text for token in ("%(default)", "(default:"))
+        ):
+            return help_text
+
+        # only add defaults for optionals or for nargs implying optional values
+        defaulting_nargs = (argparse.OPTIONAL, argparse.ZERO_OR_MORE)
+        if action.option_strings or action.nargs in defaulting_nargs:
+            help_text += " (default: %(default)s)"
+
+        return help_text
+
+
+class BaseCommand:
+    """A CLI subcommand"""
+
+    # The subcommand's name
+    name: Optional[str] = None
+    # The subcommand's help string, if not given, __doc__ will be used.
+    description: Optional[str] = None
+    # A list of pre-defined options which will be loaded on initializing
+    # Rewrite this if you don't want the default ones
+    arguments: list[Option] = [verbose_option]
+
+    def __init__(self, parser: argparse.ArgumentParser) -> None:
+        for arg in self.arguments:
+            arg.add_to_parser(parser)
+        self.add_arguments(parser)
+
+    @classmethod
+    def register_to(
+        cls,
+        subparsers: argparse._SubParsersAction,
+        name: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        """Register a subcommand to the subparsers,
+        with an optional name of the subcommand.
+        """
+        help_text = cls.description or cls.__doc__
+        name = name or cls.name or ""
+
+        # Remove the existing subparser as it will raise an error on Python 3.11+
+        subparsers._name_parser_map.pop(name, None)
+        subactions = subparsers._get_subactions()
+        subactions[:] = [action for action in subactions if action.dest != name]
+        parser = subparsers.add_parser(
+            name,
+            description=help_text,
+            help=help_text,
+            formatter_class=CustomArgumentDefaultsHelpFormatter,
+            **kwargs,
+        )
+        command = cls(parser)
+        parser.set_defaults(handler=command.handle)
+
+    def add_arguments(self, parser: argparse.ArgumentParser) -> None:
+        """Manipulate the argument parser to add more arguments"""
+        pass
+
+    def handle(self, options: argparse.Namespace) -> None:
+        """The command handler function.
+        :param options: the parsed Namespace object
+        """
+        raise NotImplementedError