flyte 2.0.0b5__py3-none-any.whl → 2.0.0b7__py3-none-any.whl

flyte/_bin/runtime.py

@@ -26,7 +26,6 @@ DOMAIN_NAME = "FLYTE_INTERNAL_TASK_DOMAIN"
 ORG_NAME = "_U_ORG_NAME"
 ENDPOINT_OVERRIDE = "_U_EP_OVERRIDE"
 RUN_OUTPUT_BASE_DIR = "_U_RUN_BASE"
-ENABLE_REF_TASKS = "_REF_TASKS"  # This is a temporary flag to enable reference tasks in the runtime.
 
 # TODO: Remove this after proper auth is implemented
 _UNION_EAGER_API_KEY_ENV_VAR = "_UNION_EAGER_API_KEY"
@@ -87,6 +86,7 @@ def main(
 
     import flyte
     import flyte._utils as utils
+    import flyte.errors
     from flyte._initialize import init
     from flyte._internal.controllers import create_controller
     from flyte._internal.imagebuild.image_builder import ImageCache
@@ -123,22 +123,7 @@ def main(
         logger.debug(f"Using controller endpoint: {ep} with kwargs: {controller_kwargs}")
 
     bundle = CodeBundle(tgz=tgz, pkl=pkl, destination=dest, computed_version=version)
-    enable_ref_tasks = os.getenv(ENABLE_REF_TASKS, "false").lower() in ("true", "1", "yes")
-    # We init regular client here so that reference tasks can work
-    # Current reference tasks will not work with remote controller, because we create 2 different
-    # channels on different threads and this is not supported by grpcio or the auth system. It ends up leading
-    # File "src/python/grpcio/grpc/_cython/_cygrpc/aio/completion_queue.pyx.pxi", line 147,
-    # in grpc._cython.cygrpc.PollerCompletionQueue._handle_events
-    # BlockingIOError: [Errno 11] Resource temporarily unavailable
-    # TODO solution is to use a single channel for both controller and reference tasks, but this requires a refactor
-    if enable_ref_tasks:
-        logger.warning(
-            "Reference tasks are enabled. This will initialize client and you will see a BlockIOError. "
-            "This is harmless, but a nuisance. We are working on a fix."
-        )
-        init(org=org, project=project, domain=domain, **controller_kwargs)
-    else:
-        init()
+    init(org=org, project=project, domain=domain, **controller_kwargs)
     # Controller is created with the same kwargs as init, so that it can be used to run tasks
     controller = create_controller(ct="remote", **controller_kwargs)
 
@@ -164,6 +149,8 @@ def main(
 
     # Run both coroutines concurrently and wait for first to finish and cancel the other
     async def _run_and_stop():
+        loop = asyncio.get_event_loop()
+        loop.set_exception_handler(flyte.errors.silence_grpc_polling_error)
         await utils.run_coros(controller_failure, task_coroutine)
         await controller.stop()
 

flyte/_cache/cache.py

@@ -21,7 +21,7 @@ from flyte.models import CodeBundle
 P = ParamSpec("P")
 FuncOut = TypeVar("FuncOut")
 
-CacheBehavior = Literal["auto", "override", "disable", "enabled"]
+CacheBehavior = Literal["auto", "override", "disable"]
 
 
 @dataclass

flyte/_deploy.py

@@ -5,7 +5,6 @@ import typing
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
 
-import grpc.aio
 import rich.repr
 
 import flyte.errors
@@ -86,6 +85,8 @@ async def _deploy_task(
     Deploy the given task.
     """
     ensure_client()
+    import grpc.aio
+
     from ._internal.runtime.convert import convert_upload_default_inputs
     from ._internal.runtime.task_serde import translate_task_to_wire
     from ._protos.workflow import task_definition_pb2, task_service_pb2

flyte/_image.py

@@ -5,10 +5,10 @@ import hashlib
 import sys
 import typing
 from abc import abstractmethod
-from dataclasses import asdict, dataclass, field
+from dataclasses import asdict, dataclass, field, fields
 from functools import cached_property
 from pathlib import Path
-from typing import TYPE_CHECKING, Callable, ClassVar, Dict, List, Literal, Optional, Tuple, TypeVar, Union
+from typing import TYPE_CHECKING, ClassVar, Dict, List, Literal, Optional, Tuple, TypeVar, Union
 
 import rich.repr
 from packaging.version import Version
@@ -49,8 +49,6 @@ class Layer:
      layered images programmatically.
     """
 
-    _compute_identifier: Callable[[Layer], str] = field(default=lambda x: x.__str__(), init=True)
-
     @abstractmethod
     def update_hash(self, hasher: hashlib._Hash):
         """
@@ -66,6 +64,27 @@ class Layer:
         :return:
         """
 
+    def identifier(self) -> str:
+        """
+        This method computes a unique identifier for the layer based on its properties.
+        It is used to identify the layer in the image cache.
+
+        It is also used to compute a unique identifier for the image itself, which is a combination of all the layers.
+        This identifier is used to look up previously built images in the image cache. So having a consistent
+        identifier is important for the image cache to work correctly.
+
+        :return: A unique identifier for the layer.
+        """
+        ignore_fields: list[str] = []
+        for f in fields(self):
+            if f.metadata.get("identifier", True) is False:
+                ignore_fields.append(f.name)
+        d = asdict(self)
+        for v in ignore_fields:
+            d.pop(v)
+
+        return str(d)
+
 
 @rich.repr.auto
 @dataclass(kw_only=True, frozen=True, repr=True)
@@ -133,7 +152,11 @@ class PipPackages(PipOption, Layer):
 @rich.repr.auto
 @dataclass(kw_only=True, frozen=True, repr=True)
 class PythonWheels(PipOption, Layer):
-    wheel_dir: Path
+    wheel_dir: Path = field(metadata={"identifier": False})
+    wheel_dir_name: str = field(init=False)
+
+    def __post_init__(self):
+        object.__setattr__(self, "wheel_dir_name", self.wheel_dir.name)
 
     def update_hash(self, hasher: hashlib._Hash):
         super().update_hash(hasher)
@@ -184,7 +207,11 @@ class UVProject(PipOption, Layer):
 @rich.repr.auto
 @dataclass(frozen=True, repr=True)
 class UVScript(PipOption, Layer):
-    script: Path
+    script: Path = field(metadata={"identifier": False})
+    script_name: str = field(init=False)
+
+    def __post_init__(self):
+        object.__setattr__(self, "script_name", self.script.name)
 
     def validate(self):
         if not self.script.exists():
@@ -196,10 +223,13 @@ class UVScript(PipOption, Layer):
         super().validate()
 
     def update_hash(self, hasher: hashlib._Hash):
-        from ._utils import filehash_update
+        from ._utils import parse_uv_script_file
 
+        header = parse_uv_script_file(self.script)
+        h_tuple = _ensure_tuple(header)
+        if h_tuple:
+            hasher.update(h_tuple.__str__().encode("utf-8"))
         super().update_hash(hasher)
-        filehash_update(self.script, hasher)
 
 
 @rich.repr.auto
@@ -247,9 +277,15 @@ class DockerIgnore(Layer):
 @rich.repr.auto
 @dataclass(frozen=True, repr=True)
 class CopyConfig(Layer):
-    path_type: CopyConfigType
-    src: Path
-    dst: str = "."
+    path_type: CopyConfigType = field(metadata={"identifier": True})
+    src: Path = field(metadata={"identifier": True})
+    dst: str
+    src_name: str = field(init=False)
+
+    def __post_init__(self):
+        if self.path_type not in (0, 1):
+            raise ValueError(f"Invalid path_type {self.path_type}, must be 0 (file) or 1 (directory)")
+        object.__setattr__(self, "src_name", self.src.name)
 
     def validate(self):
         if not self.src.exists():
@@ -393,7 +429,7 @@ class Image:
         # across different SDK versions.
         # Layers can specify a _compute_identifier optionally, but the default will just stringify
         image_dict = asdict(self, dict_factory=lambda x: {k: v for (k, v) in x if v is not None and k != "_layers"})
-        layers_str_repr = "".join([layer._compute_identifier(layer) for layer in self._layers])
+        layers_str_repr = "".join([layer.identifier() for layer in self._layers])
         image_dict["layers"] = layers_str_repr
         spec_bytes = image_dict.__str__().encode("utf-8")
         return base64.urlsafe_b64encode(hashlib.md5(spec_bytes).digest()).decode("ascii").rstrip("=")
@@ -430,6 +466,7 @@ class Image:
             base_image=f"python:{python_version[0]}.{python_version[1]}-slim-bookworm",
             registry=_BASE_REGISTRY,
             name=_DEFAULT_IMAGE_NAME,
+            python_version=python_version,
             platform=("linux/amd64", "linux/arm64") if platform is None else platform,
         )
         labels_and_user = _DockerLines(
@@ -572,8 +609,12 @@ class Image:
         :param extra_index_urls: extra index urls to use for pip install, default is None
         :param pre: whether to allow pre-release versions, default is False
         :param extra_args: extra arguments to pass to pip install, default is None
+        :param secret_mounts: Secret mounts to use for the image, default is None.
 
         :return: Image
+
+        Args:
+            secret_mounts:
         """
         ll = UVScript(
             script=Path(script),
@@ -801,7 +842,7 @@ class Image:
         :param dst: destination folder in the image
         :return: Image
         """
-        new_image = self.clone(addl_layer=CopyConfig(path_type=1, src=src, dst=dst, _compute_identifier=lambda x: dst))
+        new_image = self.clone(addl_layer=CopyConfig(path_type=1, src=src, dst=dst))
         return new_image
 
     def with_source_file(self, src: Path, dst: str = ".") -> Image:
@@ -813,7 +854,7 @@ class Image:
         :param dst: destination folder in the image
         :return: Image
         """
-        new_image = self.clone(addl_layer=CopyConfig(path_type=0, src=src, dst=dst, _compute_identifier=lambda x: dst))
+        new_image = self.clone(addl_layer=CopyConfig(path_type=0, src=src, dst=dst))
         return new_image
 
     def with_dockerignore(self, path: Path) -> Image:
@@ -899,7 +940,7 @@ class Image:
         dist_folder = Path(__file__).parent.parent.parent / "dist"
         # Manually declare the PythonWheel so we can set the hashing
         # used to compute the identifier. Can remove if we ever decide to expose the lambda in with_ commands
-        with_dist = self.clone(addl_layer=PythonWheels(wheel_dir=dist_folder, _compute_identifier=lambda x: "/dist"))
+        with_dist = self.clone(addl_layer=PythonWheels(wheel_dir=dist_folder))
 
         return with_dist
 

flyte/_internal/controllers/remote/_controller.py

@@ -253,6 +253,21 @@ class RemoteController(Controller):
             await self.cancel_action(action)
             raise
 
+        # If the action is aborted, we should abort the controller as well
+        if n.phase == run_definition_pb2.PHASE_ABORTED:
+            logger.warning(f"Action {n.action_id.name} was aborted, aborting current Action{current_action_id.name}")
+            raise flyte.errors.RunAbortedError(
+                f"Action {n.action_id.name} was aborted, aborting current Action {current_action_id.name}"
+            )
+
+        if n.phase == run_definition_pb2.PHASE_TIMED_OUT:
+            logger.warning(
+                f"Action {n.action_id.name} timed out, raising timeout exception Action {current_action_id.name}"
+            )
+            raise flyte.errors.TaskTimeoutError(
+                f"Action {n.action_id.name} timed out, raising exception in current Action {current_action_id.name}"
+            )
+
         if n.has_error() or n.phase == run_definition_pb2.PHASE_FAILED:
             exc = await handle_action_failure(action, _task.name)
             raise exc

flyte/_internal/controllers/remote/_core.py

@@ -16,7 +16,6 @@ from flyte._protos.workflow import (
     queue_service_pb2,
     task_definition_pb2,
 )
-from flyte.errors import RuntimeSystemError
 
 from ._action import Action
 from ._informer import InformerCache
@@ -125,7 +124,7 @@ class Controller:
     async def watch_for_errors(self):
         """Watch for errors in the background thread"""
         await self._run_coroutine_in_controller_thread(self._bg_watch_for_errors())
-        raise RuntimeSystemError(
+        raise flyte.errors.RuntimeSystemError(
             code="InformerWatchFailure",
             message=f"Controller thread failed with exception: {self._get_exception()}",
         )
@@ -164,7 +163,7 @@ class Controller:
             raise TimeoutError("Controller thread failed to start in time")
 
         if self._get_exception():
-            raise RuntimeSystemError(
+            raise flyte.errors.RuntimeSystemError(
                 type(self._get_exception()).__name__,
                 f"Controller thread startup failed: {self._get_exception()}",
             )
@@ -212,6 +211,7 @@ class Controller:
             # Create a new event loop for this thread
             self._loop = asyncio.new_event_loop()
             asyncio.set_event_loop(self._loop)
+            self._loop.set_exception_handler(flyte.errors.silence_grpc_polling_error)
             logger.debug(f"Controller thread started with new event loop: {threading.current_thread().name}")
 
             # Create an event to signal the errors were observed in the thread's loop

flyte/_internal/runtime/rusty.py

@@ -1,4 +1,6 @@
+import asyncio
 import sys
+import time
 from typing import Any, List, Tuple
 
 from flyte._context import contextual_run
@@ -75,19 +77,23 @@ async def create_controller(
     :return:
     """
     logger.info(f"[rusty] Creating controller with endpoint {endpoint}")
+    import flyte.errors
     from flyte._initialize import init
 
-    # TODO Currently refrence tasks are not supported in Rusty.
+    loop = asyncio.get_event_loop()
+    loop.set_exception_handler(flyte.errors.silence_grpc_polling_error)
+
+    # TODO Currently reference tasks are not supported in Rusty.
     await init.aio()
     controller_kwargs: dict[str, Any] = {"insecure": insecure}
     if api_key:
-        logger.info("Using api key from environment")
+        logger.info("[rusty] Using api key from environment")
         controller_kwargs["api_key"] = api_key
     else:
         controller_kwargs["endpoint"] = endpoint
         if "localhost" in endpoint or "docker" in endpoint:
             controller_kwargs["insecure"] = True
-        logger.debug(f"Using controller endpoint: {endpoint} with kwargs: {controller_kwargs}")
+        logger.debug(f"[rusty] Using controller endpoint: {endpoint} with kwargs: {controller_kwargs}")
 
     return _create_controller(ct="remote", **controller_kwargs)
 
@@ -130,22 +136,39 @@ async def run_task(
     :param input_path: Optional input path for the task.
     :return: The loaded task template.
     """
-    logger.info(f"[rusty] Running task {task.name}")
-    await contextual_run(
-        extract_download_run_upload,
-        task,
-        action=ActionID(name=name, org=org, project=project, domain=domain, run_name=run_name),
-        version=version,
-        controller=controller,
-        raw_data_path=RawDataPath(path=raw_data_path),
-        output_path=output_path,
-        run_base_dir=run_base_dir,
-        checkpoints=Checkpoints(prev_checkpoint_path=prev_checkpoint, checkpoint_path=checkpoint_path),
-        code_bundle=code_bundle,
-        input_path=input_path,
-        image_cache=ImageCache.from_transport(image_cache) if image_cache else None,
+    start_time = time.time()
+    action_id = f"{org}/{project}/{domain}/{run_name}/{name}"
+
+    logger.info(
+        f"[rusty] Running task '{task.name}' (action: {action_id})"
+        f" at {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(start_time))}"
     )
-    logger.info(f"[rusty] Finished task {task.name}")
+
+    try:
+        await contextual_run(
+            extract_download_run_upload,
+            task,
+            action=ActionID(name=name, org=org, project=project, domain=domain, run_name=run_name),
+            version=version,
+            controller=controller,
+            raw_data_path=RawDataPath(path=raw_data_path),
+            output_path=output_path,
+            run_base_dir=run_base_dir,
+            checkpoints=Checkpoints(prev_checkpoint_path=prev_checkpoint, checkpoint_path=checkpoint_path),
+            code_bundle=code_bundle,
+            input_path=input_path,
+            image_cache=ImageCache.from_transport(image_cache) if image_cache else None,
+        )
+    except Exception as e:
+        logger.error(f"[rusty] Task failed: {e!s}")
+        raise
+    finally:
+        end_time = time.time()
+        duration = end_time - start_time
+        logger.info(
+            f"[rusty] TASK_EXECUTION_END: Task '{task.name}' (action: {action_id})"
+            f" done after {duration:.2f}s at {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(end_time))}"
+        )
 
 
 async def ping(name: str) -> str:

flyte/_run.py

@@ -18,7 +18,6 @@ from flyte._initialize import (
     requires_storage,
 )
 from flyte._logging import logger
-from flyte._protos.common import identifier_pb2
 from flyte._task import P, R, TaskTemplate
 from flyte._tools import ipython_check
 from flyte.errors import InitializationError
@@ -411,6 +410,7 @@ class _Runner:
     async def _run_local(self, obj: TaskTemplate[P, R], *args: P.args, **kwargs: P.kwargs) -> Run:
         from flyte._internal.controllers import create_controller
         from flyte._internal.controllers._local_controller import LocalController
+        from flyte._protos.common import identifier_pb2
         from flyte.remote import Run
         from flyte.report import Report
 

flyte/_task_environment.py

@@ -62,7 +62,7 @@ class TaskEnvironment(Environment):
     :param reusable: Reuse policy for the environment, if set, a python process may be reused for multiple tasks.
     """
 
-    cache: Union[CacheRequest] = "disable"
+    cache: CacheRequest = "disable"
     reusable: ReusePolicy | None = None
     plugin_config: Optional[Any] = None
     # TODO Shall we make this union of string or env? This way we can lookup the env by module/file:name
@@ -134,7 +134,7 @@ class TaskEnvironment(Environment):
         _func=None,
         *,
         name: Optional[str] = None,
-        cache: Union[CacheRequest] | None = None,
+        cache: CacheRequest | None = None,
         retries: Union[int, RetryStrategy] = 0,
         timeout: Union[timedelta, int] = 0,
         docs: Optional[Documentation] = None,

flyte/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '2.0.0b5'
-__version_tuple__ = version_tuple = (2, 0, 0, 'b5')
+__version__ = version = '2.0.0b7'
+__version_tuple__ = version_tuple = (2, 0, 0, 'b7')
+
+__commit_id__ = commit_id = 'g5cfd1e5ec'

flyte/cli/_build.py

@@ -54,7 +54,7 @@ class BuildEnvCommand(click.Command):
         with console.status("Building...", spinner="dots"):
             image_cache = flyte.build_images(self.obj)
 
-        console.print(common.get_table("Images", image_cache.repr(), simple=obj.simple))
+        console.print(common.format("Images", image_cache.repr(), obj.output_format))
 
 
 class EnvPerFileGroup(common.ObjectsPerFileGroup):

flyte/cli/_common.py

@@ -8,19 +8,22 @@ from abc import abstractmethod
 from dataclasses import dataclass, replace
 from pathlib import Path
 from types import MappingProxyType, ModuleType
-from typing import Any, Dict, Iterable, List, Optional
+from typing import Any, Dict, Iterable, List, Literal, Optional
 
 import rich.box
 import rich.repr
 import rich_click as click
 from rich.console import Console
 from rich.panel import Panel
+from rich.pretty import pretty_repr
 from rich.table import Table
 from rich.traceback import Traceback
 
 import flyte.errors
 from flyte.config import Config
 
+OutputFormat = Literal["table", "json", "table-simple"]
+
 PREFERRED_BORDER_COLOR = "dim cyan"
 PREFERRED_ACCENT_COLOR = "bold #FFD700"
 HEADER_STYLE = f"{PREFERRED_ACCENT_COLOR} on black"
@@ -99,8 +102,8 @@ class CLIConfig:
     endpoint: str | None = None
     insecure: bool = False
     org: str | None = None
-    simple: bool = False
     auth_type: str | None = None
+    output_format: OutputFormat = "table"
 
     def replace(self, **kwargs) -> CLIConfig:
         """
@@ -327,20 +330,7 @@ class FileGroup(GroupBase):
         raise NotImplementedError
 
 
-def get_table(title: str, vals: Iterable[Any], simple: bool = False) -> Table:
-    """
-    Get a table from a list of values.
-    """
-    if simple:
-        table = Table(title, box=None)
-    else:
-        table = Table(
-            title=title,
-            box=rich.box.SQUARE_DOUBLE_HEAD,
-            header_style=HEADER_STYLE,
-            show_header=True,
-            border_style=PREFERRED_BORDER_COLOR,
-        )
+def _table_format(table: Table, vals: Iterable[Any]) -> Table:
     headers = None
     has_rich_repr = False
     for p in vals:
@@ -357,11 +347,37 @@ def get_table(title: str, vals: Iterable[Any], simple: bool = False) -> Table:
     return table
 
 
-def get_panel(title: str, renderable: Any, simple: bool = False) -> Panel:
+def format(title: str, vals: Iterable[Any], of: OutputFormat = "table") -> Table | Any:
+    """
+    Get a table from a list of values.
+    """
+
+    match of:
+        case "table-simple":
+            return _table_format(Table(title, box=None), vals)
+        case "table":
+            return _table_format(
+                Table(
+                    title=title,
+                    box=rich.box.SQUARE_DOUBLE_HEAD,
+                    header_style=HEADER_STYLE,
+                    show_header=True,
+                    border_style=PREFERRED_BORDER_COLOR,
+                ),
+                vals,
+            )
+        case "json":
+            if not vals:
+                return pretty_repr([])
+            return pretty_repr([v.to_dict() for v in vals])
+    raise click.ClickException("Unknown output format. Supported formats are: table, table-simple, json.")
+
+
+def get_panel(title: str, renderable: Any, of: OutputFormat = "table") -> Panel:
     """
     Get a panel from a list of values.
     """
-    if simple:
+    if of in ["table-simple", "json"]:
         return renderable
     return Panel.fit(
         renderable,

flyte/cli/_create.py

@@ -4,6 +4,7 @@ from typing import Any, Dict, get_args
 import rich_click as click
 
 import flyte.cli._common as common
+from flyte.cli._option import MutuallyExclusiveOption
 from flyte.remote import SecretTypes
 
 
@@ -16,8 +17,21 @@ def create():
 
 @create.command(cls=common.CommandBase)
 @click.argument("name", type=str, required=True)
-@click.argument("value", type=str, required=False)
-@click.option("--from-file", type=click.Path(exists=True), help="Path to the file with the binary secret.")
+@click.option(
+    "--value",
+    help="Secret value",
+    prompt="Enter secret value",
+    hide_input=True,
+    cls=MutuallyExclusiveOption,
+    mutually_exclusive=["from_file"],
+)
+@click.option(
+    "--from-file",
+    type=click.Path(exists=True),
+    help="Path to the file with the binary secret.",
+    cls=MutuallyExclusiveOption,
+    mutually_exclusive=["value"],
+)
 @click.option(
     "--type", type=click.Choice(get_args(SecretTypes)), default="regular", help="Type of the secret.", show_default=True
 )
@@ -38,6 +52,14 @@ def secret(
     $ flyte create secret my_secret --value my_value
     ```
 
+    If you don't provide a `--value` flag, you will be prompted to enter the
+    secret value in the terminal.
+
+    ```bash
+    $ flyte create secret my_secret
+    Enter secret value:
+    ```
+
     If `--from-file` is specified, the value will be read from the file instead of being provided directly:
 
     ```bash

flyte/cli/_deploy.py

@@ -109,8 +109,8 @@ class DeployEnvCommand(click.Command):
                 version=self.deploy_args.version,
             )
 
-        console.print(common.get_table("Environments", deployment[0].env_repr(), simple=obj.simple))
-        console.print(common.get_table("Tasks", deployment[0].task_repr(), simple=obj.simple))
+        console.print(common.format("Environments", deployment[0].env_repr(), obj.output_format))
+        console.print(common.format("Tasks", deployment[0].task_repr(), obj.output_format))
 
 
 class DeployEnvRecursiveCommand(click.Command):
@@ -139,7 +139,7 @@ class DeployEnvRecursiveCommand(click.Command):
         if failed_paths:
             console.print(f"Loaded {len(loaded_modules)} modules with, but failed to load {len(failed_paths)} paths:")
             console.print(
-                common.get_table("Modules", [[("Path", p), ("Err", e)] for p, e in failed_paths], simple=obj.simple)
+                common.format("Modules", [[("Path", p), ("Err", e)] for p, e in failed_paths], obj.output_format)
             )
         else:
             console.print(f"Loaded {len(loaded_modules)} modules")
@@ -149,9 +149,7 @@ class DeployEnvRecursiveCommand(click.Command):
         if not all_envs:
             console.print("No environments found to deploy")
             return
-        console.print(
-            common.get_table("Loaded Environments", [[("name", e.name)] for e in all_envs], simple=obj.simple)
-        )
+        console.print(common.format("Loaded Environments", [[("name", e.name)] for e in all_envs], obj.output_format))
 
         if not self.deploy_args.ignore_load_errors and len(failed_paths) > 0:
             raise click.ClickException(
@@ -168,11 +166,9 @@ class DeployEnvRecursiveCommand(click.Command):
             )
 
         console.print(
-            common.get_table("Environments", [env for d in deployments for env in d.env_repr()], simple=obj.simple)
-        )
-        console.print(
-            common.get_table("Tasks", [task for d in deployments for task in d.task_repr()], simple=obj.simple)
+            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))
 
 
 class EnvPerFileGroup(common.ObjectsPerFileGroup):

flyte/cli/_gen.py

@@ -38,6 +38,10 @@ def walk_commands(ctx: click.Context) -> Generator[Tuple[str, click.Command], No
 
     if not isinstance(command, click.Group):
         yield ctx.command_path, command
+    elif isinstance(command, common.FileGroup):
+        # If the command is a FileGroup, yield its file path and the command itself
+        # No need to recurse further into FileGroup as it doesn't have subcommands, they are dynamically generated
+        yield ctx.command_path, command
     else:
         for name in command.list_commands(ctx):
             subcommand = command.get_command(ctx, name)