flyte 2.0.0b6__py3-none-any.whl → 2.0.0b8__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

@@ -154,6 +154,7 @@ class PipPackages(PipOption, Layer):
 class PythonWheels(PipOption, Layer):
     wheel_dir: Path = field(metadata={"identifier": False})
     wheel_dir_name: str = field(init=False)
+    package_name: str
 
     def __post_init__(self):
         object.__setattr__(self, "wheel_dir_name", self.wheel_dir.name)
@@ -498,7 +499,8 @@ class Image:
                     image = image.with_pip_packages(f"flyte=={flyte_version}", pre=True)
                 else:
                     image = image.with_pip_packages(f"flyte=={flyte_version}")
-        object.__setattr__(image, "_tag", preset_tag)
+        if not dev_mode:
+            object.__setattr__(image, "_tag", preset_tag)
         # Set this to auto for all auto images because the meaning of "auto" can change (based on logic inside
         # _get_default_image_for, acts differently in a running task container) so let's make sure it stays auto.
         object.__setattr__(image, "_identifier_override", "auto")
@@ -546,7 +548,7 @@ class Image:
             platform=platform,
         )
 
-        if registry and name:
+        if registry or name:
             return base_image.clone(registry=registry, name=name)
 
         # # Set this to auto for all auto images because the meaning of "auto" can change (based on logic inside
@@ -940,7 +942,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))
+        with_dist = self.clone(addl_layer=PythonWheels(wheel_dir=dist_folder, package_name="flyte", pre=True))
 
         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/imagebuild/docker_builder.py

@@ -37,6 +37,7 @@ from flyte._internal.imagebuild.image_builder import (
     LocalDockerCommandImageChecker,
     LocalPodmanCommandImageChecker,
 )
+from flyte._internal.imagebuild.utils import copy_files_to_context
 from flyte._logging import logger
 
 _F_IMG_ID = "_F_IMG_ID"
@@ -109,7 +110,7 @@ RUN uv venv $$VIRTUALENV --python=$PYTHON_VERSION
 
 # Adds nvidia just in case it exists
 ENV PATH="$$PATH:/usr/local/nvidia/bin:/usr/local/cuda/bin" \
-    LD_LIBRARY_PATH="/usr/local/nvidia/lib64:$$LD_LIBRARY_PATH"
+    LD_LIBRARY_PATH="/usr/local/nvidia/lib64"
 """)
 
 # This gets added on to the end of the dockerfile
@@ -128,30 +129,29 @@ class Handler(Protocol):
 class PipAndRequirementsHandler:
     @staticmethod
     async def handle(layer: PipPackages, context_path: Path, dockerfile: str) -> str:
+        # Set pip_install_args based on the layer type - either a requirements file or a list of packages
         if isinstance(layer, Requirements):
             if not layer.file.exists():
                 raise FileNotFoundError(f"Requirements file {layer.file} does not exist")
             if not layer.file.is_file():
                 raise ValueError(f"Requirements file {layer.file} is not a file")
 
-            async with aiofiles.open(layer.file) as f:
-                requirements = []
-                async for line in f:
-                    requirement = line
-                    requirements.append(requirement.strip())
+            # Copy the requirements file to the context path
+            requirements_path = copy_files_to_context(layer.file, context_path)
+            pip_install_args = layer.get_pip_install_args()
+            pip_install_args.extend(["--requirement", str(requirements_path)])
         else:
             requirements = list(layer.packages) if layer.packages else []
-        requirements_uv_path = context_path / "requirements_uv.txt"
-        async with aiofiles.open(requirements_uv_path, "w") as f:
-            reqs = "\n".join(requirements)
-            await f.write(reqs)
+            reqs = " ".join(requirements)
+            pip_install_args = layer.get_pip_install_args()
+            pip_install_args.append(reqs)
 
-        pip_install_args = layer.get_pip_install_args()
-        pip_install_args.extend(["--requirement", "requirements_uv.txt"])
         secret_mounts = _get_secret_mounts_layer(layer.secret_mounts)
         delta = UV_PACKAGE_INSTALL_COMMAND_TEMPLATE.substitute(
-            PIP_INSTALL_ARGS=" ".join(pip_install_args), SECRET_MOUNT=secret_mounts
+            SECRET_MOUNT=secret_mounts,
+            PIP_INSTALL_ARGS=" ".join(pip_install_args),
         )
+
         dockerfile += delta
 
         return dockerfile
@@ -162,12 +162,31 @@ class PythonWheelHandler:
     async def handle(layer: PythonWheels, context_path: Path, dockerfile: str) -> str:
         shutil.copytree(layer.wheel_dir, context_path / "dist", dirs_exist_ok=True)
         pip_install_args = layer.get_pip_install_args()
-        pip_install_args.extend(["/dist/*.whl"])
         secret_mounts = _get_secret_mounts_layer(layer.secret_mounts)
-        delta = UV_WHEEL_INSTALL_COMMAND_TEMPLATE.substitute(
-            PIP_INSTALL_ARGS=" ".join(pip_install_args), SECRET_MOUNT=secret_mounts
+
+        # First install: Install the wheel without dependencies using --no-deps
+        pip_install_args_no_deps = [
+            *pip_install_args,
+            *[
+                "--find-links",
+                "/dist",
+                "--no-deps",
+                "--no-index",
+                layer.package_name,
+            ],
+        ]
+
+        delta1 = UV_WHEEL_INSTALL_COMMAND_TEMPLATE.substitute(
+            PIP_INSTALL_ARGS=" ".join(pip_install_args_no_deps), SECRET_MOUNT=secret_mounts
         )
-        dockerfile += delta
+        dockerfile += delta1
+
+        # Second install: Install dependencies from PyPI
+        pip_install_args_deps = [*pip_install_args, layer.package_name]
+        delta2 = UV_WHEEL_INSTALL_COMMAND_TEMPLATE.substitute(
+            PIP_INSTALL_ARGS=" ".join(pip_install_args_deps), SECRET_MOUNT=secret_mounts
+        )
+        dockerfile += delta2
 
         return dockerfile
 

flyte/_internal/imagebuild/remote_builder.py

@@ -26,6 +26,7 @@ from flyte._image import (
     UVScript,
 )
 from flyte._internal.imagebuild.image_builder import ImageBuilder, ImageChecker
+from flyte._internal.imagebuild.utils import copy_files_to_context
 from flyte._logging import logger
 from flyte.remote import ActionOutputs, Run
 
@@ -169,7 +170,7 @@ def _get_layers_proto(image: Image, context_path: Path) -> "image_definition_pb2
             )
             layers.append(apt_layer)
         elif isinstance(layer, PythonWheels):
-            dst_path = _copy_files_to_context(layer.wheel_dir, context_path)
+            dst_path = copy_files_to_context(layer.wheel_dir, context_path)
             wheel_layer = image_definition_pb2.Layer(
                 python_wheels=image_definition_pb2.PythonWheels(
                     dir=str(dst_path.relative_to(context_path)),
@@ -184,7 +185,7 @@ def _get_layers_proto(image: Image, context_path: Path) -> "image_definition_pb2
             layers.append(wheel_layer)
 
         elif isinstance(layer, Requirements):
-            dst_path = _copy_files_to_context(layer.file, context_path)
+            dst_path = copy_files_to_context(layer.file, context_path)
             requirements_layer = image_definition_pb2.Layer(
                 requirements=image_definition_pb2.Requirements(
                     file=str(dst_path.relative_to(context_path)),
@@ -240,7 +241,7 @@ def _get_layers_proto(image: Image, context_path: Path) -> "image_definition_pb2
         elif isinstance(layer, DockerIgnore):
             shutil.copy(layer.path, context_path)
         elif isinstance(layer, CopyConfig):
-            dst_path = _copy_files_to_context(layer.src, context_path)
+            dst_path = copy_files_to_context(layer.src, context_path)
 
             copy_layer = image_definition_pb2.Layer(
                 copy_config=image_definition_pb2.CopyConfig(
@@ -264,18 +265,5 @@ def _get_layers_proto(image: Image, context_path: Path) -> "image_definition_pb2
     )
 
 
-def _copy_files_to_context(src: Path, context_path: Path) -> Path:
-    if src.is_absolute() or ".." in str(src):
-        dst_path = context_path / str(src.absolute()).replace("/", "./_flyte_abs_context/", 1)
-    else:
-        dst_path = context_path / src
-    dst_path.parent.mkdir(parents=True, exist_ok=True)
-    if src.is_dir():
-        shutil.copytree(src, dst_path, dirs_exist_ok=True)
-    else:
-        shutil.copy(src, dst_path)
-    return dst_path
-
-
 def _get_fully_qualified_image_name(outputs: ActionOutputs) -> str:
     return outputs.pb2.literals[0].value.scalar.primitive.string_value

flyte/_internal/imagebuild/utils.py

@@ -0,0 +1,29 @@
+import shutil
+from pathlib import Path
+
+
+def copy_files_to_context(src: Path, context_path: Path) -> Path:
+    """
+    This helper function ensures that absolute paths that users specify are converted correctly to a path in the
+    context directory. Doing this prevents collisions while ensuring files are available in the context.
+
+    For example, if a user has
+        img.with_requirements(Path("/Users/username/requirements.txt"))
+           .with_requirements(Path("requirements.txt"))
+           .with_requirements(Path("../requirements.txt"))
+
+    copying with this function ensures that the Docker context folder has all three files.
+
+    :param src: The source path to copy
+    :param context_path: The context path where the files should be copied to
+    """
+    if src.is_absolute() or ".." in str(src):
+        dst_path = context_path / str(src.absolute()).replace("/", "./_flyte_abs_context/", 1)
+    else:
+        dst_path = context_path / src
+    dst_path.parent.mkdir(parents=True, exist_ok=True)
+    if src.is_dir():
+        shutil.copytree(src, dst_path, dirs_exist_ok=True)
+    else:
+        shutil.copy(src, dst_path)
+    return dst_path

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
 
@@ -512,7 +512,7 @@ class _Runner:
             raise ValueError("Remote task can only be run in remote mode.")
 
         if not isinstance(task, TaskTemplate) and not isinstance(task, LazyEntity):
-            raise TypeError("On Flyte tasks can be run, not generic functions or methods.")
+            raise TypeError(f"On Flyte tasks can be run, not generic functions or methods '{type(task)}'.")
 
         if self._mode == "remote":
             return await self._run_remote(task, *args, **kwargs)

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

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

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