flyte 2.0.0b4__py3-none-any.whl → 2.0.0b6__py3-none-any.whl

flyte/_code_bundle/bundle.py

@@ -7,6 +7,7 @@ import tempfile
 from pathlib import Path
 from typing import ClassVar, Type
 
+from async_lru import alru_cache
 from flyteidl.core.tasks_pb2 import TaskTemplate
 
 from flyte._logging import log, logger
@@ -109,6 +110,7 @@ async def build_pkl_bundle(
             return CodeBundle(pkl=str(dest), computed_version=str_digest)
 
 
+@alru_cache
 async def build_code_bundle(
     from_dir: Path,
     *ignore: Type[Ignore],

flyte/_deploy.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
 import asyncio
+import typing
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
 
+import grpc.aio
 import rich.repr
 
 import flyte.errors
@@ -90,27 +92,39 @@ async def _deploy_task(
 
     image_uri = task.image.uri if isinstance(task.image, Image) else task.image
 
-    if dryrun:
-        return translate_task_to_wire(task, serialization_context)
-
-    default_inputs = await convert_upload_default_inputs(task.interface)
-    spec = translate_task_to_wire(task, serialization_context, default_inputs=default_inputs)
-
-    msg = f"Deploying task {task.name}, with image {image_uri} version {serialization_context.version}"
-    if spec.task_template.HasField("container") and spec.task_template.container.args:
-        msg += f" from {spec.task_template.container.args[-3]}.{spec.task_template.container.args[-1]}"
-    logger.info(msg)
-    task_id = task_definition_pb2.TaskIdentifier(
-        org=spec.task_template.id.org,
-        project=spec.task_template.id.project,
-        domain=spec.task_template.id.domain,
-        version=spec.task_template.id.version,
-        name=spec.task_template.id.name,
-    )
+    try:
+        if dryrun:
+            return translate_task_to_wire(task, serialization_context)
+
+        default_inputs = await convert_upload_default_inputs(task.interface)
+        spec = translate_task_to_wire(task, serialization_context, default_inputs=default_inputs)
+
+        msg = f"Deploying task {task.name}, with image {image_uri} version {serialization_context.version}"
+        if spec.task_template.HasField("container") and spec.task_template.container.args:
+            msg += f" from {spec.task_template.container.args[-3]}.{spec.task_template.container.args[-1]}"
+        logger.info(msg)
+        task_id = task_definition_pb2.TaskIdentifier(
+            org=spec.task_template.id.org,
+            project=spec.task_template.id.project,
+            domain=spec.task_template.id.domain,
+            version=spec.task_template.id.version,
+            name=spec.task_template.id.name,
+        )
 
-    await get_client().task_service.DeployTask(task_service_pb2.DeployTaskRequest(task_id=task_id, spec=spec))
-    logger.info(f"Deployed task {task.name} with version {task_id.version}")
-    return spec
+        try:
+            await get_client().task_service.DeployTask(task_service_pb2.DeployTaskRequest(task_id=task_id, spec=spec))
+            logger.info(f"Deployed task {task.name} with version {task_id.version}")
+        except grpc.aio.AioRpcError as e:
+            if e.code() == grpc.StatusCode.ALREADY_EXISTS:
+                logger.info(f"Task {task.name} with image {image_uri} already exists, skipping deployment.")
+                return spec
+            raise
+        return spec
+    except Exception as e:
+        logger.error(f"Failed to deploy task {task.name} with image {image_uri}: {e}")
+        raise flyte.errors.DeploymentError(
+            f"Failed to deploy task {task.name} file{task.source_file} with image {image_uri}, Error: {e!s}"
+        ) from e
 
 
 async def _build_image_bg(env_name: str, image: Image) -> Tuple[str, str]:
@@ -151,13 +165,14 @@ async def _build_images(deployment: DeploymentPlan) -> ImageCache:
 
 
 @requires_initialization
-async def apply(deployment: DeploymentPlan, copy_style: CopyFiles, dryrun: bool = False) -> Deployment:
+async def apply(deployment_plan: DeploymentPlan, copy_style: CopyFiles, dryrun: bool = False) -> Deployment:
     from ._code_bundle import build_code_bundle
 
     cfg = get_common_config()
-    image_cache = await _build_images(deployment)
 
-    version = deployment.version
+    image_cache = await _build_images(deployment_plan)
+
+    version = deployment_plan.version
     if copy_style == "none" and not version:
         raise flyte.errors.DeploymentError("Version must be set when copy_style is none")
     else:
@@ -178,41 +193,44 @@ async def apply(deployment: DeploymentPlan, copy_style: CopyFiles, dryrun: bool
     )
 
     tasks = []
-    for env_name, env in deployment.envs.items():
+
+    for env_name, env in deployment_plan.envs.items():
         logger.info(f"Deploying environment {env_name}")
         # TODO Make this pluggable based on the environment type
         if isinstance(env, TaskEnvironment):
             for task in env.tasks.values():
                 tasks.append(_deploy_task(task, dryrun=dryrun, serialization_context=sc))
-    return Deployment(envs=deployment.envs, deployed_tasks=await asyncio.gather(*tasks))
+    return Deployment(envs=deployment_plan.envs, deployed_tasks=await asyncio.gather(*tasks))
 
 
-def _recursive_discover(
-    planned_envs: Dict[str, Environment], envs: Environment | List[Environment]
-) -> Dict[str, Environment]:
+def _recursive_discover(planned_envs: Dict[str, Environment], env: Environment) -> Dict[str, Environment]:
     """
     Recursively deploy the environment and its dependencies, if not already deployed (present in env_tasks) and
     return the updated env_tasks.
     """
-    if isinstance(envs, Environment):
-        envs = [envs]
-    for env in envs:
-        # Skip if the environment is already planned
-        if env.name in planned_envs:
-            continue
-        # Recursively discover dependent environments
-        for dependent_env in env.depends_on:
-            _recursive_discover(planned_envs, dependent_env)
-        # Add the environment to the existing envs
-        planned_envs[env.name] = env
+    # Skip if the environment is already planned
+    if env.name in planned_envs:
+        return planned_envs
+    # Recursively discover dependent environments
+    for dependent_env in env.depends_on:
+        _recursive_discover(planned_envs, dependent_env)
+    # Add the environment to the existing envs
+    planned_envs[env.name] = env
     return planned_envs
 
 
-def plan_deploy(*envs: Environment, version: Optional[str] = None) -> DeploymentPlan:
+def plan_deploy(*envs: Environment, version: Optional[str] = None) -> List[DeploymentPlan]:
     if envs is None:
-        return DeploymentPlan({})
-    planned_envs = _recursive_discover({}, *envs)
-    return DeploymentPlan(planned_envs, version=version)
+        return [DeploymentPlan({})]
+    deployment_plans = []
+    visited_envs: typing.Set[str] = set()
+    for env in envs:
+        if env.name in visited_envs:
+            continue
+        planned_envs = _recursive_discover({}, env)
+        deployment_plans.append(DeploymentPlan(planned_envs, version=version))
+        visited_envs.update(planned_envs.keys())
+    return deployment_plans
 
 
 @syncify
@@ -222,7 +240,7 @@ async def deploy(
     version: str | None = None,
     interactive_mode: bool | None = None,
     copy_style: CopyFiles = "loaded_modules",
-) -> Deployment:
+) -> List[Deployment]:
     """
     Deploy the given environment or list of environments.
     :param envs: Environment or list of environments to deploy.
@@ -238,16 +256,19 @@ async def deploy(
     """
     if interactive_mode:
         raise NotImplementedError("Interactive mode not yet implemented for deployment")
-    deployment = plan_deploy(*envs, version=version)
-    return await apply(deployment, copy_style=copy_style, dryrun=dryrun)
+    deployment_plans = plan_deploy(*envs, version=version)
+    deployments = []
+    for deployment_plan in deployment_plans:
+        deployments.append(apply(deployment_plan, copy_style=copy_style, dryrun=dryrun))
+    return await asyncio.gather(*deployments)
 
 
 @syncify
-async def build_images(*envs: Environment) -> ImageCache:
+async def build_images(envs: Environment) -> ImageCache:
     """
     Build the images for the given environments.
-    :param envs: Environment or list of environments to build images for.
+    :param envs: Environment to build images for.
     :return: ImageCache containing the built images.
     """
-    deployment = plan_deploy(*envs)
-    return await _build_images(deployment)
+    deployment = plan_deploy(envs)
+    return await _build_images(deployment[0])

flyte/_environment.py

@@ -6,14 +6,24 @@ from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Union
 
 import rich.repr
 
-from flyte._secret import SecretRequest
-
 from ._image import Image
 from ._resources import Resources
+from ._secret import SecretRequest
 
 if TYPE_CHECKING:
     from kubernetes.client import V1PodTemplate
 
+# Global registry to track all Environment instances in load order
+_ENVIRONMENT_REGISTRY: List[Environment] = []
+
+
+def list_loaded_environments() -> List[Environment]:
+    """
+    Return a list of all Environment objects in the order they were loaded.
+    This is useful for deploying environments in the order they were defined.
+    """
+    return _ENVIRONMENT_REGISTRY
+
 
 def is_snake_or_kebab_with_numbers(s: str) -> bool:
     return re.fullmatch(r"^[a-z0-9]+([_-][a-z0-9]+)*$", s) is not None
@@ -44,6 +54,8 @@ class Environment:
     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.")
+        # Automatically register this environment instance in load order
+        _ENVIRONMENT_REGISTRY.append(self)
 
     def add_dependency(self, *env: Environment):
         """

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)
@@ -165,6 +188,15 @@ class UVProject(PipOption, Layer):
     pyproject: Path
     uvlock: Path
 
+    def validate(self):
+        if not self.pyproject.exists():
+            raise FileNotFoundError(f"pyproject.toml file {self.pyproject} does not exist")
+        if not self.pyproject.is_file():
+            raise ValueError(f"Pyproject file {self.pyproject} is not a file")
+        if not self.uvlock.exists():
+            raise ValueError(f"UVLock file {self.uvlock} does not exist")
+        super().validate()
+
     def update_hash(self, hasher: hashlib._Hash):
         from ._utils import filehash_update
 
@@ -172,6 +204,34 @@ class UVProject(PipOption, Layer):
         filehash_update(self.uvlock, hasher)
 
 
+@rich.repr.auto
+@dataclass(frozen=True, repr=True)
+class UVScript(PipOption, Layer):
+    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():
+            raise FileNotFoundError(f"UV script {self.script} does not exist")
+        if not self.script.is_file():
+            raise ValueError(f"UV script {self.script} is not a file")
+        if not self.script.suffix == ".py":
+            raise ValueError(f"UV script {self.script} must have a .py extension")
+        super().validate()
+
+    def update_hash(self, hasher: hashlib._Hash):
+        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)
+
+
 @rich.repr.auto
 @dataclass(frozen=True, repr=True)
 class AptPackages(Layer):
@@ -217,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():
@@ -363,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("=")
@@ -400,12 +466,13 @@ 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(
             (
-                "LABEL org.opencontainers.image.authors='Union.AI <sales@union.ai>'",
-                "LABEL org.opencontainers.image.source=https://github.com/unionai/unionv2",
+                "LABEL org.opencontainers.image.authors='Union.AI <info@union.ai>'",
+                "LABEL org.opencontainers.image.source=https://github.com/flyteorg/flyte",
                 "RUN useradd --create-home --shell /bin/bash flytekit &&"
                 " chown -R flytekit /root && chown -R flytekit /home",
                 "WORKDIR /root",
@@ -511,6 +578,7 @@ class Image:
         pre: bool = False,
         extra_args: Optional[str] = None,
         platform: Optional[Tuple[Architecture, ...]] = None,
+        secret_mounts: Optional[SecretRequest] = None,
     ) -> Image:
         """
         Use this method to create a new image with the specified uv script.
@@ -541,39 +609,25 @@ 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:
         """
-        from ._utils import parse_uv_script_file
+        ll = UVScript(
+            script=Path(script),
+            index_url=index_url,
+            extra_index_urls=_ensure_tuple(extra_index_urls) if extra_index_urls else None,
+            pre=pre,
+            extra_args=extra_args,
+            secret_mounts=_ensure_tuple(secret_mounts) if secret_mounts else None,
+        )
 
-        if isinstance(script, str):
-            script = Path(script)
-        if not script.exists():
-            raise FileNotFoundError(f"UV script {script} does not exist")
-        if not script.is_file():
-            raise ValueError(f"UV script {script} is not a file")
-        if not script.suffix == ".py":
-            raise ValueError(f"UV script {script} must have a .py extension")
-        header = parse_uv_script_file(script)
-
-        # todo: arch
         img = cls.from_debian_base(registry=registry, name=name, python_version=python_version, platform=platform)
 
-        # add ca-certificates to the image by default
-        img = img.with_apt_packages("ca-certificates")
-
-        if header.dependencies:
-            return img.with_pip_packages(
-                *header.dependencies,
-                index_url=index_url,
-                extra_index_urls=extra_index_urls,
-                pre=pre,
-                extra_args=extra_args,
-            )
-
-        # todo: override the _identifier_override to be the script name or a hash of the script contents
-        # This is needed because inside the image, the identifier will be computed to be something different.
-        return img
+        return img.clone(addl_layer=ll)
 
     def clone(
         self,
@@ -788,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:
@@ -800,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:
@@ -809,7 +863,8 @@ class Image:
 
     def with_uv_project(
         self,
-        pyproject_file: Path,
+        pyproject_file: str | Path,
+        uvlock: Path | None = None,
         index_url: Optional[str] = None,
         extra_index_urls: Union[List[str], Tuple[str, ...], None] = None,
         pre: bool = False,
@@ -823,6 +878,8 @@ class Image:
         In the Union builders, using this will change the virtual env to /root/.venv
 
         :param pyproject_file: path to the pyproject.toml file, needs to have a corresponding uv.lock file
+        :param uvlock: path to the uv.lock file, if not specified, will use the default uv.lock file in the same
+        directory as the pyproject.toml file. (pyproject.parent / uv.lock)
         :param index_url: index url to use for pip install, default is None
         :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
@@ -830,17 +887,12 @@ class Image:
         :param secret_mounts: list of secret mounts to use for the build process.
         :return: Image
         """
-        if not pyproject_file.exists():
-            raise FileNotFoundError(f"UVLock file {pyproject_file} does not exist")
-        if not pyproject_file.is_file():
-            raise ValueError(f"UVLock file {pyproject_file} is not a file")
-        lock = pyproject_file.parent / "uv.lock"
-        if not lock.exists():
-            raise ValueError(f"UVLock file {lock} does not exist")
+        if isinstance(pyproject_file, str):
+            pyproject_file = Path(pyproject_file)
         new_image = self.clone(
             addl_layer=UVProject(
                 pyproject=pyproject_file,
-                uvlock=lock,
+                uvlock=uvlock or (pyproject_file.parent / "uv.lock"),
                 index_url=index_url,
                 extra_index_urls=extra_index_urls,
                 pre=pre,
@@ -888,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/imagebuild/docker_builder.py

@@ -25,8 +25,10 @@ from flyte._image import (
     PythonWheels,
     Requirements,
     UVProject,
+    UVScript,
     WorkDir,
     _DockerLines,
+    _ensure_tuple,
 )
 from flyte._internal.imagebuild.image_builder import (
     DockerAPIImageChecker,
@@ -325,6 +327,22 @@ async def _process_layer(layer: Layer, context_path: Path, dockerfile: str) -> s
             # Handle Python wheels
             dockerfile = await PythonWheelHandler.handle(layer, context_path, dockerfile)
 
+        case UVScript():
+            # Handle UV script
+            from flyte._utils import parse_uv_script_file
+
+            header = parse_uv_script_file(layer.script)
+            if header.dependencies:
+                pip = PipPackages(
+                    packages=_ensure_tuple(header.dependencies) if header.dependencies else None,
+                    secret_mounts=layer.secret_mounts,
+                    index_url=layer.index_url,
+                    extra_args=layer.extra_args,
+                    pre=layer.pre,
+                    extra_index_urls=layer.extra_index_urls,
+                )
+                dockerfile = await PipAndRequirementsHandler.handle(pip, context_path, dockerfile)
+
         case Requirements() | PipPackages():
             # Handle pip packages and requirements
             dockerfile = await PipAndRequirementsHandler.handle(layer, context_path, dockerfile)

flyte/_internal/imagebuild/remote_builder.py

@@ -23,6 +23,7 @@ from flyte._image import (
     PythonWheels,
     Requirements,
     UVProject,
+    UVScript,
 )
 from flyte._internal.imagebuild.image_builder import ImageBuilder, ImageChecker
 from flyte._logging import logger
@@ -196,10 +197,19 @@ def _get_layers_proto(image: Image, context_path: Path) -> "image_definition_pb2
                 )
             )
             layers.append(requirements_layer)
-        elif isinstance(layer, PipPackages):
+        elif isinstance(layer, PipPackages) or isinstance(layer, UVScript):
+            if isinstance(layer, UVScript):
+                from flyte._utils import parse_uv_script_file
+
+                header = parse_uv_script_file(layer.script)
+                if not header.dependencies:
+                    continue
+                packages: typing.Iterable[str] = header.dependencies
+            else:
+                packages = layer.packages or []
             pip_layer = image_definition_pb2.Layer(
                 pip_packages=image_definition_pb2.PipPackages(
-                    packages=layer.packages,
+                    packages=packages,
                     options=image_definition_pb2.PipOptions(
                         index_url=layer.index_url,
                         extra_index_urls=layer.extra_index_urls,

flyte/_internal/runtime/convert.py

@@ -105,11 +105,9 @@ def is_optional_type(tp) -> bool:
 async def convert_from_native_to_inputs(interface: NativeInterface, *args, **kwargs) -> Inputs:
     kwargs = interface.convert_to_kwargs(*args, **kwargs)
 
-    if len(kwargs) < interface.num_required_inputs():
-        raise ValueError(
-            f"Received {len(kwargs)} inputs but interface has {interface.num_required_inputs()} required inputs. "
-            f"Please provide all required inputs. Inputs received: {kwargs}, interface: {interface}"
-        )
+    missing = [key for key in interface.required_inputs() if key not in kwargs]
+    if missing:
+        raise ValueError(f"Missing required inputs: {', '.join(missing)}")
 
     if len(interface.inputs) == 0:
         return Inputs.empty()

flyte/_run.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import pathlib
 import uuid
+from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Tuple, Union, cast
 
 import flyte.errors
@@ -36,10 +37,26 @@ if TYPE_CHECKING:
     from flyte.remote._task import LazyEntity
 
     from ._code_bundle import CopyFiles
+    from ._internal.imagebuild.image_builder import ImageCache
 
 Mode = Literal["local", "remote", "hybrid"]
 
 
+@dataclass(frozen=True)
+class _CacheKey:
+    obj_id: int
+    dry_run: bool
+
+
+@dataclass(frozen=True)
+class _CacheValue:
+    code_bundle: CodeBundle | None
+    image_cache: Optional[ImageCache]
+
+
+_RUN_CACHE: Dict[_CacheKey, _CacheValue] = {}
+
+
 async def _get_code_bundle_for_run(name: str) -> CodeBundle | None:
     """
     Get the code bundle for the run with the given name.
@@ -78,6 +95,7 @@ class _Runner:
         annotations: Dict[str, str] | None = None,
         interruptible: bool = False,
         log_level: int | None = None,
+        disable_run_cache: bool = False,
     ):
         init_config = _get_init_config()
         client = init_config.client if init_config else None
@@ -104,6 +122,7 @@ class _Runner:
         self._annotations = annotations
         self._interruptible = interruptible
         self._log_level = log_level
+        self._disable_run_cache = disable_run_cache
 
     @requires_initialization
     async def _run_remote(self, obj: TaskTemplate[P, R] | LazyEntity, *args: P.args, **kwargs: P.kwargs) -> Run:
@@ -135,24 +154,36 @@ class _Runner:
             if obj.parent_env is None:
                 raise ValueError("Task is not attached to an environment. Please attach the task to an environment")
 
-            image_cache = await build_images.aio(cast(Environment, obj.parent_env()))
-
-            if self._interactive_mode:
-                code_bundle = await build_pkl_bundle(
-                    obj,
-                    upload_to_controlplane=not self._dry_run,
-                    copy_bundle_to=self._copy_bundle_to,
-                )
+            if (
+                not self._disable_run_cache
+                and _RUN_CACHE.get(_CacheKey(obj_id=id(obj), dry_run=self._dry_run)) is not None
+            ):
+                cached_value = _RUN_CACHE[_CacheKey(obj_id=id(obj), dry_run=self._dry_run)]
+                code_bundle = cached_value.code_bundle
+                image_cache = cached_value.image_cache
             else:
-                if self._copy_files != "none":
-                    code_bundle = await build_code_bundle(
-                        from_dir=cfg.root_dir,
-                        dryrun=self._dry_run,
+                image_cache = await build_images.aio(cast(Environment, obj.parent_env()))
+
+                if self._interactive_mode:
+                    code_bundle = await build_pkl_bundle(
+                        obj,
+                        upload_to_controlplane=not self._dry_run,
                         copy_bundle_to=self._copy_bundle_to,
-                        copy_style=self._copy_files,
                     )
                 else:
-                    code_bundle = None
+                    if self._copy_files != "none":
+                        code_bundle = await build_code_bundle(
+                            from_dir=cfg.root_dir,
+                            dryrun=self._dry_run,
+                            copy_bundle_to=self._copy_bundle_to,
+                            copy_style=self._copy_files,
+                        )
+                    else:
+                        code_bundle = None
+            if not self._disable_run_cache:
+                _RUN_CACHE[_CacheKey(obj_id=id(obj), dry_run=self._dry_run)] = _CacheValue(
+                    code_bundle=code_bundle, image_cache=image_cache
+                )
 
             version = self._version or (
                 code_bundle.computed_version if code_bundle and code_bundle.computed_version else None
@@ -516,6 +547,7 @@ def with_runcontext(
     annotations: Dict[str, str] | None = None,
     interruptible: bool = False,
     log_level: int | None = None,
+    disable_run_cache: bool = False,
 ) -> _Runner:
     """
     Launch a new run with the given parameters as the context.
@@ -556,6 +588,7 @@ def with_runcontext(
     :param interruptible: Optional If true, the run can be interrupted by the user.
     :param log_level: Optional Log level to set for the run. If not provided, it will be set to the default log level
         set using `flyte.init()`
+    :param disable_run_cache: Optional If true, the run cache will be disabled. This is useful for testing purposes.
 
     :return: runner
     """
@@ -580,6 +613,7 @@ def with_runcontext(
         project=project,
         domain=domain,
         log_level=log_level,
+        disable_run_cache=disable_run_cache,
     )
 
 

flyte/_task.py

@@ -150,6 +150,10 @@ class TaskTemplate(Generic[P, R]):
         self.__dict__.update(state)
         self.parent_env = None
 
+    @property
+    def source_file(self) -> Optional[str]:
+        return None
+
     async def pre(self, *args, **kwargs) -> Dict[str, Any]:
         """
         This is the preexecute function that will be
@@ -395,6 +399,15 @@ class AsyncFunctionTaskTemplate(TaskTemplate[P, R]):
         if not iscoroutinefunction(self.func):
             self._call_as_synchronous = True
 
+    @property
+    def source_file(self) -> Optional[str]:
+        """
+        Returns the source file of the function, if available. This is useful for debugging and tracing.
+        """
+        if hasattr(self.func, "__code__") and self.func.__code__:
+            return self.func.__code__.co_filename
+        return None
+
     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

flyte/_utils/__init__.py

@@ -9,6 +9,7 @@ from .coro_management import run_coros
 from .file_handling import filehash_update, update_hasher_for_source
 from .helpers import get_cwd_editable_install
 from .lazy_module import lazy_module
+from .module_loader import load_python_modules
 from .org_discovery import hostname_from_url, org_from_endpoint, sanitize_endpoint
 from .uv_script_parser import parse_uv_script_file
 
@@ -18,6 +19,7 @@ __all__ = [
     "get_cwd_editable_install",
     "hostname_from_url",
     "lazy_module",
+    "load_python_modules",
     "org_from_endpoint",
     "parse_uv_script_file",
     "run_coros",

flyte/_utils/module_loader.py

@@ -0,0 +1,89 @@
+import glob
+import importlib.util
+import os
+import sys
+from pathlib import Path
+from typing import List, Tuple
+
+from rich.progress import BarColumn, Progress, TextColumn, TimeElapsedColumn, TimeRemainingColumn
+
+import flyte.errors
+
+
+def load_python_modules(path: Path, recursive: bool = False) -> Tuple[List[str], List[Tuple[Path, str]]]:
+    """
+    Load all Python modules from a path and return list of loaded module names.
+
+    :param path: File or directory path
+    :param recursive: If True, load modules recursively from subdirectories
+    :return: List of loaded module names, and list of file paths that failed to load
+    """
+    loaded_modules = []
+    failed_paths = []
+
+    if path.is_file() and path.suffix == ".py":
+        # Single file case
+        module_name = _load_module_from_file(path)
+        if module_name:
+            loaded_modules.append(module_name)
+
+    elif path.is_dir():
+        # Directory case
+        pattern = "**/*.py" if recursive else "*.py"
+        python_files = glob.glob(str(path / pattern), recursive=recursive)
+
+        with Progress(
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            "[progress.percentage]{task.percentage:>3.0f}%",
+            TimeElapsedColumn(),
+            TimeRemainingColumn(),
+            TextColumn("• {task.fields[current_file]}"),
+        ) as progress:
+            task = progress.add_task(f"Loading {len(python_files)} files", total=len(python_files), current_file="")
+            for file_path in python_files:
+                p = Path(file_path)
+                progress.update(task, advance=1, current_file=p.name)
+                # Skip __init__.py files
+                if p.name == "__init__.py":
+                    continue
+
+                try:
+                    module_name = _load_module_from_file(p)
+                    if module_name:
+                        loaded_modules.append(module_name)
+                except flyte.errors.ModuleLoadError as e:
+                    failed_paths.append((p, str(e)))
+
+            progress.update(task, advance=1, current_file="[green]Done[/green]")
+
+    return loaded_modules, failed_paths
+
+
+def _load_module_from_file(file_path: Path) -> str | None:
+    """
+    Load a Python module from a file path.
+
+    :param file_path: Path to the Python file
+    :return: Module name if successfully loaded, None otherwise
+    """
+    try:
+        # Use the file stem as module name
+        module_name = file_path.stem
+
+        # Load the module specification
+        spec = importlib.util.spec_from_file_location(module_name, file_path)
+        if spec is None or spec.loader is None:
+            return None
+
+        # Create and execute the module
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[module_name] = module
+        module_path = os.path.dirname(os.path.abspath(file_path))
+        sys.path.append(module_path)
+        spec.loader.exec_module(module)
+
+        return module_name
+
+    except Exception as e:
+        raise flyte.errors.ModuleLoadError(f"Failed to load module from {file_path}: {e}") from e

flyte/_version.py

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

flyte/cli/_common.py

@@ -265,7 +265,7 @@ class ObjectsPerFileGroup(GroupBase):
 
         spec = importlib.util.spec_from_file_location(module_name, self.filename)
         if spec is None or spec.loader is None:
-            raise click.ClickException(f"Could not load module {module_name} from {self.filename}")
+            raise click.ClickException(f"Could not load module {module_name} from path [{self.filename}]")
 
         module = importlib.util.module_from_spec(spec)
         sys.modules[module_name] = module
@@ -314,6 +314,10 @@ class FileGroup(GroupBase):
         if self._files is None:
             directory = self._dir or Path(".").absolute()
             self._files = [os.fspath(p) for p in directory.glob("*.py") if p.name != "__init__.py"]
+            if not self._files:
+                self._files = [os.fspath(".")] + [
+                    os.fspath(p.name) for p in directory.iterdir() if not p.name.startswith(("_", ".")) and p.is_dir()
+                ]
         return self._files
 
     def list_commands(self, ctx):

flyte/cli/_deploy.py

@@ -1,3 +1,4 @@
+import pathlib
 from dataclasses import dataclass, field, fields
 from pathlib import Path
 from types import ModuleType
@@ -43,6 +44,36 @@ class DeployArguments:
             )
         },
     )
+    recursive: bool = field(
+        default=False,
+        metadata={
+            "click.option": click.Option(
+                ["--recursive", "-r"],
+                is_flag=True,
+                help="Recursively deploy all environments in the current directory",
+            )
+        },
+    )
+    all: bool = field(
+        default=False,
+        metadata={
+            "click.option": click.Option(
+                ["--all"],
+                is_flag=True,
+                help="Deploy all environments in the current directory, ignoring the file name",
+            )
+        },
+    )
+    ignore_load_errors: bool = field(
+        default=False,
+        metadata={
+            "click.option": click.Option(
+                ["--ignore-load-errors", "-i"],
+                is_flag=True,
+                help="Ignore errors when loading environments especially when using --recursive or --all.",
+            )
+        },
+    )
 
     @classmethod
     def from_dict(cls, d: Dict[str, Any]) -> "DeployArguments":
@@ -57,9 +88,9 @@ class DeployArguments:
 
 
 class DeployEnvCommand(click.Command):
-    def __init__(self, obj_name: str, obj: Any, deploy_args: DeployArguments, *args, **kwargs):
-        self.obj_name = obj_name
-        self.obj = obj
+    def __init__(self, env_name: str, env: Any, deploy_args: DeployArguments, *args, **kwargs):
+        self.env_name = env_name
+        self.env = env
         self.deploy_args = deploy_args
         super().__init__(*args, **kwargs)
 
@@ -67,19 +98,81 @@ class DeployEnvCommand(click.Command):
         from rich.console import Console
 
         console = Console()
-        console.print(f"Deploying root - environment: {self.obj_name}")
+        console.print(f"Deploying root - environment: {self.env_name}")
         obj: CLIConfig = ctx.obj
         obj.init(self.deploy_args.project, self.deploy_args.domain)
         with console.status("Deploying...", spinner="dots"):
             deployment = flyte.deploy(
-                self.obj,
+                self.env,
                 dryrun=self.deploy_args.dry_run,
                 copy_style=self.deploy_args.copy_style,
                 version=self.deploy_args.version,
             )
 
-        console.print(common.get_table("Environments", deployment.env_repr(), simple=obj.simple))
-        console.print(common.get_table("Tasks", deployment.task_repr(), simple=obj.simple))
+        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))
+
+
+class DeployEnvRecursiveCommand(click.Command):
+    """
+    Command to deploy all loaded environments in a directory or a file, optionally recursively.
+    This command will load all python files in the directory, and deploy all environments found in them.
+    If the path is a file, it will deploy all environments in that file.
+    """
+
+    def __init__(self, path: pathlib.Path, deploy_args: DeployArguments, *args, **kwargs):
+        self.path = path
+        self.deploy_args = deploy_args
+        super().__init__(*args, **kwargs)
+
+    def invoke(self, ctx: Context):
+        from rich.console import Console
+
+        from flyte._environment import list_loaded_environments
+        from flyte._utils import load_python_modules
+
+        console = Console()
+        obj: CLIConfig = ctx.obj
+
+        # Load all python modules
+        loaded_modules, failed_paths = load_python_modules(self.path, self.deploy_args.recursive)
+        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)
+            )
+        else:
+            console.print(f"Loaded {len(loaded_modules)} modules")
+
+        # Get newly loaded environments
+        all_envs = list_loaded_environments()
+        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)
+        )
+
+        if not self.deploy_args.ignore_load_errors and len(failed_paths) > 0:
+            raise click.ClickException(
+                f"Failed to load {len(failed_paths)} files. Use --ignore-load-errors to ignore these errors."
+            )
+        # Now start connection and deploy all environments
+        obj.init(self.deploy_args.project, self.deploy_args.domain)
+        with console.status("Deploying...", spinner="dots"):
+            deployments = flyte.deploy(
+                *all_envs,
+                dryrun=self.deploy_args.dry_run,
+                copy_style=self.deploy_args.copy_style,
+                version=self.deploy_args.version,
+            )
+
+        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)
+        )
 
 
 class EnvPerFileGroup(common.ObjectsPerFileGroup):
@@ -99,8 +192,8 @@ class EnvPerFileGroup(common.ObjectsPerFileGroup):
         obj = cast(flyte.Environment, obj)
         return DeployEnvCommand(
             name=obj_name,
-            obj_name=obj_name,
-            obj=obj,
+            env_name=obj_name,
+            env=obj,
             help=f"{obj.name}" + (f": {obj.description}" if obj.description else ""),
             deploy_args=self.deploy_args,
         )
@@ -116,20 +209,35 @@ class EnvFiles(common.FileGroup):
     def __init__(
         self,
         *args,
+        directory: Path | None = None,
         **kwargs,
     ):
         if "params" not in kwargs:
             kwargs["params"] = []
         kwargs["params"].extend(DeployArguments.options())
-        super().__init__(*args, **kwargs)
+        super().__init__(*args, directory=directory, **kwargs)
 
     def get_command(self, ctx, filename):
         deploy_args = DeployArguments.from_dict(ctx.params)
+        fp = Path(filename)
+        if not fp.exists():
+            raise click.BadParameter(f"File {filename} does not exist")
+        if deploy_args.recursive or deploy_args.all:
+            # If recursive or all, we want to deploy all environments in the current directory
+            return DeployEnvRecursiveCommand(
+                path=fp,
+                deploy_args=deploy_args,
+                name=filename,
+                help="Deploy all loaded environments from the file, or directory (optional recursively)",
+            )
+        if fp.is_dir():
+            # If the path is a directory, we want to deploy all environments in that directory
+            return EnvFiles(directory=fp)
         return EnvPerFileGroup(
-            filename=Path(filename),
+            filename=fp,
             deploy_args=deploy_args,
             name=filename,
-            help=f"Run, functions decorated `env.task` or instances of Tasks in {filename}",
+            help="Deploy a single environment and all its dependencies, from the file.",
         )
 
 

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)

flyte/cli/_run.py

@@ -199,7 +199,7 @@ class TaskFiles(common.FileGroup):
         if fp.is_dir():
             return TaskFiles(directory=fp)
         return TaskPerFileGroup(
-            filename=Path(filename),
+            filename=fp,
             run_args=run_args,
             name=filename,
             help=f"Run, functions decorated with `env.task` in {filename}",

flyte/errors.py

@@ -181,6 +181,16 @@ class ImageBuildError(RuntimeUserError):
         super().__init__("ImageBuildError", message, "user")
 
 
+class ModuleLoadError(RuntimeUserError):
+    """
+    This error is raised when the module cannot be loaded, either because it does not exist or because of a
+     syntax error.
+    """
+
+    def __init__(self, message: str):
+        super().__init__("ModuleLoadError", message, "user")
+
+
 class InlineIOMaxBytesBreached(RuntimeUserError):
     """
     This error is raised when the inline IO max bytes limit is breached.

flyte/models.py

@@ -4,7 +4,7 @@ import inspect
 import os
 import pathlib
 from dataclasses import dataclass, field, replace
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, Dict, Literal, Optional, Tuple, Type
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Dict, List, Literal, Optional, Tuple, Type
 
 import rich.repr
 
@@ -270,6 +270,14 @@ class NativeInterface:
         """
         return self.outputs is not None and len(self.outputs) > 0
 
+    def required_inputs(self) -> List[str]:
+        """
+        Get the names of the required inputs for the task. This is used to determine which inputs are required for the
+        task execution.
+        :return: A list of required input names.
+        """
+        return [k for k, v in self.inputs.items() if v[1] is inspect.Parameter.empty]
+
     def num_required_inputs(self) -> int:
         """
         Get the number of required inputs for the task. This is used to determine how many inputs are required for the

{flyte-2.0.0b4.dist-info → flyte-2.0.0b6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flyte
-Version: 2.0.0b4
+Version: 2.0.0b6
 Summary: Add your description here
 Author-email: Ketan Umare <kumare3@users.noreply.github.com>
 Requires-Python: >=3.10

{flyte-2.0.0b4.dist-info → flyte-2.0.0b6.dist-info}/RECORD

@@ -1,14 +1,14 @@
 flyte/__init__.py,sha256=jWSynBJyJ0WuSjE8HID2MT386ZNlRzx7LzCHW1y_XNw,1468
 flyte/_build.py,sha256=MkgfLAPeL56YeVrGRNZUCZgbwzlEzVP3wLbl5Qru4yk,578
 flyte/_context.py,sha256=K0-TCt-_pHOoE5Xni87_8uIe2vCBOhfNQEtjGT4Hu4k,5239
-flyte/_deploy.py,sha256=HU2ksZUvHj77DrJm7MryN0n26DUJqo4h7-op4fUTBUg,9593
+flyte/_deploy.py,sha256=v4QYa7L9AeFxZh1Ya5Wn8OSPBA3YAX5favQStdD-x-s,10536
 flyte/_doc.py,sha256=_OPCf3t_git6UT7kSJISFaWO9cfNzJhhoe6JjVdyCJo,706
 flyte/_docstring.py,sha256=SsG0Ab_YMAwy2ABJlEo3eBKlyC3kwPdnDJ1FIms-ZBQ,1127
-flyte/_environment.py,sha256=oKVXLBX0ky2eE_wjBdzvQGI_2LiT2Nbx58ur7GMt50c,3231
+flyte/_environment.py,sha256=6ks0lkvGt4oSqM5EFPFlhWC3eoUghxUvCn0wstcAD2E,3713
 flyte/_excepthook.py,sha256=nXts84rzEg6-7RtFarbKzOsRZTQR4plnbWVIFMAEprs,1310
 flyte/_group.py,sha256=7o1j16sZyUmYB50mOiq1ui4TBAKhRpDqLakV8Ya1kw4,803
 flyte/_hash.py,sha256=Of_Zl_DzzzF2jp4ZsLm-3o-xJFCCJ8_GubmLI1htx78,504
-flyte/_image.py,sha256=G6o2z3JY1epk8oSDuUkTbj-5bNuSetC4w-ciG64FoHQ,35322
+flyte/_image.py,sha256=dSChbZeXBSz77wN-AjcXyWLkVUR0kqOtjUuNsflayJM,37310
 flyte/_initialize.py,sha256=xKl_LYMluRt21wWqa6RTKuLo0_DCbSaTfUk27_brtNk,18232
 flyte/_interface.py,sha256=1B9zIwFDjiVp_3l_mk8EpA4g3Re-6DUBEBi9z9vDvPs,3504
 flyte/_logging.py,sha256=QrT4Z30C2tsZ-yIojisQODTuq6Y6zSJYuTrLgF58UYc,3664
@@ -17,18 +17,18 @@ flyte/_pod.py,sha256=--72b0c6IkOEbBwZPLmgl-ll-j7ECfG-kh75LzBnNN8,1068
 flyte/_resources.py,sha256=L2JuvQDlMo1JLJeUmJPRwtWbunhR2xJEhFgQW5yc72c,9690
 flyte/_retry.py,sha256=rfLv0MvWxzPByKESTglEmjPsytEAKiIvvmzlJxXwsfE,941
 flyte/_reusable_environment.py,sha256=f8Y1GilUwGcXH4n2Fckrnx0SrZmhk3nCfoe-TqUKivI,3740
-flyte/_run.py,sha256=HkTD3rHL34pAwvn1WPN6OXYmk-GWX0txLdRH1OIMvEA,24338
+flyte/_run.py,sha256=SSD35ICaYaqt7Ep4SNAi7BLESIullo68g0g4x_dfrW4,25654
 flyte/_secret.py,sha256=89VIihdXI03irHb217GMfipt7jzXBafm17YYmyv6gHo,3245
-flyte/_task.py,sha256=rYR7SVGihfBp7UYrhdmqhHp0ngl2K7Za8IJfhv1K2oc,19402
+flyte/_task.py,sha256=FUqGDtDmhOVPdv-UVko4h0oecoAcc3JZKu8S__cwUpY,19805
 flyte/_task_environment.py,sha256=Zpfr8gjwXg5KuCfIbT4s3l2mtJCFqDxXwv6ZStHWBuc,9840
 flyte/_task_plugins.py,sha256=9MH3nFPOH_e8_92BT4sFk4oyAnj6GJFvaPYWaraX7yE,1037
 flyte/_timeout.py,sha256=zx5sFcbYmjJAJbZWSGzzX-BpC9HC7Jfs35T7vVhKwkk,1571
 flyte/_tools.py,sha256=tWb0sx3t3mm4jbaQVjCTc9y39oR_Ibo3z_KHToP3Lto,966
 flyte/_trace.py,sha256=SSE1nzUgmVTS2xFNtchEOjEjlRavMOIInasXzY8i9lU,4911
-flyte/_version.py,sha256=_khCeGxTPxDDeGWBrQG01YziZI4eo5tW-iu_1TCc42w,519
-flyte/errors.py,sha256=MsVZxq6oeIOXe6AVWpxqA3ZiyxCGM0A6UqnYuvmSUCU,5514
+flyte/_version.py,sha256=c1--_MDUEVzy0HOAoU4GvWafX-tUEg8fSks16cbT7nQ,519
+flyte/errors.py,sha256=DKKw0LVywBNuiWR9WMkODxd_dwWRn-NtyN1TMs6HHd0,5800
 flyte/extend.py,sha256=GB4ZedGzKa30vYWRVPOdxEeK62xnUVFY4z2tD6H9eEw,376
-flyte/models.py,sha256=AJZXL8eRmZ2RHEvjL6VSdpTmgF5S1Ekh_tAKRn0b6mM,15321
+flyte/models.py,sha256=2TgfrkPPgcnnk1P_MO5SEmOYAUbsMKl3gxIDwhW2yEU,15674
 flyte/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 flyte/_bin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 flyte/_bin/runtime.py,sha256=2jTy3ccvrJ__Xrfdo2t0Fxhsojc5o2zIxDHt98RE_eU,6475
@@ -40,7 +40,7 @@ flyte/_code_bundle/__init__.py,sha256=G7DJTQ0UN_ETvdh55pYcWsTrZJKXEcyQl9iQQNQOBX
 flyte/_code_bundle/_ignore.py,sha256=Tfaoa62CQVTH17kBHD6Xv6xEh1FhcAyvXivl9m-MEE0,3853
 flyte/_code_bundle/_packaging.py,sha256=5QUuea6kg9s-ebBg7gFAHaxOMchxR5MhTQ8KohWsjPk,6909
 flyte/_code_bundle/_utils.py,sha256=qlAVmik9rLasfd1oNrCxhL870w5ntk5ZlNGeaKSKaAU,12028
-flyte/_code_bundle/bundle.py,sha256=nUAwYTVAE3Z9dfgkBtsqCoKJImjSl4AicG36yweWHLc,8797
+flyte/_code_bundle/bundle.py,sha256=QbodfyX1RW_V8v0lW8kNwJ8lf4JCL3_uVE43_9ePAzo,8842
 flyte/_internal/__init__.py,sha256=vjXgGzAAjy609YFkAy9_RVPuUlslsHSJBXCLNTVnqOY,136
 flyte/_internal/controllers/__init__.py,sha256=TVAc4ydsldcIFmN3PW9-IX5UkKeD8oOmuIukIgEae9M,4341
 flyte/_internal/controllers/_local_controller.py,sha256=__-eEira0k18DsBu1LBXeEjhFGFcp1Uai9K0YEBbwKM,7300
@@ -53,15 +53,15 @@ flyte/_internal/controllers/remote/_core.py,sha256=PhqI_qwKieH0abOzXYzUZt3v166Dx
 flyte/_internal/controllers/remote/_informer.py,sha256=w4p29_dzS_ns762eNBljvnbJLgCm36d1Ogo2ZkgV1yg,14418
 flyte/_internal/controllers/remote/_service_protocol.py,sha256=B9qbIg6DiGeac-iSccLmX_AL2xUgX4ezNUOiAbSy4V0,1357
 flyte/_internal/imagebuild/__init__.py,sha256=dwXdJ1jMhw9RF8itF7jkPLanvX1yCviSns7hE5eoIts,102
-flyte/_internal/imagebuild/docker_builder.py,sha256=8k8YPqhr22p_SRx3_EaOlaXB67CGWFP3reRdQ0iOS8E,19770
+flyte/_internal/imagebuild/docker_builder.py,sha256=tTA5Wg479ThCB2qwttrZcAqUWBjzzOVUwVg1wNKY4u4,20508
 flyte/_internal/imagebuild/image_builder.py,sha256=dXBXl62qcPabus6dR3eP8P9mBGNhpZHZ2Xm12AymKkk,11150
-flyte/_internal/imagebuild/remote_builder.py,sha256=vxPhosMbFXQGQY0Um6il4C8I4vZEWsDyBK3uJQN3icg,10602
+flyte/_internal/imagebuild/remote_builder.py,sha256=oP8JgnkRgkEMvIdcakxvXjOZiKEYyt5h6CvgEbakSAM,11016
 flyte/_internal/resolvers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 flyte/_internal/resolvers/_task_module.py,sha256=jwy1QYygUK7xmpCZLt1SPTfJCkfox3Ck3mTlTsm66UI,1973
 flyte/_internal/resolvers/common.py,sha256=ADQLRoyGsJ4vuUkitffMGrMKKjy0vpk6X53g4FuKDLc,993
 flyte/_internal/resolvers/default.py,sha256=nX4DHUYod1nRvEsl_vSgutQVEdExu2xL8pRkyi4VWbY,981
 flyte/_internal/runtime/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-flyte/_internal/runtime/convert.py,sha256=yK5Fy25-CVSqTtWF8BuBel2jwlVoh8R5F4UhIMYpgmg,16086
+flyte/_internal/runtime/convert.py,sha256=dX3PfIhuYvuCpRAFGRo-uTRy8Ys3Rgs9cowO6XUjHMo,15951
 flyte/_internal/runtime/entrypoints.py,sha256=9Ng-aQ45M-_MMWeOe9uGmgx69qO9b0xaMRiu542ZI9g,6581
 flyte/_internal/runtime/io.py,sha256=ysL7hMpfVumvsEYWOM-_VPa8MXn5_X_CZorKbOThyv4,5935
 flyte/_internal/runtime/resources_serde.py,sha256=TObMVsSjVcQhcY8-nY81pbvrz7TP-adDD5xV-LqAaxM,4813
@@ -145,26 +145,27 @@ flyte/_protos/workflow/task_definition_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8g
 flyte/_protos/workflow/task_service_pb2.py,sha256=7kCVgR8Is9MzlbdoGd1kVCwz1ot39r2qyY3oZzE_Xuo,5781
 flyte/_protos/workflow/task_service_pb2.pyi,sha256=W0OZWui3TbQANi0GL7lCVmbpJKRwJ0X-8vjXj1qNP5k,3100
 flyte/_protos/workflow/task_service_pb2_grpc.py,sha256=whmfmOTiNhz6_CBsXm8aXUCwtA5bncOikqKYz-bKdok,5992
-flyte/_utils/__init__.py,sha256=RByuYa2hSqsKrpLkFfjKspKxH3K7DzfVzTVnZsxkO0A,757
+flyte/_utils/__init__.py,sha256=Lwn9_fLxNF4YR0oCUIKCwM_aXYT5UFjUFInofTHnQTs,831
 flyte/_utils/asyn.py,sha256=KeJKarXNIyD16g6oPM0T9cH7JDmh1KY7JLbwo7i0IlQ,3673
 flyte/_utils/async_cache.py,sha256=JtZJmWO62OowJ0QFNl6wryWqh-kuDi76aAASMie87QY,4596
 flyte/_utils/coro_management.py,sha256=wIsul4XY-tQbH9bjqZ3A0jKluE19xSzLlkMeYu_dk_A,934
 flyte/_utils/file_handling.py,sha256=iU4TxW--fCho_Eg5xTMODn96P03SxzF-V-5f-7bZAZY,2233
 flyte/_utils/helpers.py,sha256=9N70yzfLF4lLGEEdOv5OcweEpYtrCvZqqhtzkjZUXNY,4779
 flyte/_utils/lazy_module.py,sha256=fvXPjvZLzCfcI8Vzs4pKedUDdY0U_RQ1ZVrp9b8qBQY,1994
+flyte/_utils/module_loader.py,sha256=XDmK2qndI2Lx-7JUvPi0LW33_zr5HgCgt-FsyXJzccI,3124
 flyte/_utils/org_discovery.py,sha256=C7aJa0LfnWBkDtSU9M7bE60zp27qEhJC58piqOErZ94,2088
 flyte/_utils/uv_script_parser.py,sha256=PxqD8lSMi6xv0uDd1s8LKB2IPZr4ttZJCUweqlyMTKk,1483
 flyte/cli/__init__.py,sha256=aeCcumeP9xD_5aCmaRYUPCe2QRJSGCaxcUbTZ3co768,341
 flyte/cli/_abort.py,sha256=Ty-63Gtd2PUn6lCuL5AaasfBoPu7TDSU5EQKVbkF4qw,661
 flyte/cli/_build.py,sha256=SBgybTVWOZ22VBHFL8CVFB_oo34lF9wvlwNirYFFyk0,3543
-flyte/cli/_common.py,sha256=k5_DwLNm2Nqps99ry3Bkbnw9tVxeQd3Ya7fSpReaUn4,12315
+flyte/cli/_common.py,sha256=SLY3M7ganzLCf2MaybJFRkk677IoZrkZKjIR5Qoc0cE,12542
 flyte/cli/_create.py,sha256=Rv_Ox_OA9TqdSI6zaTzLp9vwiqOanOk-Oasnbgx1Q3M,5081
 flyte/cli/_delete.py,sha256=VTmXv09PBjkdtyl23mbSjIQQlN7Y1AI_bO0GkHP-f9E,546
-flyte/cli/_deploy.py,sha256=Zxm7vn1zrqmll73CJTiVGYJI95P-XBI1AlhOlmbmkD0,4635
-flyte/cli/_gen.py,sha256=vlE5l8UR1zz4RSdaRyUfYFvGR0TLxGcTYcP4dhA3Pvg,5458
+flyte/cli/_deploy.py,sha256=h-laMIbqNskxPzqtBNxIhgamjt2MxGoNongi9_nTQbo,8939
+flyte/cli/_gen.py,sha256=ni3E65_wSBc9x5NNbq1REuxfZCJz-ioLMVQnZIgwyYg,5745
 flyte/cli/_get.py,sha256=fvoJaBmZuD4sDs33dMo94dvBJVk3MaWPJe24e3cG0Ps,10200
 flyte/cli/_params.py,sha256=8Gj8UYGHwu-SUXGWCTRX5QsVf19NiajhaUMMae6FF9o,19466
-flyte/cli/_run.py,sha256=fyxGt5ZbW84EcjPVJq5ADK4254kzYHUa2ggp7MRKarI,7776
+flyte/cli/_run.py,sha256=x1BRMK4M0kUboZVOKNuufi8B0cFjsOE7b36zbHT40Cc,7764
 flyte/cli/main.py,sha256=9sLH-xaGdF9HamUQrTxmGTGNScdCtBfNmyYyPHiW3vU,5180
 flyte/config/__init__.py,sha256=MiwEYK5Iv7MRR22z61nzbsbvZ9Q6MdmAU_g9If1Pmb8,144
 flyte/config/_config.py,sha256=WElU--Kw4MM9zx1v-rLD8qYu2T5Zk0-1QbTpkEc27bc,10779
@@ -226,10 +227,10 @@ 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=Tas_OXYddOi0nDuORjqan2SkJ96wKD8937I2l1bo8vk,97916
 flyte/types/_utils.py,sha256=pbts9E1_2LTdLygAY0UYTLYJ8AsN3BZyviSXvrtcutc,2626
-flyte-2.0.0b4.data/scripts/runtime.py,sha256=2jTy3ccvrJ__Xrfdo2t0Fxhsojc5o2zIxDHt98RE_eU,6475
-flyte-2.0.0b4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-flyte-2.0.0b4.dist-info/METADATA,sha256=hrYyZeScWhM_utQk4oz22SQDBQi6V4W5OqOa2rRnSTw,10004
-flyte-2.0.0b4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-flyte-2.0.0b4.dist-info/entry_points.txt,sha256=MIq2z5dBurdCJfpXfMKzgBv7sJOakKRYxr8G0cMiTrg,75
-flyte-2.0.0b4.dist-info/top_level.txt,sha256=7dkyFbikvA12LEZEqawx8oDG1CMod6hTliPj7iWzgYo,6
-flyte-2.0.0b4.dist-info/RECORD,,
+flyte-2.0.0b6.data/scripts/runtime.py,sha256=2jTy3ccvrJ__Xrfdo2t0Fxhsojc5o2zIxDHt98RE_eU,6475
+flyte-2.0.0b6.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+flyte-2.0.0b6.dist-info/METADATA,sha256=AfK1udiYYhGWg2MmKRBZGsVOe7Ff3QrPdMozeqv3feY,10004
+flyte-2.0.0b6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+flyte-2.0.0b6.dist-info/entry_points.txt,sha256=MIq2z5dBurdCJfpXfMKzgBv7sJOakKRYxr8G0cMiTrg,75
+flyte-2.0.0b6.dist-info/top_level.txt,sha256=7dkyFbikvA12LEZEqawx8oDG1CMod6hTliPj7iWzgYo,6
+flyte-2.0.0b6.dist-info/RECORD,,