flyte 2.0.0b22__py3-none-any.whl → 2.0.0b30__py3-none-any.whl

flyte/cli/_delete.py

@@ -20,4 +20,26 @@ def secret(cfg: common.CLIConfig, name: str, project: str | None = None, domain:
     from flyte.remote import Secret
 
     cfg.init(project, domain)
-    Secret.delete(name=name)
+    console = common.get_console()
+    with console.status(f"Deleting secret {name}..."):
+        Secret.delete(name=name)
+    console.print(f"Successfully deleted secret {name}.")
+
+
+@delete.command(cls=common.CommandBase)
+@click.argument("name", type=str, required=True)
+@click.argument("task-name", type=str, required=True)
+@click.pass_obj
+def trigger(cfg: common.CLIConfig, name: str, task_name: str, project: str | None = None, domain: str | None = None):
+    """
+    Delete a trigger. The name of the trigger is required.
+    """
+    from flyte.remote import Trigger
+
+    cfg.init(project, domain)
+    console = common.get_console()
+
+    with console.status(f"Deleting trigger {name}..."):
+        Trigger.delete(name=name, task_name=task_name)
+
+    console.log(f"[green]Successfully deleted trigger {name}[/green]")

flyte/cli/_deploy.py

@@ -7,8 +7,8 @@ from typing import Any, Dict, List, cast, get_args
 import rich_click as click
 
 import flyte
+from flyte._code_bundle._utils import CopyFiles
 
-from .._code_bundle._utils import CopyFiles
 from . import _common as common
 from ._common import CLIConfig
 
@@ -83,6 +83,19 @@ class DeployArguments:
             )
         },
     )
+    no_sync_local_sys_paths: bool = field(
+        default=True,
+        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.",
+            )
+        },
+    )
 
     @classmethod
     def from_dict(cls, d: Dict[str, Any]) -> "DeployArguments":
@@ -104,12 +117,15 @@ class DeployEnvCommand(click.RichCommand):
         super().__init__(*args, **kwargs)
 
     def invoke(self, ctx: click.Context):
-        from rich.console import Console
-
-        console = Console()
+        console = common.get_console()
         console.print(f"Deploying root - environment: {self.env_name}")
         obj: CLIConfig = ctx.obj
-        obj.init(self.deploy_args.project, self.deploy_args.domain, root_dir=self.deploy_args.root_dir)
+        obj.init(
+            self.deploy_args.project,
+            self.deploy_args.domain,
+            root_dir=self.deploy_args.root_dir,
+            sync_local_sys_paths=not self.deploy_args.no_sync_local_sys_paths,
+        )
         with console.status("Deploying...", spinner="dots"):
             deployment = flyte.deploy(
                 self.env,
@@ -119,7 +135,7 @@ class DeployEnvCommand(click.RichCommand):
             )
 
         console.print(common.format("Environments", deployment[0].env_repr(), obj.output_format))
-        console.print(common.format("Tasks", deployment[0].task_repr(), obj.output_format))
+        console.print(common.format("Tasks", deployment[0].table_repr(), obj.output_format))
 
 
 class DeployEnvRecursiveCommand(click.Command):
@@ -135,13 +151,11 @@ class DeployEnvRecursiveCommand(click.Command):
         super().__init__(*args, **kwargs)
 
     def invoke(self, ctx: click.Context):
-        from rich.console import Console
-
         from flyte._environment import list_loaded_environments
         from flyte._utils import load_python_modules
 
-        console = Console()
         obj: CLIConfig = ctx.obj
+        console = common.get_console()
 
         # Load all python modules
         loaded_modules, failed_paths = load_python_modules(self.path, self.deploy_args.recursive)
@@ -165,7 +179,11 @@ class DeployEnvRecursiveCommand(click.Command):
                 f"Failed to load {len(failed_paths)} files. Use --ignore-load-errors to ignore these errors."
             )
         # Now start connection and deploy all environments
-        obj.init(self.deploy_args.project, self.deploy_args.domain)
+        obj.init(
+            self.deploy_args.project,
+            self.deploy_args.domain,
+            sync_local_sys_paths=not self.deploy_args.no_sync_local_sys_paths,
+        )
         with console.status("Deploying...", spinner="dots"):
             deployments = flyte.deploy(
                 *all_envs,
@@ -177,7 +195,7 @@ class DeployEnvRecursiveCommand(click.Command):
         console.print(
             common.format("Environments", [env for d in deployments for env in d.env_repr()], obj.output_format)
         )
-        console.print(common.format("Tasks", [task for d in deployments for task in d.task_repr()], obj.output_format))
+        console.print(common.format("Tasks", [task for d in deployments for task in d.table_repr()], obj.output_format))
 
 
 class EnvPerFileGroup(common.ObjectsPerFileGroup):
@@ -193,6 +211,26 @@ class EnvPerFileGroup(common.ObjectsPerFileGroup):
     def _filter_objects(self, module: ModuleType) -> Dict[str, Any]:
         return {k: v for k, v in module.__dict__.items() if isinstance(v, flyte.Environment)}
 
+    def list_commands(self, ctx):
+        common.initialize_config(
+            ctx,
+            self.deploy_args.project,
+            self.deploy_args.domain,
+            self.deploy_args.root_dir,
+            sync_local_sys_paths=not self.deploy_args.no_sync_local_sys_paths,
+        )
+        return super().list_commands(ctx)
+
+    def get_command(self, ctx, obj_name):
+        common.initialize_config(
+            ctx,
+            self.deploy_args.project,
+            self.deploy_args.domain,
+            self.deploy_args.root_dir,
+            sync_local_sys_paths=not self.deploy_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(flyte.Environment, obj)
         return DeployEnvCommand(

flyte/cli/_get.py

@@ -1,10 +1,11 @@
 import asyncio
-from typing import Tuple, Union
+from typing import Tuple, Union, get_args
 
 import rich_click as click
-from rich.console import Console
 from rich.pretty import pretty_repr
 
+import flyte.remote as remote
+
 from . import _common as common
 
 
@@ -38,20 +39,24 @@ def project(cfg: common.CLIConfig, name: str | None = None):
     """
     Get a list of all projects, or details of a specific project by name.
     """
-    from flyte.remote import Project
-
     cfg.init()
 
-    console = Console()
+    console = common.get_console()
     if name:
-        console.print(pretty_repr(Project.get(name)))
+        console.print(pretty_repr(remote.Project.get(name)))
     else:
-        console.print(common.format("Projects", Project.listall(), cfg.output_format))
+        console.print(common.format("Projects", remote.Project.listall(), cfg.output_format))
 
 
 @get.command(cls=common.CommandBase)
 @click.argument("name", type=str, required=False)
 @click.option("--limit", type=int, default=100, help="Limit the number of runs to fetch when listing.")
+@click.option(
+    "--in-phase",  # multiple=True, TODO support multiple phases once values in works
+    type=click.Choice(get_args(remote.Phase), case_sensitive=False),
+    help="Filter runs by their status.",
+)
+@click.option("--only-mine", is_flag=True, default=False, help="Show only runs created by the current user (you).")
 @click.pass_obj
 def run(
     cfg: common.CLIConfig,
@@ -59,6 +64,8 @@ def run(
     project: str | None = None,
     domain: str | None = None,
     limit: int = 100,
+    in_phase: str | Tuple[str, ...] | None = None,
+    only_mine: bool = False,
 ):
     """
     Get a list of all runs, or details of a specific run by name.
@@ -67,16 +74,29 @@ def run(
 
     If you want to see the actions for a run, use `get action <run_name>`.
     """
-    from flyte.remote import Run, RunDetails
 
     cfg.init(project=project, domain=domain)
 
-    console = Console()
+    console = common.get_console()
     if name:
-        details = RunDetails.get(name=name)
+        details = remote.RunDetails.get(name=name)
         console.print(common.format(f"Run {name}", [details], "json"))
     else:
-        console.print(common.format("Runs", Run.listall(limit=limit), cfg.output_format))
+        if in_phase and isinstance(in_phase, str):
+            in_phase = (in_phase,)
+
+        subject = None
+        if only_mine:
+            usr = remote.User.get()
+            subject = usr.subject()
+
+        console.print(
+            common.format(
+                "Runs",
+                remote.Run.listall(limit=limit, in_phase=in_phase, created_by_subject=subject),
+                cfg.output_format,
+            )
+        )
 
 
 @get.command(cls=common.CommandBase)
@@ -97,22 +117,22 @@ def task(
 
     Currently, both `name` and `version` are required to get a specific task.
     """
-    from flyte.remote import Task
-
     cfg.init(project=project, domain=domain)
 
-    console = Console()
+    console = common.get_console()
     if name:
         if version:
-            v = Task.get(name=name, version=version)
+            v = remote.Task.get(name=name, version=version)
             if v is None:
                 raise click.BadParameter(f"Task {name} not found.")
             t = v.fetch()
             console.print(common.format(f"Task {name}", [t], "json"))
         else:
-            console.print(common.format("Tasks", Task.listall(by_task_name=name, limit=limit), cfg.output_format))
+            console.print(
+                common.format("Tasks", remote.Task.listall(by_task_name=name, limit=limit), cfg.output_format)
+            )
     else:
-        console.print(common.format("Tasks", Task.listall(limit=limit), cfg.output_format))
+        console.print(common.format("Tasks", remote.Task.listall(limit=limit), cfg.output_format))
 
 
 @get.command(cls=common.CommandBase)
@@ -129,11 +149,9 @@ def action(
     """
     Get all actions for a run or details for a specific action.
     """
-    import flyte.remote as remote
-
     cfg.init(project=project, domain=domain)
 
-    console = Console()
+    console = common.get_console()
     if action_name:
         console.print(
             common.format(
@@ -196,8 +214,6 @@ def logs(
     $ flyte get logs my_run my_action --pretty --lines 50
     ```
     """
-    import flyte.remote as remote
-
     cfg.init(project=project, domain=domain)
 
     async def _run_log_view(_obj):
@@ -230,11 +246,13 @@ def secret(
     """
     Get a list of all secrets, or details of a specific secret by name.
     """
-    import flyte.remote as remote
-
+    if project is None:
+        project = ""
+    if domain is None:
+        domain = ""
     cfg.init(project=project, domain=domain)
 
-    console = Console()
+    console = common.get_console()
     if name:
         console.print(common.format("Secret", [remote.Secret.get(name)], "json"))
     else:
@@ -275,26 +293,23 @@ def io(
     if inputs_only and outputs_only:
         raise click.BadParameter("Cannot use both --inputs-only and --outputs-only")
 
-    import flyte.remote as remote
-    from flyte.remote import ActionDetails, ActionInputs, ActionOutputs
-
     cfg.init(project=project, domain=domain)
-    console = Console()
+    console = common.get_console()
     if action_name:
-        obj = ActionDetails.get(run_name=run_name, name=action_name)
+        obj = remote.ActionDetails.get(run_name=run_name, name=action_name)
     else:
         obj = remote.RunDetails.get(run_name)
 
     async def _get_io(
-        details: Union[remote.RunDetails, ActionDetails],
-    ) -> Tuple[ActionInputs | None, ActionOutputs | None | str]:
+        details: Union[remote.RunDetails, remote.ActionDetails],
+    ) -> Tuple[remote.ActionInputs | None, remote.ActionOutputs | None | str]:
         if inputs_only or outputs_only:
             if inputs_only:
                 return await details.inputs(), None
             elif outputs_only:
                 return None, await details.outputs()
         inputs = await details.inputs()
-        outputs: ActionOutputs | None | str = None
+        outputs: remote.ActionOutputs | None | str = None
         try:
             outputs = await details.outputs()
         except Exception:
@@ -321,5 +336,35 @@ def config(cfg: common.CLIConfig):
 
     The configuration will include the endpoint, organization, and other settings that are used by the CLI.
     """
-    console = Console()
+    console = common.get_console()
     console.print(cfg)
+
+
+@get.command(cls=common.CommandBase)
+@click.argument("task_name", type=str, required=False)
+@click.argument("name", type=str, required=False)
+@click.option("--limit", type=int, default=100, help="Limit the number of triggers to fetch.")
+@click.pass_obj
+def trigger(
+    cfg: common.CLIConfig,
+    task_name: str | None = None,
+    name: str | None = None,
+    limit: int = 100,
+    project: str | None = None,
+    domain: str | None = None,
+):
+    """
+    Get a list of all triggers, or details of a specific trigger by name.
+    """
+    if name and not task_name:
+        raise click.BadParameter("If you provide a trigger name, you must also provide the task name.")
+
+    from flyte.remote import Trigger
+
+    cfg.init(project=project, domain=domain)
+
+    console = common.get_console()
+    if name:
+        console.print(pretty_repr(Trigger.get(name=name, task_name=task_name)))
+    else:
+        console.print(common.format("Triggers", Trigger.listall(task_name=task_name, limit=limit), cfg.output_format))

flyte/cli/_params.py

@@ -15,9 +15,9 @@ from typing import get_args
 import rich_click as click
 import yaml
 from click import Parameter
-from flyteidl.core.interface_pb2 import Variable
-from flyteidl.core.literals_pb2 import Literal
-from flyteidl.core.types_pb2 import BlobType, LiteralType, SimpleType
+from flyteidl2.core.interface_pb2 import Variable
+from flyteidl2.core.literals_pb2 import Literal
+from flyteidl2.core.types_pb2 import BlobType, LiteralType, SimpleType
 from google.protobuf.json_format import MessageToDict
 from mashumaro.codecs.json import JSONEncoder
 
@@ -505,7 +505,7 @@ def to_click_option(
     This handles converting workflow input types to supported click parameters with callbacks to initialize
     the input values to their expected types.
     """
-    from flyteidl.core.types_pb2 import SimpleType
+    from flyteidl2.core.types_pb2 import SimpleType
 
     if input_name != input_name.lower():
         # Click does not support uppercase option names: https://github.com/pallets/click/issues/837
@@ -531,17 +531,19 @@ def to_click_option(
         if literal_var.type.metadata:
             description_extra = f": {MessageToDict(literal_var.type.metadata)}"
 
-    # If a query has been specified, the input is never strictly required at this layer
     required = False if default_val is not None else True
     is_flag: typing.Optional[bool] = None
+    param_decls = [f"--{input_name}"]
     if literal_converter.is_bool():
         required = False
         is_flag = True
+        if default_val is True:
+            param_decls = [f"--{input_name}/--no-{input_name}"]
     if literal_converter.is_optional():
         required = False
 
     return click.Option(
-        param_decls=[f"--{input_name}"],
+        param_decls=param_decls,
         type=literal_converter.click_type,
         is_flag=is_flag,
         default=default_val,

flyte/cli/_plugins.py

@@ -0,0 +1,209 @@
+"""CLI Plugin System for Flyte.
+
+This module provides a plugin system that allows external packages to:
+1. Register new top-level CLI commands (e.g., flyte my-command)
+2. Register new subcommands in existing groups (e.g., flyte get my-object)
+3. Modify behavior of existing commands via hooks
+
+Plugins are discovered via Python entry points.
+
+Entry Point Groups:
+- flyte.plugins.cli.commands: Register new commands
+  - Entry point name "foo" -> flyte foo (top-level command)
+  - Entry point name "get.bar" -> flyte get bar (adds subcommand to get group)
+  - Note: At most one dot is supported. For nested groups, register the entire
+    group hierarchy as a top-level command (without dots).
+
+- flyte.plugins.cli.hooks: Modify existing commands
+  - Entry point name "run" -> modifies flyte run
+  - Entry point name "get.project" -> modifies flyte get project
+  - Note: At most one dot is supported.
+
+Example Plugin Package:
+    # In your-plugin/pyproject.toml
+    [project.entry-points."flyte.plugins.cli.commands"]
+    my-command = "your_plugin.cli:my_command"
+    get.my-object = "your_plugin.cli:get_my_object"
+
+    [project.entry-points."flyte.plugins.cli.hooks"]
+    run = "your_plugin.hooks:modify_run"
+
+    # In your-plugin/your_plugin/cli.py
+    import rich_click as click
+
+    @click.command()
+    def my_command():
+        '''My custom top-level command.'''
+        click.echo("Hello from plugin!")
+
+    @click.command()
+    def get_my_object():
+        '''Get my custom object.'''
+        click.echo("Getting my object...")
+
+    # In your-plugin/your_plugin/hooks.py
+    def modify_run(command):
+        '''Add behavior to flyte run command.'''
+        # Wrap invoke() instead of callback to ensure Click's full machinery runs
+        original_invoke = command.invoke
+
+        def wrapper(ctx):
+            # Do something before
+            click.echo("Plugin: Starting task...")
+
+            result = original_invoke(ctx)
+
+            # Do something after
+            click.echo("Plugin: Task completed!")
+            return result
+
+        command.invoke = wrapper
+        return command
+"""
+
+from importlib.metadata import entry_points
+from typing import Callable
+
+import rich_click as click
+
+from flyte._logging import logger
+
+# Type alias for command hooks
+CommandHook = Callable[[click.Command], click.Command]
+
+
+def discover_and_register_plugins(root_group: click.Group):
+    """
+    Discover all CLI plugins from installed packages and register them.
+
+    This function:
+    1. Discovers command plugins and adds them to the CLI
+    2. Discovers hook plugins and applies them to existing commands
+
+    Args:
+        root_group: The root Click command group (main CLI group)
+    """
+    _load_command_plugins(root_group)
+    _load_hook_plugins(root_group)
+
+
+def _load_command_plugins(root_group: click.Group):
+    """Load and register command plugins."""
+    for ep in entry_points(group="flyte.plugins.cli.commands"):
+        try:
+            command = ep.load()
+            if not isinstance(command, click.Command):
+                logger.warning(f"Plugin {ep.name} did not return a click.Command, got {type(command).__name__}")
+                continue
+
+            # Check if this is a subcommand (contains dot notation)
+            if "." in ep.name:
+                group_name, command_name = ep.name.split(".", 1)
+
+                # Validate: only support one level of nesting (group.command)
+                if "." in command_name:
+                    logger.error(
+                        f"Plugin {ep.name} uses multiple dots, which is not supported. "
+                        f"Use at most one dot (e.g., 'group.command'). "
+                        f"For nested groups, register the entire group hierarchy as a top-level command."
+                    )
+                    continue
+
+                _add_subcommand_to_group(root_group, group_name, command_name, command)
+            else:
+                # Top-level command
+                root_group.add_command(command, name=ep.name)
+                logger.info(f"Registered plugin command: flyte {ep.name}")
+
+        except Exception as e:
+            logger.error(f"Failed to load plugin command {ep.name}: {e}")
+
+
+def _load_hook_plugins(root_group: click.Group):
+    """Load and apply hook plugins to existing commands."""
+    for ep in entry_points(group="flyte.plugins.cli.hooks"):
+        try:
+            hook = ep.load()
+            if not callable(hook):
+                logger.warning(f"Plugin hook {ep.name} is not callable")
+                continue
+
+            # Check if this is a subcommand hook (contains dot notation)
+            if "." in ep.name:
+                group_name, command_name = ep.name.split(".", 1)
+
+                # Validate: only support one level of nesting (group.command)
+                if "." in command_name:
+                    logger.error(
+                        f"Plugin hook {ep.name} uses multiple dots, which is not supported. "
+                        f"Use at most one dot (e.g., 'group.command')."
+                    )
+                    continue
+
+                _apply_hook_to_subcommand(root_group, group_name, command_name, hook)
+            else:
+                # Top-level command hook
+                _apply_hook_to_command(root_group, ep.name, hook)
+
+        except Exception as e:
+            logger.error(f"Failed to apply hook {ep.name}: {e}")
+
+
+def _add_subcommand_to_group(root_group: click.Group, group_name: str, command_name: str, command: click.Command):
+    """Add a subcommand to an existing command group."""
+    if group_name not in root_group.commands:
+        logger.warning(f"Cannot add plugin subcommand '{command_name}' - group '{group_name}' does not exist")
+        return
+
+    group = root_group.commands[group_name]
+    if not isinstance(group, click.Group):
+        logger.warning(f"Cannot add plugin subcommand '{command_name}' - '{group_name}' is not a command group")
+        return
+
+    group.add_command(command, name=command_name)
+    # lower to debug later
+    logger.info(f"Registered plugin subcommand: flyte {group_name} {command_name}")
+
+
+def _apply_hook_to_command(root_group: click.Group, command_name: str, hook: CommandHook):
+    """Apply a hook to a top-level command."""
+    if command_name not in root_group.commands:
+        logger.warning(f"Cannot apply hook - command '{command_name}' does not exist")
+        return
+
+    original_command = root_group.commands[command_name]
+    try:
+        modified_command = hook(original_command)
+        root_group.commands[command_name] = modified_command
+        # lower to debug later
+        logger.info(f"Applied hook to command: flyte {command_name}")
+    except Exception as e:
+        logger.error(f"Hook failed for command {command_name}: {e}")
+        root_group.commands[command_name] = original_command
+
+
+def _apply_hook_to_subcommand(root_group: click.Group, group_name: str, command_name: str, hook: CommandHook):
+    """Apply a hook to a subcommand within a group."""
+    if group_name not in root_group.commands:
+        logger.warning(f"Cannot apply hook - group '{group_name}' does not exist")
+        return
+
+    group = root_group.commands[group_name]
+    if not isinstance(group, click.Group):
+        logger.warning(f"Cannot apply hook - '{group_name}' is not a command group")
+        return
+
+    if command_name not in group.commands:
+        logger.warning(f"Cannot apply hook - subcommand '{command_name}' does not exist in group '{group_name}'")
+        return
+
+    original_command = group.commands[command_name]
+    if original_command.callback is not None:
+        original_command.callback()
+    try:
+        modified_command = hook(original_command)
+        group.commands[command_name] = modified_command
+        logger.info(f"Applied hook to subcommand: flyte {group_name} {command_name}")
+    except Exception as e:
+        logger.error(f"Hook failed for subcommand {group_name}.{command_name}: {e}")
+        group.commands[command_name] = original_command