flyte 0.2.0b7__py3-none-any.whl → 0.2.0b8__py3-none-any.whl

flyte/_environment.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+import re
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Dict, List, Literal, Optional, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Union
 
 import rich.repr
 
@@ -14,6 +15,10 @@ if TYPE_CHECKING:
     from kubernetes.client import V1PodTemplate
 
 
+def is_snake_or_kebab_with_numbers(s: str) -> bool:
+    return re.fullmatch(r"^[a-z0-9]+([_-][a-z0-9]+)*$", s) is not None
+
+
 @rich.repr.auto
 @dataclass(init=True, repr=True)
 class Environment:
@@ -36,8 +41,44 @@ class Environment:
     resources: Optional[Resources] = None
     image: Union[str, Image, Literal["auto"]] = "auto"
 
+    def __post_init__(self):
+        if not is_snake_or_kebab_with_numbers(self.name):
+            raise ValueError(f"Environment name '{self.name}' must be in snake_case or kebab-case format.")
+
     def add_dependency(self, *env: Environment):
         """
         Add a dependency to the environment.
         """
         self.env_dep_hints.extend(env)
+
+    def clone_with(
+        self,
+        name: str,
+        image: Optional[Union[str, Image, Literal["auto"]]] = None,
+        resources: Optional[Resources] = None,
+        env: Optional[Dict[str, str]] = None,
+        secrets: Optional[SecretRequest] = None,
+        env_dep_hints: Optional[List[Environment]] = None,
+        **kwargs: Any,
+    ) -> Environment:
+        raise NotImplementedError
+
+    def _get_kwargs(self) -> Dict[str, Any]:
+        """
+        Get the keyword arguments for the environment.
+        """
+        kwargs: Dict[str, Any] = {
+            "env_dep_hints": self.env_dep_hints,
+            "image": self.image,
+        }
+        if self.resources is not None:
+            kwargs["resources"] = self.resources
+        if self.secrets is not None:
+            kwargs["secrets"] = self.secrets
+        if self.env is not None:
+            kwargs["env"] = self.env
+        if self.pod_template is not None:
+            kwargs["pod_template"] = self.pod_template
+        if self.description is not None:
+            kwargs["description"] = self.description
+        return kwargs

flyte/_image.py

@@ -444,8 +444,7 @@ class Image:
         ```
 
         For more information on the uv script format, see the documentation:
-        <href="https://docs.astral.sh/uv/guides/scripts/#declaring-script-dependencies">
-            UV: Declaring script dependencies</href>
+        [UV: Declaring script dependencies](https://docs.astral.sh/uv/guides/scripts/#declaring-script-dependencies)
 
         :param name: name of the image
         :param registry: registry to use for the image

flyte/_internal/controllers/__init__.py

@@ -28,6 +28,8 @@ class Controller(Protocol):
         """
         ...
 
+    def submit_sync(self, _task: TaskTemplate, *args, **kwargs) -> Any: ...
+
     async def submit_task_ref(self, _task: task_definition_pb2.TaskDetails, *args, **kwargs) -> Any:
         """
         Submit a task reference to the controller asynchronously and wait for the result. This is async and will block

flyte/_internal/controllers/_local_controller.py

@@ -8,6 +8,7 @@ from flyte._internal.runtime.entrypoints import direct_dispatch
 from flyte._logging import log, logger
 from flyte._protos.workflow import task_definition_pb2
 from flyte._task import TaskTemplate
+from flyte._utils.asyn import loop_manager
 from flyte.models import ActionID, NativeInterface, RawDataPath
 
 R = TypeVar("R")
@@ -58,6 +59,8 @@ class LocalController:
             return result
         return out
 
+    submit_sync = loop_manager.synced(submit)
+
     async def finalize_parent_action(self, action: ActionID):
         pass
 

flyte/_internal/controllers/remote/_controller.py

@@ -21,6 +21,7 @@ from flyte._internal.runtime.task_serde import translate_task_to_wire
 from flyte._logging import logger
 from flyte._protos.workflow import run_definition_pb2, task_definition_pb2
 from flyte._task import TaskTemplate
+from flyte._utils.asyn import loop_manager
 from flyte.models import ActionID, NativeInterface, SerializationContext
 
 R = TypeVar("R")
@@ -235,6 +236,8 @@ class RemoteController(Controller):
         async with self._parent_action_semaphore[unique_action_name(current_action_id)]:
             return await self._submit(task_call_seq, _task, *args, **kwargs)
 
+    submit_sync = loop_manager.synced(submit)
+
     async def finalize_parent_action(self, action_id: ActionID):
         """
         This method is invoked when the parent action is finished. It will finalize the run and upload the outputs

flyte/_internal/controllers/remote/_informer.py

@@ -38,11 +38,11 @@ class ActionCache:
         """
         Add an action to the cache if it doesn't exist. This is invoked by the watch.
         """
-        logger.info(f"Observing phase {run_definition_pb2.Phase.Name(state.phase)} for {state.action_id.name}")
+        logger.debug(f"Observing phase {run_definition_pb2.Phase.Name(state.phase)} for {state.action_id.name}")
         if state.output_uri:
-            logger.info(f"Output URI: {state.output_uri}")
+            logger.debug(f"Output URI: {state.output_uri}")
         else:
-            logger.info(f"{state.action_id.name} has no output URI")
+            logger.warning(f"{state.action_id.name} has no output URI")
         if state.phase == run_definition_pb2.Phase.PHASE_FAILED:
             logger.error(
                 f"Action {state.action_id.name} failed with error (msg):"

flyte/_task.py

@@ -3,10 +3,10 @@ from __future__ import annotations
 import weakref
 from dataclasses import dataclass, field, replace
 from functools import cached_property
+from inspect import iscoroutinefunction
 from typing import (
     TYPE_CHECKING,
     Any,
-    Awaitable,
     Callable,
     Coroutine,
     Dict,
@@ -15,6 +15,7 @@ from typing import (
     Literal,
     Optional,
     ParamSpec,
+    TypeAlias,
     TypeVar,
     Union,
 )
@@ -42,6 +43,10 @@ if TYPE_CHECKING:
 P = ParamSpec("P")  # capture the function's parameters
 R = TypeVar("R")  # return type
 
+AsyncFunctionType: TypeAlias = Callable[P, Coroutine[Any, Any, R]]
+SyncFunctionType: TypeAlias = Callable[P, R]
+FunctionTypes: TypeAlias = Union[AsyncFunctionType, SyncFunctionType]
+
 
 @dataclass(kw_only=True)
 class TaskTemplate(Generic[P, R]):
@@ -98,6 +103,9 @@ class TaskTemplate(Generic[P, R]):
     local: bool = field(default=False, init=False)
     ref: bool = field(default=False, init=False, repr=False, compare=False)
 
+    # Only used in python 3.10 and 3.11, where we cannot use markcoroutinefunction
+    _call_as_synchronous: bool = False
+
     def __post_init__(self):
         # If pod_template is set to a pod, verify
         if self.pod_template is not None and not isinstance(self.pod_template, str):
@@ -208,13 +216,15 @@ class TaskTemplate(Generic[P, R]):
     def native_interface(self) -> NativeInterface:
         return self.interface
 
-    async def __call__(self, *args: P.args, **kwargs: P.kwargs) -> Coroutine[Any, Any, R]:
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> Coroutine[Any, Any, R] | R:
         """
         This is the entrypoint for an async function task at runtime. It will be called during an execution.
         Please do not override this method, if you simply want to modify the execution behavior, override the
         execute method.
 
-        # TODO lets provide one hook to implement, _pre, _execute and _post. We do not want actual execute to
+        This needs to be overridable to maybe be async.
+        The returned thing from here needs to be an awaitable if the underlying task is async, and a regular object
+        if the task is not.
         """
         try:
             ctx = internal_ctx()
@@ -226,8 +236,14 @@ class TaskTemplate(Generic[P, R]):
 
                 controller = get_controller()
                 if controller:
-                    return await controller.submit(self, *args, **kwargs)
-            return await self.execute(*args, **kwargs)
+                    if self._call_as_synchronous:
+                        return controller.submit_sync(self, *args, **kwargs)
+                    else:
+                        return controller.submit(self, *args, **kwargs)
+                else:
+                    raise RuntimeSystemError("BadContext", "Controller is not initialized.")
+
+            return self.forward(*args, **kwargs)
         except RuntimeSystemError:
             raise
         except RuntimeUserError:
@@ -235,6 +251,17 @@ class TaskTemplate(Generic[P, R]):
         except Exception as e:
             raise RuntimeUserError(type(e).__name__, str(e)) from e
 
+    def forward(self, *args: P.args, **kwargs: P.kwargs) -> Coroutine[Any, Any, R] | R:
+        """
+        Think of this as a local execute method for your task. This function will be invoked by the __call__ method
+        when not in a Flyte task execution context.  See the implementation below for an example.
+
+        :param args:
+        :param kwargs:
+        :return:
+        """
+        raise NotImplementedError
+
     def override(
         self,
         *,
@@ -290,26 +317,38 @@ class AsyncFunctionTaskTemplate(TaskTemplate[P, R]):
     is decorated with the task decorator.
     """
 
-    func: Callable[P, Awaitable[R]]
+    func: FunctionTypes
+
+    def __post_init__(self):
+        super().__post_init__()
+        if not iscoroutinefunction(self.func):
+            self._call_as_synchronous = True
 
     @cached_property
     def native_interface(self) -> NativeInterface:
         return NativeInterface.from_callable(self.func)
 
+    def forward(self, *args: P.args, **kwargs: P.kwargs) -> Coroutine[Any, Any, R] | R:
+        # In local execution, we want to just call the function. Note we're not awaiting anything here.
+        # If the function was a coroutine function, the coroutine is returned and the await that the caller has
+        # in front of the task invocation will handle the awaiting.
+        return self.func(*args, **kwargs)
+
     async def execute(self, *args: P.args, **kwargs: P.kwargs) -> R:
         """
         This is the execute method that will be called when the task is invoked. It will call the actual function.
         # TODO We may need to keep this as the bare func execute, and need a pre and post execute some other func.
         """
+
         ctx = internal_ctx()
+        assert ctx.data.task_context is not None, "Function should have already returned if not in a task context"
         ctx_data = await self.pre(*args, **kwargs)
-        if ctx.data.task_context is not None:
-            tctx = ctx.data.task_context.replace(data=ctx_data)
-            with ctx.replace_task_context(tctx):
+        tctx = ctx.data.task_context.replace(data=ctx_data)
+        with ctx.replace_task_context(tctx):
+            if iscoroutinefunction(self.func):
                 v = await self.func(*args, **kwargs)
-                await self.post(v)
-        else:
-            v = await self.func(*args, **kwargs)
+            else:
+                v = self.func(*args, **kwargs)
             await self.post(v)
         return v
 

flyte/_task_environment.py

@@ -1,11 +1,19 @@
 from __future__ import annotations
 
-import asyncio
 import weakref
 from dataclasses import dataclass, field, replace
 from datetime import timedelta
-from functools import wraps
-from typing import TYPE_CHECKING, Awaitable, Callable, Dict, List, Literal, Optional, ParamSpec, TypeVar, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Union,
+    cast,
+)
 
 import rich.repr
 
@@ -23,8 +31,7 @@ from .models import NativeInterface
 if TYPE_CHECKING:
     from kubernetes.client import V1PodTemplate
 
-P = ParamSpec("P")  # capture the function's parameters
-R = TypeVar("R")  # return type
+    from ._task import FunctionTypes, P, R
 
 
 @rich.repr.auto
@@ -54,7 +61,7 @@ class TaskEnvironment(Environment):
     """
 
     cache: Union[CacheRequest] = "auto"
-    reusable: Union[ReusePolicy, Literal["auto"], None] = None
+    reusable: ReusePolicy | None = None
     # TODO Shall we make this union of string or env? This way we can lookup the env by module/file:name
     # TODO also we could add list of files that are used by this environment
 
@@ -65,32 +72,42 @@ class TaskEnvironment(Environment):
         name: str,
         image: Optional[Union[str, Image, Literal["auto"]]] = None,
         resources: Optional[Resources] = None,
-        cache: Union[CacheRequest, None] = None,
         env: Optional[Dict[str, str]] = None,
-        reusable: Union[ReusePolicy, None] = None,
         secrets: Optional[SecretRequest] = None,
         env_dep_hints: Optional[List[Environment]] = None,
+        **kwargs: Any,
     ) -> TaskEnvironment:
         """
-        Clone the environment with new settings.
+        Clone the TaskEnvironment with new parameters.
+        besides the base environment parameters, you can override, kwargs like `cache`, `reusable`, etc.
+
         """
-        if image is None:
-            image = self.image
-        else:
-            image = "auto"
-        return replace(
-            self,
-            cache=cache if cache else "auto",
-            reusable=reusable,
-            name=name,
-            image=image,
-            resources=resources,
-            env=env,
-            secrets=secrets,
-            env_dep_hints=env_dep_hints if env_dep_hints else [],
-        )
-
-    def _task(
+        cache = kwargs.pop("cache", None)
+        reusable = kwargs.pop("reusable", None)
+
+        # validate unknown kwargs if needed
+        if kwargs:
+            raise TypeError(f"Unexpected keyword arguments: {list(kwargs.keys())}")
+
+        kwargs = self._get_kwargs()
+        kwargs["name"] = name
+        if image is not None:
+            kwargs["image"] = image
+        if resources is not None:
+            kwargs["resources"] = resources
+        if cache is not None:
+            kwargs["cache"] = cache
+        if env is not None:
+            kwargs["env"] = env
+        if reusable is not None:
+            kwargs["reusable"] = reusable
+        if secrets is not None:
+            kwargs["secrets"] = secrets
+        if env_dep_hints is not None:
+            kwargs["env_dep_hints"] = env_dep_hints
+        return replace(self, **kwargs)
+
+    def task(
         self,
         _func=None,
         *,
@@ -104,6 +121,7 @@ class TaskEnvironment(Environment):
         report: bool = False,
     ) -> Union[AsyncFunctionTaskTemplate, Callable[P, R]]:
         """
+        :param _func: Optional The function to decorate. If not provided, the decorator will return a callable that
         :param name: Optional The name of the task (defaults to the function name)
         :param cache: Optional The cache policy for the task, defaults to auto, which will cache the results of the
         task.
@@ -119,25 +137,12 @@ class TaskEnvironment(Environment):
             if pod_template is not None:
                 raise ValueError("Cannot set pod_template when environment is reusable.")
 
-        def decorator(func: Callable[P, Awaitable[R]]) -> AsyncFunctionTaskTemplate[P, R]:
+        def decorator(func: FunctionTypes) -> AsyncFunctionTaskTemplate[P, R]:
             task_name = name or func.__name__
             task_name = self.name + "." + task_name
-            if len(task_name) > 30:
-                # delete this if we can remove the restriction that task names must be <= 30 characters
-                task_name = task_name[-30:]
-
-            @wraps(func)
-            async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
-                return await func(*args, **kwargs)
-
-            if not asyncio.iscoroutinefunction(func):
-                raise TypeError(
-                    f"Function {func.__name__} is not a coroutine function. Use @env.task decorator for async tasks."
-                    f"You can simply mark your function as async def {func.__name__} to make it a coroutine function, "
-                    f"it is ok to write sync code in async functions, but not the other way around."
-                )
-            tmpl = AsyncFunctionTaskTemplate(
-                func=wrapper,
+
+            tmpl: AsyncFunctionTaskTemplate = AsyncFunctionTaskTemplate(
+                func=func,
                 name=task_name,
                 image=self.image,
                 resources=self.resources,
@@ -160,29 +165,6 @@ class TaskEnvironment(Environment):
             return cast(AsyncFunctionTaskTemplate, decorator)
         return cast(AsyncFunctionTaskTemplate, decorator(_func))
 
-    @property
-    def task(self) -> Callable:
-        """
-        Decorator to create a new task with the environment settings.
-        The task will be executed in its own container with the specified image, resources, and environment variables,
-        unless reusePolicy is set, in which case the same container will be reused for all tasks with the same
-        environment settings.
-
-        :param name: Optional The name of the task (defaults to the function name)
-        :param cache: Optional The cache policy for the task, defaults to auto, which will cache the results of the
-         task.
-        :param retries: Optional The number of retries for the task, defaults to 0, which means no retries.
-        :param docs: Optional The documentation for the task, if not provided the function docstring will be used.
-        :param secrets: Optional The secrets that will be injected into the task at runtime.
-        :param timeout: Optional The timeout for the task.
-        :param pod_template: Optional The pod template for the task, if not provided the default pod template will be
-         used.
-        :param report: Optional Whether to generate the html report for the task, defaults to False.
-
-        :return: New Task instance or Task decorator
-        """
-        return self._task
-
     @property
     def tasks(self) -> Dict[str, TaskTemplate]:
         """

flyte/_utils/coro_management.py

@@ -21,5 +21,3 @@ async def run_coros(*coros: typing.Coroutine, return_when: str = asyncio.FIRST_C
         err = t.exception()
         if err:
             raise err
-        else:
-            print(f"Task result: {t.result()}")

flyte/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.2.0b7'
-__version_tuple__ = version_tuple = (0, 2, 0, 'b7')
+__version__ = version = '0.2.0b8'
+__version_tuple__ = version_tuple = (0, 2, 0, 'b8')

flyte/cli/_common.py

@@ -74,6 +74,7 @@ class CLIConfig:
     """
 
     config: Config
+    ctx: click.Context
     log_level: int | None = logging.ERROR
     endpoint: str | None = None
     insecure: bool = False

flyte/cli/_create.py

@@ -10,7 +10,7 @@ from flyte.remote._secret import SecretTypes
 @click.group(name="create")
 def create():
     """
-    Create a new task or environment.
+    The create subcommand allows you to create resources in a Flyte deployment.
     """
 
 
@@ -32,7 +32,23 @@ def secret(
     domain: str | None = None,
 ):
     """
-    Create a new secret.
+    Create a new secret, the name of the secret is required.
+
+    Examples:
+    ```bash
+    flyte create secret my_secret --value my_value
+    ```
+    If `--from-file` is specified, the value will be read from the file instead of being provided directly.
+    Example:
+    ```bash
+    flyte create secret my_secret --from-file /path/to/secret_file
+    ```
+    Secret types can be used to create specific types of secrets. Some secrets are useful for image pull, while some
+    are `regular` / general purpose secrets.
+    Example:
+    ```bash
+    flyte create secret my_secret --type image_pull
+    ```
     """
     from flyte.remote import Secret
 
@@ -55,9 +71,19 @@ def secret(
 @click.option(
     "-o",
     "--output",
-    type=click.Path(),
-    default=Path.cwd(),
+    type=click.Path(exists=False, writable=True),
+    default=Path.cwd() / "config.yaml",
     help="Path to the output dir where the config will be saved, defaults to current directory.",
+    show_default=True,
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    default=False,
+    help="Force overwrite the config file if it already exists.",
+    show_default=True,
+    prompt="Are you sure you want to overwrite the config file?",
+    confirmation_prompt=True,
 )
 def config(
     output: Path,
@@ -66,14 +92,19 @@ def config(
     org: str | None = None,
     project: str | None = None,
     domain: str | None = None,
+    force: bool = False,
 ):
     """
-    Create a new config file.
+    This command creates a configuration file for Flyte CLI.
+    If the `--output` option is not specified, it will create a file named `config.yaml` in the current directory.
+    If the file already exists, it will raise an error unless the `--force` option is used.
     """
     import yaml
 
-    output_file = output / "config.yaml"
-    with open(output_file, "w") as f:
+    if output.exists() and not force:
+        raise click.BadParameter(f"Output file {output} already exists. Use --force to overwrite.")
+
+    with open(output, "w") as f:
         d = {
             "admin": {
                 "endpoint": endpoint,
@@ -87,4 +118,4 @@ def config(
         }
         yaml.dump(d, f)
 
-    click.echo(f"Config file created at {output_file}")
+    click.echo(f"Config file created at {output}")

flyte/cli/_delete.py

@@ -6,7 +6,7 @@ import flyte.cli._common as common
 @click.group(name="delete")
 def delete():
     """
-    Delete a task or environment.
+    The delete subcommand allows you to remove resources from a Flyte deployment.
     """
 
 
@@ -15,7 +15,7 @@ def delete():
 @click.pass_obj
 def secret(cfg: common.CLIConfig, name: str, project: str | None = None, domain: str | None = None):
     """
-    Delete a secret.
+    Delete a secret, the name of the secret is required.
     """
     from flyte.remote import Secret
 

flyte/cli/_deploy.py

@@ -138,5 +138,8 @@ class EnvFiles(common.FileGroup):
 
 deploy = EnvFiles(
     name="deploy",
-    help="deploy one or more environments from a python file.",
+    help="""
+    Deploy one or more environments from a python file.
+    The deploy command will create or update environments in the Flyte system.
+    """,
 )

flyte/cli/_gen.py

@@ -0,0 +1,155 @@
+from os import getcwd
+from typing import Generator, Tuple
+
+import rich_click as click
+
+import flyte.cli._common as common
+
+
+@click.group(name="gen")
+def gen():
+    """
+    Generate documentation
+    """
+
+
+@gen.command(cls=common.CommandBase)
+@click.option("--type", "doc_type", type=str, required=True, help="Type of documentation (valid: markdown)")
+@click.pass_obj
+def docs(cfg: common.CLIConfig, doc_type: str, project: str | None = None, domain: str | None = None):
+    """
+    Generate documentation
+    """
+    if doc_type == "markdown":
+        markdown(cfg)
+    else:
+        raise click.ClickException("Invalid documentation type: {}".format(doc_type))
+
+
+def walk_commands(ctx: click.Context) -> Generator[Tuple[str, click.Command], None, None]:
+    """
+    Recursively walk a Click command tree, starting from the given context.
+
+    Yields:
+        (full_command_path, command_object)
+    """
+    command = ctx.command
+
+    if not isinstance(command, click.Group):
+        yield ctx.command_path, command
+    else:
+        for name in command.list_commands(ctx):
+            subcommand = command.get_command(ctx, name)
+            if subcommand is None:
+                continue
+
+            full_name = f"{ctx.command_path} {name}".strip()
+            yield full_name, subcommand
+
+            # Recurse if subcommand is a MultiCommand (i.e., has its own subcommands)
+            if isinstance(subcommand, click.Group):
+                sub_ctx = click.Context(subcommand, info_name=name, parent=ctx)
+                yield from walk_commands(sub_ctx)
+
+
+def markdown(cfg: common.CLIConfig):
+    """
+    Generate documentation in Markdown format
+    """
+    ctx = cfg.ctx
+
+    output = []
+    output_verb_groups: dict[str, list[str]] = {}
+    output_noun_groups: dict[str, list[str]] = {}
+
+    commands = [*[("flyte", ctx.command)], *walk_commands(ctx)]
+    for cmd_path, cmd in commands:
+        output.append("")
+
+        cmd_path_parts = cmd_path.split(" ")
+
+        if len(cmd_path_parts) > 1:
+            if cmd_path_parts[1] not in output_verb_groups:
+                output_verb_groups[cmd_path_parts[1]] = []
+            if len(cmd_path_parts) > 2:
+                output_verb_groups[cmd_path_parts[1]].append(cmd_path_parts[2])
+
+        if len(cmd_path_parts) == 3:
+            if cmd_path_parts[2] not in output_noun_groups:
+                output_noun_groups[cmd_path_parts[2]] = []
+            output_noun_groups[cmd_path_parts[2]].append(cmd_path_parts[1])
+
+        output.append(f"{'#' * (len(cmd_path_parts) + 1)} {cmd_path}")
+        if cmd.help:
+            output.append("")
+            output.append(f"{cmd.help.strip()}")
+
+        if not cmd.params:
+            continue
+
+        params = cmd.get_params(click.Context(cmd))
+
+        # Collect all data first to calculate column widths
+        table_data = []
+        for param in params:
+            if isinstance(param, click.Option):
+                # Format each option with backticks before joining
+                all_opts = param.opts + param.secondary_opts
+                if len(all_opts) == 1:
+                    opts = f"`{all_opts[0]}`"
+                else:
+                    opts = "".join(
+                        [
+                            "{{< multiline >}}",
+                            "\n".join([f"`{opt}`" for opt in all_opts]),
+                            "{{< /multiline >}}",
+                        ]
+                    )
+                default_value = ""
+                if param.default is not None:
+                    default_value = f"`{param.default}`"
+                    default_value = default_value.replace(f"{getcwd()}/", "")
+                help_text = param.help.strip() if param.help else ""
+                table_data.append([opts, f"`{param.type.name}`", default_value, help_text])
+
+        if not table_data:
+            continue
+
+        # Add table header with proper alignment
+        output.append("")
+        output.append("| Option | Type | Default | Description |")
+        output.append("|--------|------|---------|-------------|")
+
+        # Add table rows with proper alignment
+        for row in table_data:
+            output.append(f"| {row[0]} | {row[1]} | {row[2]} | {row[3]} |")
+
+    output_verb_index = []
+
+    if len(output_verb_groups) > 0:
+        output_verb_index.append("| Action | On |")
+        output_verb_index.append("| ------ | -- |")
+        for verb, nouns in output_verb_groups.items():
+            entries = [f"[`{noun}`](#flyte-{verb}-{noun})" for noun in nouns]
+            output_verb_index.append(f"| `{verb}` | {', '.join(entries)}  |")
+
+    output_noun_index = []
+
+    if len(output_noun_groups) > 0:
+        output_noun_index.append("| Object | Action |")
+        output_noun_index.append("| ------ | -- |")
+        for obj, actions in output_noun_groups.items():
+            entries = [f"[`{action}`](#flyte-{action}-{obj})" for action in actions]
+            output_noun_index.append(f"| `{obj}` | {', '.join(entries)}  |")
+
+    print()
+    print("{{< grid >}}")
+    print("{{< markdown >}}")
+    print("\n".join(output_noun_index))
+    print("{{< /markdown >}}")
+    print("{{< markdown >}}")
+    print("\n".join(output_verb_index))
+    print("{{< /markdown >}}")
+    print("{{< /grid >}}")
+    print()
+    print("\n".join(output))

flyte/cli/_get.py

@@ -11,7 +11,16 @@ from . import _common as common
 @click.group(name="get")
 def get():
     """
-    Get the value of a task or environment.
+    The `get` subcommand allows you to retrieve various resources from a Flyte deployment.
+
+    You can get information about projects, runs, tasks, actions, secrets, and more.
+    Each command supports optional parameters to filter or specify the resource you want to retrieve.
+
+    Every `get` subcommand for example ``get project` without any arguments will list all projects.
+    `get project my_project` will return the details of the project named `my_project`.
+
+    In some cases `get action my_run` will return all actions for the run named `my_run` and
+    `get action my_run my_action` will return the details of the action named `my_action` for the run `my_run`.
     """
 
 
@@ -20,7 +29,7 @@ def get():
 @click.pass_obj
 def project(cfg: common.CLIConfig, name: str | None = None):
     """
-    Get the current project.
+    Retrieve a list of all projects or details of a specific project by name.
     """
     from flyte.remote import Project
 
@@ -39,7 +48,11 @@ def project(cfg: common.CLIConfig, name: str | None = None):
 @click.pass_obj
 def run(cfg: common.CLIConfig, name: str | None = None, project: str | None = None, domain: str | None = None):
     """
-    Get the current run.
+    Get list of all runs or details of a specific run by name.
+
+    The run details will include information about the run, its status, but only the root action will be shown.
+
+    If you want to see the actions for a run, use `get action <run_name>`.
     """
     from flyte.remote import Run, RunDetails
 
@@ -65,7 +78,9 @@ def task(
     domain: str | None = None,
 ):
     """
-    Get the current task.
+    Retrieve a list of all tasks or details of a specific task by name and version.
+
+    Currently name+version are required to get a specific task.
     """
     from flyte.remote import Task
 
@@ -140,8 +155,24 @@ def logs(
     filter_system: bool = False,
 ):
     """
-    Stream logs for the provided run or action. If the run is provided, only the logs for the parent action will be
-    streamed.
+    Stream logs for the provided run or action.
+    If only the run is provided, only the logs for the parent action will be streamed.
+
+    Example:
+    ```bash
+    flyte get logs my_run
+    ```
+
+    But, if you want to see the logs for a specific action, you can provide the action name as well:
+    ```bash
+    flyte get logs my_run my_action
+    ```
+    By default logs will be shown in the raw format, will scroll on the terminal. If automatic scrolling and only
+    tailing --lines lines is desired, use the `--pretty` flag:
+    ```bash
+    flyte get logs my_run my_action --pretty --lines 50
+    ```
+
     """
     import flyte.remote as remote
 
@@ -175,7 +206,7 @@ def secret(
     domain: str | None = None,
 ):
     """
-    Get the current secret.
+    Retrieve a list of all secrets or details of a specific secret by name.
     """
     import flyte.remote as remote
 
@@ -205,6 +236,19 @@ def io(
 ):
     """
     Get the inputs and outputs of a run or action.
+    if only the run name is provided, it will show the inputs and outputs of the root action of that run.
+    If an action name is provided, it will show the inputs and outputs for that action.
+
+    If `--inputs-only` or `--outputs-only` is specified, it will only show the inputs or outputs respectively.
+
+    Example:
+    ```bash
+    flyte get io my_run
+    ```
+    or
+    ```bash
+    flyte get io my_run my_action
+    ```
     """
     if inputs_only and outputs_only:
         raise click.BadParameter("Cannot use both --inputs-only and --outputs-only")
@@ -250,6 +294,8 @@ def io(
 def config(cfg: common.CLIConfig):
     """
     Shows the automatically detected configuration to connect with remote Flyte services.
+
+    The configuration will include the endpoint, organization, and other settings that are used by the CLI.
     """
     console = Console()
     console.print(cfg)

flyte/cli/_run.py

@@ -204,11 +204,31 @@ class TaskFiles(common.FileGroup):
             filename=Path(filename),
             run_args=run_args,
             name=filename,
-            help=f"Run, functions decorated `env.task` {filename}",
+            help=f"Run, functions decorated with `env.task` in {filename}",
         )
 
 
 run = TaskFiles(
     name="run",
-    help="Run a task from a python file.",
+    help="""
+Run a task from a python file.
+
+Example usage:
+```bash
+flyte run --name examples/basics/hello.py my_task --arg1 value1 --arg2 value2
+```
+Note: all arguments for the run command are provided right after the `run` command and before the file name.
+
+You can also specify the project and domain using the `--project` and `--domain` options, respectively. These
+options can be set in the config file or passed as command line arguments.
+
+Note: The arguments for the task are provided after the task name and can be retrieved using `--help`
+Example:
+```bash
+flyte run --name examples/basics/hello.py my_task --help
+```
+
+To run a task locally, use the `--local` flag. This will run the task in the local environment instead of the remote
+ Flyte environment.
+""",
 )

flyte/cli/main.py

@@ -6,9 +6,32 @@ from ._abort import abort
 from ._common import CLIConfig
 from ._create import create
 from ._deploy import deploy
+from ._gen import gen
 from ._get import get
 from ._run import run
 
+click.rich_click.COMMAND_GROUPS = {
+    "flyte": [
+        {
+            "name": "Running Workflows",
+            "commands": ["run", "abort"],
+        },
+        {
+            "name": "Management",
+            "commands": ["create", "deploy", "get"],
+        },
+        {
+            "name": "Documentation Generation",
+            "commands": ["gen"],
+        },
+    ]
+}
+
+help_config = click.RichHelpConfiguration(
+    use_markdown=True,
+    use_markdown_emoji=True,
+)
+
 
 def _verbosity_to_loglevel(verbosity: int) -> int | None:
     """
@@ -41,7 +64,7 @@ def _verbosity_to_loglevel(verbosity: int) -> int | None:
     "--insecure/--secure",
     is_flag=True,
     required=False,
-    help="Use insecure connection to the endpoint. If secure is specified, the CLI will use TLS",
+    help="Use insecure connection to the endpoint. If secure is specified, the CLI will use TLS.",
     type=bool,
     default=None,
     show_default=True,
@@ -50,7 +73,7 @@ def _verbosity_to_loglevel(verbosity: int) -> int | None:
     "-v",
     "--verbose",
     required=False,
-    help="Show verbose messages and exception traces",
+    help="Show verbose messages and exception traces, multiple times increases verbosity (e.g., -vvv).",
     count=True,
     default=0,
     type=int,
@@ -70,6 +93,7 @@ def _verbosity_to_loglevel(verbosity: int) -> int | None:
     help="Path to config file (YAML format) to use for the CLI. If not specified,"
     " the default config file will be used.",
 )
+@click.rich_config(help_config=help_config)
 @click.pass_context
 def main(
     ctx: click.Context,
@@ -80,14 +104,35 @@ def main(
     config_file: str | None,
 ):
     """
-
- ____  __    _  _  ____  ____    _  _  ____     __
-(  __)(  )  ( \\/ )(_  _)(  __)  / )( \\(___ \\   /  \
- ) _) / (_/\\ )  /   )(   ) _)   \\ \\/ / / __/ _(  0 )
-(__)  \\____/(__/   (__) (____)   \\__/ (____)(_)\\__/
+    ### Flyte entrypoint for the CLI
+    The Flyte CLI is a command line interface for interacting with Flyte.
 
     The flyte cli follows a simple verb based 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.
+    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 most commands, such as setting the endpoint,
+     organization, and verbosity level.
+
+     Example: Set endpoint and organization
+     ```bash
+      flyte --endpoint <endpoint> --org <org> get project <project_name>
+     ```
+
+     Example: Increase verbosity level (This is useful for debugging, this will show more logs and exception traces)
+      ```bash
+      flyte -vvv get logs <run-name>
+      ```
+
+      Example: Override the default config file
+    ```bash
+    flyte --config /path/to/config.yaml run ...
+    ```
+
+    👉 [Documentation](https://www.union.ai/docs/flyte/user-guide/) \n
+    👉 [GitHub](https://github.com/flyteorg/flyte) - Please leave a ⭐. \n
+    👉 [Slack](https://slack.flyte.org) - Join the community and ask questions.
+    👉 [Issues](https://github.com/flyteorg/flyte/issues)
+
     """
     import flyte.config as config
 
@@ -108,6 +153,7 @@ to be taken, and the subcommands are nouns that describe the object of the actio
         insecure=final_insecure,
         org_override=org or cfg.task.org,
         config=cfg,
+        ctx=ctx,
     )
     logger.debug(f"Final materialized Cli config: {ctx.obj}")
 
@@ -117,3 +163,4 @@ 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

flyte/extras/_container.py

@@ -215,7 +215,7 @@ class ContainerTask(TaskTemplate):
                 output_dict[k] = self._convert_output_val_to_correct_type(output_val, output_type)
         return output_dict
 
-    def execute(self, **kwargs) -> Any:
+    async def execute(self, **kwargs) -> Any:
         try:
             import docker
         except ImportError:

flyte/remote/_run.py

@@ -50,6 +50,7 @@ def _action_rich_repr(action: run_definition_pb2.Action) -> rich.repr.Result:
     """
     Rich representation of the action.
     """
+    yield "run", action.id.run.name
     if action.metadata.HasField("task"):
         yield "task", action.metadata.task.id.name
         yield "type", "task"

flyte/syncify/__init__.py

@@ -1,3 +1,54 @@
+"""
+# Syncify Module
+This module provides the `syncify` decorator and the `Syncify` class.
+The decorator can be used to convert asynchronous functions or methods into synchronous ones.
+This is useful for integrating async code into synchronous contexts.
+
+Every asynchronous function or method wrapped with `syncify` can be called synchronously using the
+parenthesis `()` operator, or asynchronously using the `.aio()` method.
+
+Example::
+
+```python
+from flyte.syncify import syncify
+
+@syncify
+async def async_function(x: str) -> str:
+    return f"Hello, Async World {x}!"
+
+
+# now you can call it synchronously
+result = async_function("Async World")   # Note: no .aio() needed for sync calls
+print(result)
+# Output: Hello, Async World Async World!
+
+# or call it asynchronously
+async def main():
+    result = await async_function.aio("World")    # Note the use of .aio() for async calls
+    print(result)
+```
+
+## Creating a Syncify Instance
+```python
+from flyte.syncify. import Syncify
+
+syncer = Syncify("my_syncer")
+
+# Now you can use `syncer` to decorate your async functions or methods
+
+```
+
+## How does it work?
+The Syncify class wraps asynchronous functions, classmethods, instance methods, and static methods to
+ provide a synchronous interface. The wrapped methods are always executed in the context of a background loop,
+ whether they are called synchronously or asynchronously. This allows for seamless integration of async code, as
+ certain async libraries capture the event loop. An example is grpc.aio, which captures the event loop.
+ In such a case, the Syncify class ensures that the async function is executed in the context of the background loop.
+
+To use it correctly with grpc.aio, you should wrap every grpc.aio channel creation, and client invocation
+with the same `Syncify` instance. This ensures that the async code runs in the correct event loop context.
+"""
+
 from flyte.syncify._api import Syncify
 
 syncify = Syncify()

flyte/syncify/_api.py

@@ -54,14 +54,13 @@ class _BackgroundLoop:
     functions or methods synchronously.
     """
 
-    def __init__(self):
-        self.loop = None
-        self.thread = threading.Thread(name="syncify_bg", target=self._run, daemon=True)
+    def __init__(self, name: str):
+        self.loop = asyncio.new_event_loop()
+        self.thread = threading.Thread(name=name, target=self._run, daemon=True)
         self.thread.start()
         atexit.register(self.stop)
 
     def _run(self):
-        self.loop = asyncio.new_event_loop()
         asyncio.set_event_loop(self.loop)
         self.loop.run_forever()
 
@@ -242,8 +241,8 @@ class Syncify:
 
     """
 
-    def __init__(self):
-        self._bg_loop = _BackgroundLoop()
+    def __init__(self, name: str = "flyte_syncify"):
+        self._bg_loop = _BackgroundLoop(name=name)
 
     @overload
     def __call__(self, func: Callable[P, Awaitable[R_co]]) -> Any: ...

{flyte-0.2.0b7.dist-info → flyte-0.2.0b8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flyte
-Version: 0.2.0b7
+Version: 0.2.0b8
 Summary: Add your description here
 Author-email: Ketan Umare <kumare3@users.noreply.github.com>
 Requires-Python: >=3.10
@@ -24,11 +24,35 @@ Requires-Dist: async-lru>=2.0.5
 Requires-Dist: mashumaro
 Requires-Dist: dataclasses_json
 
-# Flyte 2
+# Flyte 2 SDK
 
-Next-gen of SDK for Flyte.
+The next-generation SDK for Flyte.
 
-## Get started
+## Quickstart
+1. Clone this repo and set `unionv2` to working directory.
+2. Run `uv venv`, and `source .venv/bin/activate` to create a new virtualenv
+3. Install the latest version of the SDK by running the following:
+
+```
+uv pip install --no-cache --prerelease=allow --upgrade flyte
+```
+4. Create the config and point it to the Dogfood GCP cluster by running the following:
+
+```
+flyte create config --endpoint dns:///dogfood-gcp.cloud-staging.union.ai --org dogfood-gcp --project andrew --domain development 
+```
+This will create a `config.yaml` file in the current directory which will be referenced ahead of any other `config.yaml`s found in your system.
+
+5. Now you can run stuff with the CLI:
+
+```
+flyte run --follow examples/basics/devbox_one.py say_hello_nested
+```
+Note that the `--follow` command is optional. Use this to stream updates to the terminal!
+
+
+
+## Hello World Example
 
 1. Only async tasks are supported right now. Style recommended, `import flyte` and then `flyte.TaskEnvironment` etc
 2. You have to create environment for even a single task

{flyte-0.2.0b7.dist-info → flyte-0.2.0b8.dist-info}/RECORD

@@ -4,10 +4,10 @@ flyte/_context.py,sha256=pYa43ut8gp6i-Y_zOy1WW_N2IbP9Vd-zIORO11vqK1E,4995
 flyte/_deploy.py,sha256=hHZKLU3U7t1ZF_8x6LykkPu_KSDyaHL3f2WzyjLj9BQ,7723
 flyte/_doc.py,sha256=_OPCf3t_git6UT7kSJISFaWO9cfNzJhhoe6JjVdyCJo,706
 flyte/_docstring.py,sha256=SsG0Ab_YMAwy2ABJlEo3eBKlyC3kwPdnDJ1FIms-ZBQ,1127
-flyte/_environment.py,sha256=ft0EsyFg6OnoIFPFbwkABLcq676veIH3TTR4SNilrj8,1499
+flyte/_environment.py,sha256=BkChtdVhWB3SwMSvetDZ-KiNBgRFlAXgq69PHT4zyG0,2942
 flyte/_group.py,sha256=64q2GFDp3koIkx3IV4GBeGEbu4v-GPUxTlxU_sV2fPk,743
 flyte/_hash.py,sha256=Of_Zl_DzzzF2jp4ZsLm-3o-xJFCCJ8_GubmLI1htx78,504
-flyte/_image.py,sha256=8xEGmAALY6jQAsLfJQH9NweeVUaSTWivFEQt-JchN24,29068
+flyte/_image.py,sha256=NeBvjCdwFAVGd666ufi1q-YOvhwdTEzAeJl5YBfl0bI,29043
 flyte/_initialize.py,sha256=ihTIvoMHs67UKbtFLR_zy9M1e7OK26ywoc_yMfLYwMw,16499
 flyte/_interface.py,sha256=MP5o_qpIwfBNtAc7zo_cLSjMugsPyanuO6EgUSk4fBE,3644
 flyte/_logging.py,sha256=FQvF3W1kkFypbARcOQ7WZVXO0XJasXp8EhozF6E6-aQ,3379
@@ -16,12 +16,12 @@ flyte/_retry.py,sha256=rfLv0MvWxzPByKESTglEmjPsytEAKiIvvmzlJxXwsfE,941
 flyte/_reusable_environment.py,sha256=P4FBATVKAYcIKpdFN98sI8acPyKy8eIGx6V0kUb9YdM,1289
 flyte/_run.py,sha256=2ugAk4tpvSAnNAlfhx4YysSrdFoce-hZHQ6XMHYxp0A,17783
 flyte/_secret.py,sha256=SqIHs6mi8hEkIIBZe3bI9jJsPt65Mt6dV5uh9_op1ME,2392
-flyte/_task.py,sha256=cqWfbMDMkEg1Q0sOkaSi1h_9Vn81DbGCOgNFZo8bMfI,14622
-flyte/_task_environment.py,sha256=svSJJMEiiYsqz403s_urMgPdjguHJJSGVuBobT3uwVo,8403
+flyte/_task.py,sha256=UDsnSs0lYXZe-0HvZHk4FQ5X9DGRyy1qldm7zpUEXT4,16373
+flyte/_task_environment.py,sha256=J1LFH9Zz1nPhlsrc_rYny1SS3QC1b55X7tRYoTG7Vk4,6815
 flyte/_timeout.py,sha256=zx5sFcbYmjJAJbZWSGzzX-BpC9HC7Jfs35T7vVhKwkk,1571
 flyte/_tools.py,sha256=JewkQZBR_M85tS6QY8e4xXue75jbOE48nID4ZHnc9jY,632
 flyte/_trace.py,sha256=7OQtQNosIlycTwaMjdc3GW4h3T3N0bYTsY6og4clPl8,5234
-flyte/_version.py,sha256=aew4sh3XJsC-oHvLUBV1yrPYnRPf3pvzP7MaVQdQXzs,519
+flyte/_version.py,sha256=vlbuxWySGV761QhtXKWRtZJy0eos4BpfR3ZShXEd4sQ,519
 flyte/errors.py,sha256=m2JUNqLC6anVW6UiDK_ihuA06q_Hkw1mIUMDskb2OW8,4289
 flyte/models.py,sha256=GTRuR6GXc0RAbLmPEnnH54oRF7__2TNFhmYjFoYMjZA,12660
 flyte/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -37,15 +37,15 @@ flyte/_code_bundle/_packaging.py,sha256=_wEozcQTYgqvAAaKQYna9ptvShIMlXk3vEdccwAO
 flyte/_code_bundle/_utils.py,sha256=b0s3ZVKSRwaa_2CMTCqt2iRrUvTTW3FmlyqCD9k5BS0,12028
 flyte/_code_bundle/bundle.py,sha256=8T0gcXck6dmg-8L2-0G3B2iNjC-Xwydu806iyKneMMY,8789
 flyte/_internal/__init__.py,sha256=vjXgGzAAjy609YFkAy9_RVPuUlslsHSJBXCLNTVnqOY,136
-flyte/_internal/controllers/__init__.py,sha256=qaawXUgYdC5yHh5JfQ9mCH3u9a7oTYriDChADekzuzo,3750
-flyte/_internal/controllers/_local_controller.py,sha256=wTrJitUZMKodvvZMiy4bQbmIv0doF8Pb-OCsa8lAHgA,4708
+flyte/_internal/controllers/__init__.py,sha256=wPugf6_9BUVqwCXClnmScwyKVaGYIo0PTd-sdYjxVWA,3827
+flyte/_internal/controllers/_local_controller.py,sha256=fT-mFBs05vxHf43U24AKGJg5NuSTO5F8LBRcZAfgX2g,4798
 flyte/_internal/controllers/_trace.py,sha256=Ga2b65sn9q2IoOwHBZV2inMYyO6-CSDwzN7E3pDxsEI,1126
 flyte/_internal/controllers/remote/__init__.py,sha256=9_azH1eHLqY6VULpDugXi7Kf1kK1ODqEnsQ_3wM6IqU,1919
 flyte/_internal/controllers/remote/_action.py,sha256=w6vE1vPz1BwxvwfotDWjTNbDXfGEPrRBA8N3UVQ6P0w,4905
 flyte/_internal/controllers/remote/_client.py,sha256=HPbzbfaWZVv5wpOvKNtFXR6COiZDwd1cUJQqi60A7oU,1421
-flyte/_internal/controllers/remote/_controller.py,sha256=uqZYQDGG70DeJiqAU4y7n7VhXQ0gvD4ktWu15-zg86I,17387
+flyte/_internal/controllers/remote/_controller.py,sha256=5jhm6UG3DLCUiwQMkVGeIF4pIx_cZkR9it6tLMK7DRw,17477
 flyte/_internal/controllers/remote/_core.py,sha256=2dka1rDnA8Ui_qhfE1ymZuN8E2BYQPn123h_eMixSiM,18091
-flyte/_internal/controllers/remote/_informer.py,sha256=6WPaT1EmDcIwQ3VlujGWICzHy-kaGhMut_zBh2ShZnE,14186
+flyte/_internal/controllers/remote/_informer.py,sha256=JC35aHbEdwBN7cwDKbQj6koPUypTapYyK0wKxOBRBCo,14191
 flyte/_internal/controllers/remote/_service_protocol.py,sha256=B9qbIg6DiGeac-iSccLmX_AL2xUgX4ezNUOiAbSy4V0,1357
 flyte/_internal/imagebuild/__init__.py,sha256=cLXVxkAyFpbdC1y-k3Rb6FRW9f_xpoRQWVn__G9IqKs,354
 flyte/_internal/imagebuild/docker_builder.py,sha256=bkr2fs9jInTq8jqU8ka7NGvp0RPfYhbTfX1RqtqTvvs,13986
@@ -129,28 +129,29 @@ flyte/_protos/workflow/task_service_pb2_grpc.py,sha256=PdhEfPraBIeN-UQulZsA2D0on
 flyte/_utils/__init__.py,sha256=ZlVA1bLeAEnzwbkK7eEVAVmeVQnbBCuGqfd2UIk-yNc,599
 flyte/_utils/asyn.py,sha256=KeJKarXNIyD16g6oPM0T9cH7JDmh1KY7JLbwo7i0IlQ,3673
 flyte/_utils/async_cache.py,sha256=JtZJmWO62OowJ0QFNl6wryWqh-kuDi76aAASMie87QY,4596
-flyte/_utils/coro_management.py,sha256=hlWzxdrsBYfUwzQS7qtltclG56XPxBMNgWE5lkuYdrY,760
+flyte/_utils/coro_management.py,sha256=_JTt9x9fOc_1OSe03DSheYoKOvlonBB_4WNCS9XSaoU,698
 flyte/_utils/file_handling.py,sha256=iU4TxW--fCho_Eg5xTMODn96P03SxzF-V-5f-7bZAZY,2233
 flyte/_utils/helpers.py,sha256=Ntrs1WilJS7a4oLmcIPLXMi0cuzRDiCr_wwgtpV30uk,3953
 flyte/_utils/lazy_module.py,sha256=fvXPjvZLzCfcI8Vzs4pKedUDdY0U_RQ1ZVrp9b8qBQY,1994
 flyte/_utils/uv_script_parser.py,sha256=PxqD8lSMi6xv0uDd1s8LKB2IPZr4ttZJCUweqlyMTKk,1483
 flyte/cli/__init__.py,sha256=Hx_mrERToVkrvORPB56ZnUED86T4S50ac1nwLQfvsgo,278
 flyte/cli/_abort.py,sha256=WkXmjAOcrBU9NXXndcwF7YW7QcUTJzyUrvIRW0fjpSE,580
-flyte/cli/_common.py,sha256=u9Vf4VR601cEawlKw-o9bJJuQVNlLMMsFgCTWl-umU4,10748
-flyte/cli/_create.py,sha256=8g9LgrjhpJiusUkmWeIRB3XviTVmMfo1dGCEt8Hna00,2377
-flyte/cli/_delete.py,sha256=xOZN7Y13AQjAEQvdEod9qk1MQPU9l7bjQCkYzf_l4uY,497
-flyte/cli/_deploy.py,sha256=u30rb6KfZnr52M6zHlLueaOkgdCGoS2pIpfb0wFoTvY,4371
-flyte/cli/_get.py,sha256=u5PNAeJTPkGzdcz5gd2oiFrNvIfm8oRGK3MsjyY4Dzc,7553
+flyte/cli/_common.py,sha256=KSn6MxJng_WJDrA20Wl_RKWiCcqZ7ZS68UFlqYyR7xs,10771
+flyte/cli/_create.py,sha256=bB_kkM54LLWVBaAy8LKPJGfLjC3NSIDELB8niQlG50c,3667
+flyte/cli/_delete.py,sha256=WnHn9m_1b3nAXaD772bOirsN73ICUi-BVzjFP8s_Hyg,581
+flyte/cli/_deploy.py,sha256=zCHvy88UPYz_iXXG7b9Pi61GFdB52-niYw2pVIum2b4,4464
+flyte/cli/_gen.py,sha256=onJIXj2PiJxxHCOFo5A9LNwjt-rRo-a_SojdtuvQ5is,5302
+flyte/cli/_get.py,sha256=f5e8h6P6LBBPNZKHEx8aYeoym_Bih7eIsxqiAqAHtso,9641
 flyte/cli/_params.py,sha256=X3GpuftXmtfIsYQ7vBilD4kmlkXTc7_AxpaxohRjSuY,19458
-flyte/cli/_run.py,sha256=F8Io2WB4dGHvNWbCmvCtyx4YGQhmoCAxeARwAwNSn78,7150
-flyte/cli/main.py,sha256=1-Qm3IAPIRQSKaWVL1iGajiJoOO0mRqJsRnNtfd_uw4,3064
+flyte/cli/_run.py,sha256=zRu4DTO__BVsLgpSLUbYR1Twvzc_2zivUhcviymCRf0,7884
+flyte/cli/main.py,sha256=PhH8RgpNFP9owpjN8purGvM41qlm9VcR2QF2oLi_6FA,4480
 flyte/config/__init__.py,sha256=MiwEYK5Iv7MRR22z61nzbsbvZ9Q6MdmAU_g9If1Pmb8,144
 flyte/config/_config.py,sha256=QE3T0W8xOULjJaqDMdMF90f9gFVjGR6h8QPOLsyqjYw,9831
 flyte/config/_internal.py,sha256=Bj0uzn3PYgxKbzM-q2GKXxp7Y6cyzhPzUB-Y2i6cQKo,2836
 flyte/config/_reader.py,sha256=c16jm0_IYxwEAjXENtllLeO_sT5Eg2RNLG4UjnAv_x4,7157
 flyte/connectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 flyte/extras/__init__.py,sha256=FhB0uK7H1Yo5De9vOuF7UGnezTKncj3u2Wo5uQdWN0g,74
-flyte/extras/_container.py,sha256=JM-JNsj9-Mjf7E4OQcAS2Z5IJBXhB-HtQkGn_mu7gvk,11249
+flyte/extras/_container.py,sha256=R7tMIy2EuprEGowYhjPMwnszSutgWIzAeKPeXNc2nmI,11255
 flyte/io/__init__.py,sha256=e2wHVEoZ84TGOtOPrtTg6hJpeuxiYI56Sg011yq6nUQ,236
 flyte/io/_dataframe.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 flyte/io/_dir.py,sha256=rih9CY1YjNX05bcAu5LG62Xoyij5GXAlv7jLyVF0je8,15310
@@ -165,7 +166,7 @@ flyte/remote/_console.py,sha256=avmELJPx8nQMAVPrHlh6jEIRPjrMwFpdZjJsWOOa9rE,660
 flyte/remote/_data.py,sha256=DPK85gB6M71RjxqIh1Q5PdZ9xcJ0m1w_3cT2lAO0r7w,5795
 flyte/remote/_logs.py,sha256=EOXg4OS8yYclsT6NASgOLMo0TA2sZpKb2MWZXpWBPuI,6404
 flyte/remote/_project.py,sha256=dTBYqORDAbLvh9WnPO1Ytuzw2vxNYZwwNsKE2_b0o14,2807
-flyte/remote/_run.py,sha256=Dk7LQaB_edxSd6H93H-khjeZKXT76PgHPSLKIuGJQfw,31021
+flyte/remote/_run.py,sha256=9euHjYRX-xyxXuhn0MunYb9dmgl0FMU3a-FZNjJA4F8,31057
 flyte/remote/_secret.py,sha256=l5xeMS83uMcWWeSSTRsSZUNhS0N--1Dze09C-thSOQs,4341
 flyte/remote/_task.py,sha256=6TBdjPWgxHmdY9OJMMPGZax8h7Qs7q9dprNktjnZ77E,7904
 flyte/remote/_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -197,16 +198,16 @@ flyte/storage/_config.py,sha256=xVibWJaioOnkeTb_M30azgiUe1jvmQaOWRZEkpdoTao,8680
 flyte/storage/_remote_fs.py,sha256=kM_iszbccjVD5VtVdgfkl1FHS8NPnY__JOo_CPQUE4c,1124
 flyte/storage/_storage.py,sha256=mBy7MKII2M1UTVm_EUUDwVb7uT1_AOPzQr2wCJ-fgW0,9873
 flyte/storage/_utils.py,sha256=8oLCM-7D7JyJhzUi1_Q1NFx8GBUPRfou0T_5tPBmPbE,309
-flyte/syncify/__init__.py,sha256=tmGOUw3XvDXpaxQk95oRmUTObcIzjEvBFaceSzrXATU,94
-flyte/syncify/_api.py,sha256=Ayq9xzb1IJJrlHuTJ160C3k7tdrAjhX4z-FgQM-3T8M,9799
+flyte/syncify/__init__.py,sha256=WgTk-v-SntULnI55CsVy71cxGJ9Q6pxpTrhbPFuouJ0,1974
+flyte/syncify/_api.py,sha256=Jek0sIpu6RyOCAYQZFxuW-xv_lpr6DBOjs2kGA8tfvc,9815
 flyte/types/__init__.py,sha256=xMIYOolT3Vq0qXy7unw90IVdYztdMDpKg0oG0XAPC9o,364
 flyte/types/_interface.py,sha256=mY7mb8v2hJPGk7AU99gdOWl4_jArA1VFtjYGlE31SK0,953
 flyte/types/_renderer.py,sha256=ygcCo5l60lHufyQISFddZfWwLlQ8kJAKxUT_XnR_6dY,4818
 flyte/types/_string_literals.py,sha256=NlG1xV8RSA-sZ-n-IFQCAsdB6jXJOAKkHWtnopxVVDk,4231
 flyte/types/_type_engine.py,sha256=QxyoDWRG_whfLCz88YqEVVoTTnca0FZv9eHeLLT0_-s,93645
 flyte/types/_utils.py,sha256=pbts9E1_2LTdLygAY0UYTLYJ8AsN3BZyviSXvrtcutc,2626
-flyte-0.2.0b7.dist-info/METADATA,sha256=PEzzLl143Af5aF5AtaQFINAedUl2-txdzh36uHWd6fQ,3751
-flyte-0.2.0b7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-flyte-0.2.0b7.dist-info/entry_points.txt,sha256=MIq2z5dBurdCJfpXfMKzgBv7sJOakKRYxr8G0cMiTrg,75
-flyte-0.2.0b7.dist-info/top_level.txt,sha256=7dkyFbikvA12LEZEqawx8oDG1CMod6hTliPj7iWzgYo,6
-flyte-0.2.0b7.dist-info/RECORD,,
+flyte-0.2.0b8.dist-info/METADATA,sha256=143TeXr4H7BtrVp2r0GwVQ0jviOe8S5fXn3t1s439wY,4636
+flyte-0.2.0b8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+flyte-0.2.0b8.dist-info/entry_points.txt,sha256=MIq2z5dBurdCJfpXfMKzgBv7sJOakKRYxr8G0cMiTrg,75
+flyte-0.2.0b8.dist-info/top_level.txt,sha256=7dkyFbikvA12LEZEqawx8oDG1CMod6hTliPj7iWzgYo,6
+flyte-0.2.0b8.dist-info/RECORD,,