flyte 2.0.0b21__py3-none-any.whl → 2.0.0b23__py3-none-any.whl

flyte/_trigger.py

@@ -0,0 +1,382 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, Mapping, Union
+
+import rich.repr
+
+
+class _trigger_time:
+    """
+    This class represents the actual time of Trigger, which can be bound to any task input.
+    """
+
+
+TriggerTime = _trigger_time()
+
+
+@rich.repr.auto
+@dataclass(frozen=True)
+class Cron:
+    """
+    This class defines a Cron automation that can be associated with a Trigger in Flyte.
+    Example usage:
+    ```python
+    from flyte.trigger import Trigger, Cron
+    my_trigger = Trigger(
+        name="my_cron_trigger",
+        automation=Cron("0 * * * *"),  # Runs every hour
+        description="A trigger that runs every hour",
+    )
+    ```
+    """
+
+    expression: str
+
+    def __str__(self):
+        return f"Cron Trigger: {self.expression}"
+
+
+@rich.repr.auto
+@dataclass(frozen=True)
+class FixedRate:
+    """
+    This class defines a FixedRate automation that can be associated with a Trigger in Flyte.
+    Example usage:
+    ```python
+    from flyte.trigger import Trigger, FixedRate
+    my_trigger = Trigger(
+        name="my_fixed_rate_trigger",
+        automation=FixedRate(60),  # Runs every hour
+        description="A trigger that runs every hour",
+    )
+    ```
+    """
+
+    interval_minutes: int
+    start_time: datetime | None = None
+
+    def __str__(self):
+        return f"FixedRate Trigger: every {self.interval_minutes} minutes"
+
+
+@rich.repr.auto
+@dataclass(frozen=True)
+class Trigger:
+    """
+    This class defines specification of a Trigger, that can be associated with any Flyte V2 task.
+    The trigger then is deployed to the Flyte Platform.
+
+    Triggers can be used to run tasks on a schedule, in response to events, or based on other conditions.
+    The `Trigger` class encapsulates the metadata and configuration needed to define a trigger.
+
+    You can associate the same Trigger object with multiple tasks.
+
+    Example usage:
+    ```python
+    from flyte.trigger import Trigger
+    my_trigger = Trigger(
+        name="my_trigger",
+        description="A trigger that runs every hour",
+    )
+    ```
+
+    :param name: (str) The name of the trigger.
+    :param automation: (AutomationType) The automation type, currently only supports Cron.
+    :param description: (str) A description of the trigger, default is an empty string.
+    :param auto_activate: (bool) Whether the trigger should be automatically activated, default is True.
+    :param inputs: (Dict[str, Any]) Optional inputs for the trigger, default is None. If provided, will replace the
+       values for inputs to these defaults.
+    :param env_vars: (Dict[str, str]) Optional environment variables for the trigger, default is None. If provided, will
+        replace the environment variables set in the config of the task.
+    :param interruptible: (bool) Whether the trigger is interruptible, default is None. If provided,
+     it overrides whatever is set in the config of the task.
+    :param overwrite_cache: (bool) Whether to overwrite the cache, default is False.
+    :param queue: (str) Optional queue to run the trigger in, default is None.
+    :param labels: (Mapping[str, str]) Optional labels to attach to the trigger, default is None.
+    :param annotations: (Mapping[str, str]) Optional annotations to attach to the trigger, default is None.
+    """
+
+    name: str
+    automation: Union[Cron, FixedRate]
+    description: str = ""
+    auto_activate: bool = True
+    inputs: Dict[str, Any] | None = None
+    env_vars: Dict[str, str] | None = None
+    interruptible: bool | None = None
+    overwrite_cache: bool = False
+    queue: str | None = None
+    labels: Mapping[str, str] | None = None
+    annotations: Mapping[str, str] | None = None
+
+    def __post_init__(self):
+        if not self.name:
+            raise ValueError("Trigger name cannot be empty")
+        if self.automation is None:
+            raise ValueError("Automation cannot be None")
+
+    @classmethod
+    def daily(
+        cls,
+        trigger_time_input_key: str = "trigger_time",
+        *,
+        name: str = "daily",
+        description: str = "A trigger that runs daily at midnight",
+        auto_activate: bool = True,
+        inputs: Dict[str, Any] | None = None,
+        env_vars: Dict[str, str] | None = None,
+        interruptible: bool | None = None,
+        overwrite_cache: bool = False,
+        queue: str | None = None,
+        labels: Mapping[str, str] | None = None,
+        annotations: Mapping[str, str] | None = None,
+    ) -> Trigger:
+        """
+        Creates a Cron trigger that runs daily at midnight.
+
+        Args:
+            trigger_time_input_key (str): The input key for the trigger time, default is "trigger_time".
+            name (str): The name of the trigger, default is "daily".
+            description (str): A description of the trigger.
+            auto_activate (bool): Whether the trigger should be automatically activated.
+            inputs (Dict[str, Any] | None): Optional inputs for the trigger.
+            env_vars (Dict[str, str] | None): Optional environment variables.
+            interruptible (bool | None): Whether the trigger is interruptible.
+            overwrite_cache (bool): Whether to overwrite the cache.
+            queue (str | None): Optional queue to run the trigger in.
+            labels (Mapping[str, str] | None): Optional labels to attach to the trigger.
+            annotations (Mapping[str, str] | None): Optional annotations to attach to the trigger.
+
+        Returns:
+            Trigger: A trigger that runs daily at midnight.
+        """
+        final_inputs = {trigger_time_input_key: TriggerTime}
+        if inputs:
+            final_inputs.update(inputs)
+
+        return cls(
+            name=name,
+            automation=Cron("0 0 * * *"),  # Cron expression for daily at midnight
+            description=description,
+            auto_activate=auto_activate,
+            inputs=final_inputs,
+            env_vars=env_vars,
+            interruptible=interruptible,
+            overwrite_cache=overwrite_cache,
+            queue=queue,
+            labels=labels,
+            annotations=annotations,
+        )
+
+    @classmethod
+    def hourly(
+        cls,
+        trigger_time_input_key: str = "trigger_time",
+        *,
+        name: str = "hourly",
+        description: str = "A trigger that runs every hour",
+        auto_activate: bool = True,
+        inputs: Dict[str, Any] | None = None,
+        env_vars: Dict[str, str] | None = None,
+        interruptible: bool | None = None,
+        overwrite_cache: bool = False,
+        queue: str | None = None,
+        labels: Mapping[str, str] | None = None,
+        annotations: Mapping[str, str] | None = None,
+    ) -> Trigger:
+        """
+        Creates a Cron trigger that runs every hour.
+
+        Args:
+            trigger_time_input_key (str): The input parameter for the trigger time, default is "trigger_time".
+            name (str): The name of the trigger, default is "hourly".
+            description (str): A description of the trigger.
+            auto_activate (bool): Whether the trigger should be automatically activated.
+            inputs (Dict[str, Any] | None): Optional inputs for the trigger.
+            env_vars (Dict[str, str] | None): Optional environment variables.
+            interruptible (bool | None): Whether the trigger is interruptible.
+            overwrite_cache (bool): Whether to overwrite the cache.
+            queue (str | None): Optional queue to run the trigger in.
+            labels (Mapping[str, str] | None): Optional labels to attach to the trigger.
+            annotations (Mapping[str, str] | None): Optional annotations to attach to the trigger.
+
+        Returns:
+            Trigger: A trigger that runs every hour, on the hour.
+        """
+        final_inputs = {trigger_time_input_key: TriggerTime}
+        if inputs:
+            final_inputs.update(inputs)
+
+        return cls(
+            name=name,
+            automation=Cron("0 * * * *"),  # Cron expression for every hour
+            description=description,
+            auto_activate=auto_activate,
+            inputs=final_inputs,
+            env_vars=env_vars,
+            interruptible=interruptible,
+            overwrite_cache=overwrite_cache,
+            queue=queue,
+            labels=labels,
+            annotations=annotations,
+        )
+
+    @classmethod
+    def minutely(
+        cls,
+        trigger_time_input_key: str = "trigger_time",
+        *,
+        name: str = "minutely",
+        description: str = "A trigger that runs every minute",
+        auto_activate: bool = True,
+        inputs: Dict[str, Any] | None = None,
+        env_vars: Dict[str, str] | None = None,
+        interruptible: bool | None = None,
+        overwrite_cache: bool = False,
+        queue: str | None = None,
+        labels: Mapping[str, str] | None = None,
+        annotations: Mapping[str, str] | None = None,
+    ) -> Trigger:
+        """
+        Creates a Cron trigger that runs every minute.
+
+        Args:
+            trigger_time_input_key (str): The input parameter for the trigger time, default is "trigger_time".
+            name (str): The name of the trigger, default is "every_minute".
+            description (str): A description of the trigger.
+            auto_activate (bool): Whether the trigger should be automatically activated.
+            inputs (Dict[str, Any] | None): Optional inputs for the trigger.
+            env_vars (Dict[str, str] | None): Optional environment variables.
+            interruptible (bool | None): Whether the trigger is interruptible.
+            overwrite_cache (bool): Whether to overwrite the cache.
+            queue (str | None): Optional queue to run the trigger in.
+            labels (Mapping[str, str] | None): Optional labels to attach to the trigger.
+            annotations (Mapping[str, str] | None): Optional annotations to attach to the trigger.
+
+        Returns:
+            Trigger: A trigger that runs every minute.
+        """
+        final_inputs = {trigger_time_input_key: TriggerTime}
+        if inputs:
+            final_inputs.update(inputs)
+
+        return cls(
+            name=name,
+            automation=Cron("* * * * *"),  # Cron expression for every minute
+            description=description,
+            auto_activate=auto_activate,
+            inputs=final_inputs,
+            env_vars=env_vars,
+            interruptible=interruptible,
+            overwrite_cache=overwrite_cache,
+            queue=queue,
+            labels=labels,
+            annotations=annotations,
+        )
+
+    @classmethod
+    def weekly(
+        cls,
+        trigger_time_input_key: str = "trigger_time",
+        *,
+        name: str = "weekly",
+        description: str = "A trigger that runs weekly on Sundays at midnight",
+        auto_activate: bool = True,
+        inputs: Dict[str, Any] | None = None,
+        env_vars: Dict[str, str] | None = None,
+        interruptible: bool | None = None,
+        overwrite_cache: bool = False,
+        queue: str | None = None,
+        labels: Mapping[str, str] | None = None,
+        annotations: Mapping[str, str] | None = None,
+    ) -> Trigger:
+        """
+        Creates a Cron trigger that runs weekly on Sundays at midnight.
+
+        Args:
+            trigger_time_input_key (str): The input parameter for the trigger time, default is "trigger_time".
+            name (str): The name of the trigger, default is "weekly".
+            description (str): A description of the trigger.
+            auto_activate (bool): Whether the trigger should be automatically activated.
+            inputs (Dict[str, Any] | None): Optional inputs for the trigger.
+            env_vars (Dict[str, str] | None): Optional environment variables.
+            interruptible (bool | None): Whether the trigger is interruptible.
+            overwrite_cache (bool): Whether to overwrite the cache.
+            queue (str | None): Optional queue to run the trigger in.
+            labels (Mapping[str, str] | None): Optional labels to attach to the trigger.
+            annotations (Mapping[str, str] | None): Optional annotations to attach to the trigger.
+
+        Returns:
+            Trigger: A trigger that runs weekly on Sundays at midnight.
+        """
+        final_inputs = {trigger_time_input_key: TriggerTime}
+        if inputs:
+            final_inputs.update(inputs)
+
+        return cls(
+            name=name,
+            automation=Cron("0 0 * * 0"),  # Cron expression for every Sunday at midnight
+            description=description,
+            auto_activate=auto_activate,
+            inputs=final_inputs,
+            env_vars=env_vars,
+            interruptible=interruptible,
+            overwrite_cache=overwrite_cache,
+            queue=queue,
+            labels=labels,
+            annotations=annotations,
+        )
+
+    @classmethod
+    def monthly(
+        cls,
+        trigger_time_input_key: str = "trigger_time",
+        *,
+        name: str = "monthly",
+        description: str = "A trigger that runs monthly on the 1st at midnight",
+        auto_activate: bool = True,
+        inputs: Dict[str, Any] | None = None,
+        env_vars: Dict[str, str] | None = None,
+        interruptible: bool | None = None,
+        overwrite_cache: bool = False,
+        queue: str | None = None,
+        labels: Mapping[str, str] | None = None,
+        annotations: Mapping[str, str] | None = None,
+    ) -> Trigger:
+        """
+        Creates a Cron trigger that runs monthly on the 1st at midnight.
+
+        Args:
+            trigger_time_input_key (str): The input parameter for the trigger time, default is "trigger_time".
+            name (str): The name of the trigger, default is "monthly".
+            description (str): A description of the trigger.
+            auto_activate (bool): Whether the trigger should be automatically activated.
+            inputs (Dict[str, Any] | None): Optional inputs for the trigger.
+            env_vars (Dict[str, str] | None): Optional environment variables.
+            interruptible (bool | None): Whether the trigger is interruptible.
+            overwrite_cache (bool): Whether to overwrite the cache.
+            queue (str | None): Optional queue to run the trigger in.
+            labels (Mapping[str, str] | None): Optional labels to attach to the trigger.
+            annotations (Mapping[str, str] | None): Optional annotations to attach to the trigger.
+
+        Returns:
+            Trigger: A trigger that runs monthly on the 1st at midnight.
+        """
+        final_inputs = {trigger_time_input_key: TriggerTime}
+        if inputs:
+            final_inputs.update(inputs)
+
+        return cls(
+            name=name,
+            automation=Cron("0 0 1 * *"),  # Cron expression for monthly on the 1st at midnight
+            description=description,
+            auto_activate=auto_activate,
+            inputs=final_inputs,
+            env_vars=env_vars,
+            interruptible=interruptible,
+            overwrite_cache=overwrite_cache,
+            queue=queue,
+            labels=labels,
+            annotations=annotations,
+        )

flyte/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.0.0b21'
-__version_tuple__ = version_tuple = (2, 0, 0, 'b21')
+__version__ = version = '2.0.0b23'
+__version_tuple__ = version_tuple = (2, 0, 0, 'b23')
 
-__commit_id__ = commit_id = 'g7f82f6ddd'
+__commit_id__ = commit_id = 'g52dc01de2'

flyte/cli/_abort.py

@@ -1,5 +1,4 @@
 import rich_click as click
-from rich.console import Console
 
 from flyte.cli import _common as common
 
@@ -23,6 +22,7 @@ def run(cfg: common.CLIConfig, run_name: str, project: str | None = None, domain
     cfg.init(project=project, domain=domain)
     r = Run.get(name=run_name)
     if r:
-        console = Console()
-        r.abort()
+        console = common.get_console()
+        with console.status(f"Aborting run '{run_name}'...", spinner="dots"):
+            r.abort()
         console.print(f"Run '{run_name}' has been aborted.")

flyte/cli/_build.py

@@ -44,9 +44,7 @@ class BuildEnvCommand(click.Command):
         super().__init__(*args, **kwargs)
 
     def invoke(self, ctx: click.Context):
-        from rich.console import Console
-
-        console = Console()
+        console = common.get_console()
         console.print(f"Building Environment: {self.obj_name}")
         obj: CLIConfig = ctx.obj
         obj.init()

flyte/cli/_common.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import importlib.util
+import json
 import logging
 import os
 import sys
@@ -22,7 +23,7 @@ from rich.traceback import Traceback
 import flyte.errors
 from flyte.config import Config
 
-OutputFormat = Literal["table", "json", "table-simple"]
+OutputFormat = Literal["table", "json", "table-simple", "json-raw"]
 
 PREFERRED_BORDER_COLOR = "dim cyan"
 PREFERRED_ACCENT_COLOR = "bold #FFD700"
@@ -111,7 +112,7 @@ class CLIConfig:
         """
         return replace(self, **kwargs)
 
-    def init(self, project: str | None = None, domain: str | None = None):
+    def init(self, project: str | None = None, domain: str | None = None, root_dir: str | None = None):
         from flyte.config._config import TaskConfig
 
         task_cfg = TaskConfig(
@@ -131,7 +132,7 @@ class CLIConfig:
 
         updated_config = self.config.with_params(platform_cfg, task_cfg)
 
-        flyte.init_from_config(updated_config, log_level=self.log_level)
+        flyte.init_from_config(updated_config, log_level=self.log_level, root_dir=root_dir)
 
 
 class InvokeBaseMixin:
@@ -177,7 +178,7 @@ class InvokeBaseMixin:
         except Exception as e:
             if ctx.obj and ctx.obj.log_level and ctx.obj.log_level <= logging.DEBUG:
                 # If the user has requested verbose output, print the full traceback
-                console = Console()
+                console = get_console()
                 console.print(Traceback.from_exception(type(e), e, e.__traceback__))
                 exit(1)
             else:
@@ -381,6 +382,11 @@ def format(title: str, vals: Iterable[Any], of: OutputFormat = "table") -> Table
             if not vals:
                 return pretty_repr([])
             return pretty_repr([v.to_dict() for v in vals])
+        case "json-raw":
+            if not vals:
+                return []
+            return json.dumps([v.to_dict() for v in vals])
+
     raise click.ClickException("Unknown output format. Supported formats are: table, table-simple, json.")
 
 
@@ -395,3 +401,10 @@ def get_panel(title: str, renderable: Any, of: OutputFormat = "table") -> Panel:
         title=f"[{PREFERRED_ACCENT_COLOR}]{title}[/{PREFERRED_ACCENT_COLOR}]",
         border_style=PREFERRED_BORDER_COLOR,
     )
+
+
+def get_console() -> Console:
+    """
+    Get a console that is configured to use colors if the terminal supports it.
+    """
+    return Console(color_system="auto", force_terminal=True, width=120)

flyte/cli/_create.py

@@ -3,6 +3,7 @@ from typing import Any, Dict, get_args
 
 import rich_click as click
 
+import flyte
 import flyte.cli._common as common
 from flyte.cli._option import MutuallyExclusiveOption
 from flyte.remote import SecretTypes
@@ -194,3 +195,76 @@ def config(
         yaml.dump(d, f)
 
     click.echo(f"Config file written to {output_path}")
+
+
+@create.command(cls=common.CommandBase)
+@click.argument("task_name", type=str, required=True)
+@click.argument("name", type=str, required=True)
+@click.option(
+    "--schedule",
+    type=str,
+    required=True,
+    help="Cron schedule for the trigger. Defaults to every minute.",
+    show_default=True,
+)
+@click.option(
+    "--description",
+    type=str,
+    default="",
+    help="Description of the trigger.",
+    show_default=True,
+)
+@click.option(
+    "--auto-activate",
+    is_flag=True,
+    default=True,
+    help="Whether the trigger should not be automatically activated. Defaults to True.",
+    show_default=True,
+)
+@click.option(
+    "--trigger-time-var",
+    type=str,
+    default="trigger_time",
+    help="Variable name for the trigger time in the task inputs. Defaults to 'trigger_time'.",
+    show_default=True,
+)
+@click.pass_obj
+def trigger(
+    cfg: common.CLIConfig,
+    task_name: str,
+    name: str,
+    schedule: str,
+    trigger_time_var: str = "trigger_time",
+    auto_activate: bool = True,
+    description: str = "",
+    project: str | None = None,
+    domain: str | None = None,
+):
+    """
+    Create a new trigger for a task. The task name and trigger name are required.
+
+    Example:
+
+    ```bash
+    $ flyte create trigger my_task my_trigger --schedule "0 0 * * *"
+    ```
+
+    This will create a trigger that runs every day at midnight.
+    """
+    from flyte.remote import Trigger
+
+    cfg.init(project, domain)
+    console = common.get_console()
+
+    trigger = flyte.Trigger(
+        name=name,
+        automation=flyte.Cron(schedule),
+        description=description,
+        auto_activate=auto_activate,
+        inputs={trigger_time_var: flyte.TriggerTime},  # Use the trigger time variable in inputs
+        env_vars=None,
+        interruptible=None,
+    )
+    with console.status("Creating trigger..."):
+        v = Trigger.create(trigger, task_name=task_name)
+    console.print(f"[bold green]Trigger {v.name} created successfully![/bold green]")

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
 
@@ -43,6 +43,16 @@ class DeployArguments:
             )
         },
     )
+    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.",
+            )
+        },
+    )
     recursive: bool = field(
         default=False,
         metadata={
@@ -94,12 +104,10 @@ 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)
+        obj.init(self.deploy_args.project, self.deploy_args.domain, root_dir=self.deploy_args.root_dir)
         with console.status("Deploying...", spinner="dots"):
             deployment = flyte.deploy(
                 self.env,
@@ -109,7 +117,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):
@@ -125,13 +133,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)
@@ -167,7 +173,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):