flyte 0.0.1b0__py3-none-any.whl → 2.0.0b46__py3-none-any.whl

flyte/cli/_serve.py

@@ -0,0 +1,338 @@
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass, field, fields
+from pathlib import Path
+from types import ModuleType
+from typing import Any, Dict, List, cast
+
+import rich_click as click
+from typing_extensions import get_args
+
+from flyte._code_bundle._utils import CopyFiles
+from flyte.app import AppEnvironment
+
+from . import _common as common
+from ._common import CLIConfig
+
+
+@dataclass
+class ServeArguments:
+    project: str = field(
+        default=cast(str, common.PROJECT_OPTION.default), metadata={"click.option": common.PROJECT_OPTION}
+    )
+    domain: str = field(
+        default=cast(str, common.DOMAIN_OPTION.default), metadata={"click.option": common.DOMAIN_OPTION}
+    )
+    copy_style: CopyFiles = field(
+        default="loaded_modules",
+        metadata={
+            "click.option": click.Option(
+                ["--copy-style"],
+                type=click.Choice(get_args(CopyFiles)),
+                default="loaded_modules",
+                help="Copy style to use when serving the app",
+            )
+        },
+    )
+    root_dir: str | None = field(
+        default=None,
+        metadata={
+            "click.option": click.Option(
+                ["--root-dir"],
+                type=str,
+                help="Override the root source directory, helpful when working with monorepos.",
+            )
+        },
+    )
+    service_account: str | None = field(
+        default=None,
+        metadata={
+            "click.option": click.Option(
+                ["--service-account"],
+                type=str,
+                help="Kubernetes service account. If not provided, the configured default will be used",
+            )
+        },
+    )
+    name: str | None = field(
+        default=None,
+        metadata={
+            "click.option": click.Option(
+                ["--name"],
+                type=str,
+                help="Name of the app deployment. If not provided, the app environment name will be used.",
+            )
+        },
+    )
+    follow: bool = field(
+        default=False,
+        metadata={
+            "click.option": click.Option(
+                ["--follow", "-f"],
+                is_flag=True,
+                default=False,
+                help="Wait and watch logs for the app. If not provided, the CLI will exit after "
+                "successfully deploying the app with a link to the UI.",
+            )
+        },
+    )
+    image: List[str] = field(
+        default_factory=list,
+        metadata={
+            "click.option": click.Option(
+                ["--image"],
+                type=str,
+                multiple=True,
+                help="Image to be used in the serve. Format: imagename=imageuri. Can be specified multiple times.",
+            )
+        },
+    )
+    no_sync_local_sys_paths: bool = field(
+        default=False,
+        metadata={
+            "click.option": click.Option(
+                ["--no-sync-local-sys-paths"],
+                is_flag=True,
+                flag_value=True,
+                default=False,
+                help="Disable synchronization of local sys.path entries under the root directory "
+                "to the remote container.",
+            )
+        },
+    )
+    env_var: List[str] = field(
+        default_factory=list,
+        metadata={
+            "click.option": click.Option(
+                ["--env-var", "-e"],
+                type=str,
+                multiple=True,
+                help="Environment variable to set in the app. Format: KEY=VALUE. Can be specified multiple times. "
+                "Example: --env-var LOG_LEVEL=DEBUG --env-var DATABASE_URL=postgresql://...",
+            )
+        },
+    )
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ServeArguments:
+        modified = {k: v for k, v in d.items() if k in {f.name for f in fields(cls)}}
+        return cls(**modified)
+
+    @classmethod
+    def options(cls) -> List[click.Option]:
+        """
+        Return the set of base parameters added to serve subcommand.
+        """
+        return [common.get_option_from_metadata(f.metadata) for f in fields(cls) if f.metadata]
+
+
+class ServeAppCommand(click.RichCommand):
+    def __init__(self, obj_name: str, obj: AppEnvironment, serve_args: ServeArguments, *args, **kwargs):
+        self.obj_name = obj_name
+        self.obj = cast(AppEnvironment, obj)
+        self.serve_args = serve_args
+        kwargs.pop("name", None)
+        super().__init__(obj_name, *args, **kwargs)
+
+    def invoke(self, ctx: click.Context):
+        obj: CLIConfig = common.initialize_config(
+            ctx,
+            self.serve_args.project,
+            self.serve_args.domain,
+            self.serve_args.root_dir,
+            tuple(self.serve_args.image) or None,
+            not self.serve_args.no_sync_local_sys_paths,
+        )
+
+        async def _serve():
+            import flyte
+
+            console = common.get_console()
+
+            # Parse env vars from CLI (format: KEY=VALUE)
+            env_vars = {}
+            for env_var in self.serve_args.env_var:
+                if "=" in env_var:
+                    key, value = env_var.split("=", 1)
+                    env_vars[key] = value
+                else:
+                    console.print(
+                        f"[yellow]Warning: Ignoring invalid env var format: {env_var} (expected KEY=VALUE)[/yellow]"
+                    )
+
+            # Use with_servecontext to configure the serve operation
+            app = await flyte.with_servecontext(
+                copy_style=self.serve_args.copy_style,
+                project=self.serve_args.project if self.serve_args.project else None,
+                domain=self.serve_args.domain if self.serve_args.domain else None,
+                env_vars=env_vars if env_vars else None,
+            ).serve.aio(self.obj)
+
+            console.print(
+                common.get_panel(
+                    "Serve",
+                    f"[green bold]App '{app.name}' is now being served[/green bold]\n"
+                    f"➡️  [blue bold][link={app.url}]{app.url}[/link][/blue bold]",
+                    obj.output_format,
+                )
+            )
+
+            if self.serve_args.follow:
+                # TODO: Implement log streaming for apps
+                # This should retrieve and display logs from the running app
+                # Similar to how r.show_logs.aio() works for tasks in _run.py
+                console.print(
+                    "[yellow]Note: Log streaming for apps is not yet implemented. "
+                    "Please check the app logs via the UI.[/yellow]"
+                )
+
+        asyncio.run(_serve())
+
+
+class AppPerFileGroup(common.ObjectsPerFileGroup):
+    """
+    Group that creates a command for each AppEnvironment in the current directory that is not __init__.py.
+    """
+
+    def __init__(self, filename: Path, serve_args: ServeArguments, *args, **kwargs):
+        if filename.is_absolute():
+            filename = filename.relative_to(Path.cwd())
+        super().__init__(*(filename, *args), **kwargs)
+        self.serve_args = serve_args
+
+    def _filter_objects(self, module: ModuleType) -> Dict[str, Any]:
+        return {k: v for k, v in module.__dict__.items() if isinstance(v, AppEnvironment)}
+
+    def list_commands(self, ctx):
+        common.initialize_config(
+            ctx,
+            self.serve_args.project,
+            self.serve_args.domain,
+            self.serve_args.root_dir,
+            sync_local_sys_paths=not self.serve_args.no_sync_local_sys_paths,
+        )
+        return super().list_commands(ctx)
+
+    def get_command(self, ctx, obj_name):
+        common.initialize_config(
+            ctx,
+            self.serve_args.project,
+            self.serve_args.domain,
+            self.serve_args.root_dir,
+            sync_local_sys_paths=not self.serve_args.no_sync_local_sys_paths,
+        )
+        return super().get_command(ctx, obj_name)
+
+    def _get_command_for_obj(self, ctx: click.Context, obj_name: str, obj: Any) -> click.Command:
+        obj = cast(AppEnvironment, obj)
+        return ServeAppCommand(
+            obj_name=obj_name,
+            obj=obj,
+            help=f"Serve the '{obj_name}' app environment",
+            serve_args=self.serve_args,
+        )
+
+
+class AppFiles(common.FileGroup):
+    """
+    Group that creates a command for each file in the current directory that is not __init__.py.
+    """
+
+    common_options_enabled = False
+
+    def __init__(
+        self,
+        *args,
+        directory: Path | None = None,
+        **kwargs,
+    ):
+        if "params" not in kwargs:
+            kwargs["params"] = []
+        kwargs["params"].extend(ServeArguments.options())
+        super().__init__(*args, directory=directory, **kwargs)
+
+    def get_command(self, ctx, cmd_name):
+        serve_args = ServeArguments.from_dict(ctx.params)
+
+        fp = Path(cmd_name)
+        if not fp.exists():
+            raise click.BadParameter(f"File {cmd_name} does not exist")
+        if fp.is_dir():
+            return AppFiles(
+                directory=fp,
+                help=f"Serve `*.py` file inside the {fp} directory",
+            )
+        return AppPerFileGroup(
+            filename=fp,
+            serve_args=serve_args,
+            name=cmd_name,
+            help=f"Serve AppEnvironment instances in {cmd_name}",
+        )
+
+
+serve = AppFiles(
+    name="serve",
+    help="""
+Serve an app from a Python file using flyte.serve().
+
+This command allows you to serve apps defined with `flyte.app.AppEnvironment`
+in your Python files. The serve command will deploy the app to the Flyte backend
+and start it, making it accessible via a URL.
+
+Example usage:
+
+```bash
+flyte serve examples/apps/basic_app.py app_env
+```
+
+Arguments to the serve command are provided right after the `serve` command and before the file name.
+
+To follow the logs of the served app, use the `--follow` flag:
+
+```bash
+flyte serve --follow examples/apps/basic_app.py app_env
+```
+
+Note: Log streaming is not yet fully implemented and will be added in a future release.
+
+You can provide image mappings with `--image` flag. This allows you to specify
+the image URI for the app environment during CLI execution without changing
+the code. Any images defined with `Image.from_ref_name("name")` will resolve to the
+corresponding URIs you specify here.
+
+```bash
+flyte serve --image my_image=ghcr.io/myorg/my-image:v1.0 examples/apps/basic_app.py app_env
+```
+
+If the image name is not provided, it is regarded as a default image and will
+be used when no image is specified in AppEnvironment:
+
+```bash
+flyte serve --image ghcr.io/myorg/default-image:latest examples/apps/basic_app.py app_env
+```
+
+You can specify multiple image arguments:
+
+```bash
+flyte serve --image ghcr.io/org/default:latest --image gpu=ghcr.io/org/gpu:v2.0 examples/apps/basic_app.py app_env
+```
+
+You can specify the `--config` flag to point to a specific Flyte cluster:
+
+```bash
+flyte serve --config my-config.yaml examples/apps/basic_app.py app_env
+```
+
+You can override the default configured project and domain:
+
+```bash
+flyte serve --project my-project --domain development examples/apps/basic_app.py app_env
+```
+
+Other arguments to the serve command are listed below.
+
+Note: This pattern is primarily useful for serving apps defined in tasks.
+Serving deployed apps is not currently supported through this CLI command.
+""",
+)

flyte/cli/_update.py

@@ -0,0 +1,86 @@
+import rich_click as click
+
+import flyte.remote as remote
+
+from . import _common as common
+
+
+@click.group(name="update")
+def update():
+    """
+    Update various flyte entities.
+    """
+
+
+@update.command("trigger", cls=common.CommandBase)
+@click.argument("name", type=str)
+@click.argument("task_name", type=str)
+@click.option("--activate/--deactivate", required=True, help="Activate or deactivate the trigger.")
+@click.pass_obj
+def trigger(cfg: common.CLIConfig, name: str, task_name: str, activate: bool, project: str | None, domain: str | None):
+    """
+    Update a trigger.
+
+    \b
+    Example usage:
+
+    ```bash
+    flyte update trigger <trigger_name> <task_name> --activate | --deactivate
+    [--project <project_name> --domain <domain_name>]
+    ```
+    """
+    cfg.init(project, domain)
+    console = common.get_console()
+    to_state = "active" if activate else "deactivate"
+    with console.status(f"Updating trigger {name} for task {task_name} to {to_state}..."):
+        remote.Trigger.update(name, task_name, activate)
+    console.print(f"Trigger updated and is set to [fuchsia]{to_state}[/fuchsia]")
+
+
+@update.command("app", cls=common.CommandBase)
+@click.argument("name", type=str)
+@click.option("--activate/--deactivate", "is_activate", default=None, help="Activate or deactivate app.")
+@click.option("--wait", is_flag=True, default=False, help="Wait for the app to reach the desired state.")
+@click.pass_obj
+def app(
+    cfg: common.CLIConfig, name: str, is_activate: bool | None, wait: bool, project: str | None, domain: str | None
+):
+    """
+    Update an app by starting or stopping it.
+
+    \b
+    Example usage:
+
+    ```bash
+    flyte update app <app_name> --activate | --deactivate [--wait] [--project <project_name>] [--domain <domain_name>]
+    ```
+    """
+
+    if is_activate is None:
+        raise click.UsageError("Missing option '--activate' / '--deactivate'.")
+
+    cfg.init(project, domain)
+    console = common.get_console()
+
+    app_obj = remote.App.get(name=name)
+    if is_activate:
+        if app_obj.is_active():
+            console.print(f"App [yellow]{name}[/yellow] is already active.")
+            return
+        state = "activate"
+        color = "green"
+        with console.status(f"Activating app {name}..."):
+            app_obj.activate(wait=wait)
+    else:
+        state = "deactivate"
+        color = "red"
+        if app_obj.is_deactivated():
+            console.print(f"App [red]{name}[/red] is already deactivated.")
+            return
+        with console.status(f"Deactivating app {name}..."):
+            app_obj.deactivate(wait=wait)
+
+    if wait:
+        console.print(f"App [{color}]{name}[/{color}] {state}d successfully")
+    else:
+        console.print(f"App [{color}]{name}[/{color}] {state} initiated")

flyte/cli/_user.py

@@ -0,0 +1,20 @@
+import os
+
+import rich_click as click
+
+import flyte.remote as remote
+
+from . import _common as common
+
+
+@click.command()
+@click.pass_obj
+def whoami(
+    cfg: common.CLIConfig,
+):
+    """Display the current user information."""
+    cfg.init()
+    console = common.get_console()
+    user_info = remote.User.get()
+    console.print(user_info.to_json())
+    os._exit(0)

flyte/cli/main.py

@@ -0,0 +1,246 @@
+import rich_click as click
+from typing_extensions import get_args
+
+import flyte
+from flyte._logging import LogFormat, initialize_logger, logger
+
+from . import _common as common
+from ._abort import abort
+from ._build import build
+from ._common import CLIConfig
+from ._create import create
+from ._delete import delete
+from ._deploy import deploy
+from ._gen import gen
+from ._get import get
+from ._plugins import discover_and_register_plugins
+from ._prefetch import prefetch
+from ._run import run
+from ._serve import serve
+from ._update import update
+from ._user import whoami
+
+help_config = click.RichHelpConfiguration(
+    use_markdown=True,
+    use_markdown_emoji=True,
+    command_groups={
+        "flyte": [
+            {
+                "name": "Run and stop tasks",
+                "commands": ["run", "abort"],
+            },
+            {
+                "name": "Serve Apps",
+                "commands": ["serve"],
+            },
+            {
+                "name": "Management of various objects.",
+                "commands": ["create", "get", "delete", "update"],
+            },
+            {
+                "name": "Build and deploy environments, tasks and images.",
+                "commands": ["build", "deploy"],
+            },
+            {
+                "name": "Prefetch artifacts from remote registries.",
+                "commands": ["prefetch"],
+            },
+            {
+                "name": "Documentation generation",
+                "commands": ["gen"],
+            },
+            {
+                "name": "User information",
+                "commands": ["whoami"],
+            },
+        ]
+    },
+)
+
+
+def _verbosity_to_loglevel(verbosity: int) -> int | None:
+    """
+    Converts a verbosity level from the CLI to a logging level.
+
+    :param verbosity: verbosity level from the CLI
+    :return: logging level
+    """
+    import logging
+
+    match verbosity:
+        case 0:
+            return None
+        case 1:
+            return logging.WARNING
+        case 2:
+            return logging.INFO
+        case _:
+            return logging.DEBUG
+
+
+@click.group(cls=click.RichGroup)
+@click.version_option(
+    message=f"Flyte SDK version: {flyte.version()}",
+)
+@click.option(
+    "--endpoint",
+    type=str,
+    required=False,
+    help="The endpoint to connect to. This will override any configuration file and simply use `pkce` to connect.",
+)
+@click.option(
+    "--insecure",
+    is_flag=True,
+    required=False,
+    help="Use an insecure connection to the endpoint. If not specified, the CLI will use TLS.",
+    type=bool,
+    default=None,
+    show_default=True,
+)
+@click.option(
+    "--auth-type",
+    type=click.Choice(common.ALL_AUTH_OPTIONS, case_sensitive=False),
+    default=None,
+    help="Authentication type to use for the Flyte backend. Defaults to 'pkce'.",
+    show_default=True,
+    required=False,
+)
+@click.option(
+    "-v",
+    "--verbose",
+    required=False,
+    help="Show verbose messages and exception traces. Repeating multiple times increases the verbosity (e.g., -vvv).",
+    count=True,
+    default=0,
+    type=int,
+)
+@click.option(
+    "--org",
+    type=str,
+    required=False,
+    help="The organization to which the command applies.",
+)
+@click.option(
+    "-c",
+    "--config",
+    "config_file",
+    required=False,
+    type=click.Path(exists=True),
+    help="Path to the configuration file to use. If not specified, the default configuration file is used.",
+)
+@click.option(
+    "--output-format",
+    "-of",
+    type=click.Choice(get_args(common.OutputFormat), case_sensitive=False),
+    default="table",
+    help="Output format for commands that support it. Defaults to 'table'.",
+    show_default=True,
+    required=False,
+)
+@click.option(
+    "--log-format",
+    type=click.Choice(get_args(LogFormat), case_sensitive=False),
+    envvar="LOG_FORMAT",
+    default="console",
+    help="Formatting for logs, defaults to 'console' which is meant to be human readable."
+    " 'json' is meant for machine parsing.",
+    show_default=True,
+    required=False,
+)
+@click.option(
+    "--reset-root-logger",
+    is_flag=True,
+    required=False,
+    help="If set, the root logger will be reset to use Flyte logging style",
+    type=bool,
+    default=False,
+    show_default=True,
+)
+@click.rich_config(help_config=help_config)
+@click.pass_context
+def main(
+    ctx: click.Context,
+    endpoint: str | None,
+    insecure: bool,
+    verbose: int,
+    log_format: LogFormat,
+    reset_root_logger: bool,
+    org: str | None,
+    config_file: str | None,
+    auth_type: str | None = None,
+    output_format: common.OutputFormat = "table",
+):
+    """
+    The Flyte CLI is the command line interface for working with the Flyte SDK and backend.
+
+    It follows a simple verb/noun structure,
+    where the top-level commands are verbs that describe the action to be taken,
+    and the subcommands are nouns that describe the object of the action.
+
+    The root command can be used to configure the CLI for persistent settings,
+    such as the endpoint, organization, and verbosity level.
+
+    Set endpoint and organization:
+
+    ```bash
+    $ flyte --endpoint <endpoint> --org <org> get project <project_name>
+    ```
+
+    Increase verbosity level (This is useful for debugging,
+    this will show more logs and exception traces):
+
+    ```bash
+    $ flyte -vvv get logs <run-name>
+    ```
+
+    Override the default config file:
+
+    ```bash
+    $ flyte --config /path/to/config.yaml run ...
+    ```
+
+    * [Documentation](https://www.union.ai/docs/flyte/user-guide/)
+    * [GitHub](https://github.com/flyteorg/flyte): Please leave a star if you like Flyte!
+    * [Slack](https://slack.flyte.org): Join the community and ask questions.
+    * [Issues](https://github.com/flyteorg/flyte/issues)
+
+    """
+    import flyte.config as config
+
+    log_level = _verbosity_to_loglevel(verbose)
+    if log_level is not None or log_format != "console" or reset_root_logger:
+        initialize_logger(log_level=log_level, log_format=log_format, reset_root_logger=reset_root_logger)
+
+    cfg = config.auto(config_file=config_file)
+    if cfg.source:
+        logger.debug(f"Using config file discovered at location `{cfg.source.absolute()}`")
+
+    ctx.obj = CLIConfig(
+        log_level=log_level,
+        log_format=log_format,
+        reset_root_logger=reset_root_logger,
+        endpoint=endpoint,
+        insecure=insecure,
+        org=org,
+        config=cfg,
+        ctx=ctx,
+        auth_type=auth_type,
+        output_format=output_format,
+    )
+
+
+main.add_command(run)
+main.add_command(deploy)
+main.add_command(get)  # type: ignore
+main.add_command(create)  # type: ignore
+main.add_command(abort)  # type: ignore
+main.add_command(gen)  # type: ignore
+main.add_command(delete)  # type: ignore
+main.add_command(build)
+main.add_command(whoami)  # type: ignore
+main.add_command(update)  # type: ignore
+main.add_command(serve)  # type: ignore
+main.add_command(prefetch)  # type: ignore
+
+# Discover and register CLI plugins from installed packages
+discover_and_register_plugins(main)

flyte/config/__init__.py

@@ -0,0 +1,3 @@
+from flyte.config._config import Config, auto, get_config_file, set_if_exists
+
+__all__ = ["Config", "auto", "get_config_file", "set_if_exists"]