flyte 2.0.0b25__py3-none-any.whl → 2.0.0b28__py3-none-any.whl

flyte/__init__.py

@@ -16,6 +16,7 @@ from ._excepthook import custom_excepthook
 from ._group import group
 from ._image import Image
 from ._initialize import current_domain, init, init_from_config
+from ._logging import logger
 from ._map import map
 from ._pod import PodTemplate
 from ._resources import AMD_GPU, GPU, HABANA_GAUDI, TPU, Device, DeviceClass, Neuron, Resources
@@ -97,6 +98,7 @@ __all__ = [
     "group",
     "init",
     "init_from_config",
+    "logger",
     "map",
     "run",
     "trace",

flyte/_bin/runtime.py

@@ -12,6 +12,7 @@ from typing import Any, List
 
 import click
 
+from flyte._utils.helpers import str2bool
 from flyte.models import PathRewrite
 
 # Todo: work with pvditt to make these the names
@@ -27,6 +28,7 @@ PROJECT_NAME = "FLYTE_INTERNAL_EXECUTION_PROJECT"
 DOMAIN_NAME = "FLYTE_INTERNAL_EXECUTION_DOMAIN"
 ORG_NAME = "_U_ORG_NAME"
 ENDPOINT_OVERRIDE = "_U_EP_OVERRIDE"
+INSECURE_SKIP_VERIFY_OVERRIDE = "_U_INSECURE_SKIP_VERIFY"
 RUN_OUTPUT_BASE_DIR = "_U_RUN_BASE"
 FLYTE_ENABLE_VSCODE_KEY = "_F_E_VS"
 
@@ -139,6 +141,12 @@ def main(
             controller_kwargs["insecure"] = True
         logger.debug(f"Using controller endpoint: {ep} with kwargs: {controller_kwargs}")
 
+    # Check for insecure_skip_verify override (e.g. for self-signed certs)
+    insecure_skip_verify_str = os.getenv(INSECURE_SKIP_VERIFY_OVERRIDE, "")
+    if str2bool(insecure_skip_verify_str):
+        controller_kwargs["insecure_skip_verify"] = True
+        logger.info("SSL certificate verification disabled (insecure_skip_verify=True)")
+
     bundle = None
     if tgz or pkl:
         bundle = CodeBundle(tgz=tgz, pkl=pkl, destination=dest, computed_version=version)

flyte/_code_bundle/_utils.py

@@ -193,10 +193,10 @@ def list_all_files(source_path: pathlib.Path, deref_symlinks, ignore_group: Opti
 def _file_is_in_directory(file: str, directory: str) -> bool:
     """Return True if file is in directory and in its children."""
     try:
-        return os.path.commonpath([file, directory]) == directory
-    except ValueError as e:
-        # ValueError is raised by windows if the paths are not from the same drive
-        logger.debug(f"{file} and {directory} are not in the same drive: {e!s}")
+        return pathlib.Path(file).resolve().is_relative_to(pathlib.Path(directory).resolve())
+    except OSError as e:
+        # OSError can be raised if paths cannot be resolved (permissions, broken symlinks, etc.)
+        logger.debug(f"Failed to resolve paths for {file} and {directory}: {e!s}")
         return False
 
 

flyte/_code_bundle/bundle.py

@@ -104,7 +104,7 @@ async def build_pkl_bundle(
                 import shutil
 
                 # Copy the bundle to the given path
-                shutil.copy(dest, copy_bundle_to)
+                shutil.copy(dest, copy_bundle_to, follow_symlinks=True)
                 local_path = copy_bundle_to / dest.name
                 return CodeBundle(pkl=str(local_path), computed_version=str_digest)
             return CodeBundle(pkl=str(dest), computed_version=str_digest)

flyte/_constants.py

@@ -0,0 +1 @@
+FLYTE_SYS_PATH = "_F_SYS_PATH"  # The paths that will be appended to sys.path at runtime

flyte/_deploy.py

@@ -255,7 +255,6 @@ async def _build_images(deployment: DeploymentPlan, image_refs: Dict[str, str] |
 
     for env_name, image_uri in final_images:
         logger.warning(f"Built Image for environment {env_name}, image: {image_uri}")
-        env = deployment.envs[env_name]
         image_identifier_map[env_name] = image_uri
 
     return ImageCache(image_lookup=image_identifier_map)

flyte/_excepthook.py

@@ -33,5 +33,5 @@ def custom_excepthook(exc_type, exc_value, exc_tb):
         filtered_tb = [frame for frame in tb_list if should_include_frame(frame)]
         # Print the filtered version (custom format)
         print("Filtered traceback (most recent call last):")
-        traceback.print_tb(filtered_tb)
+        traceback.print_list(filtered_tb)
         print(f"{exc_type.__name__}: {exc_value}\n")

flyte/_initialize.py

@@ -34,6 +34,7 @@ class CommonInit:
     domain: str | None = None
     batch_size: int = 1000
     source_config_path: Optional[Path] = None  # Only used for documentation
+    sync_local_sys_paths: bool = True
 
 
 @dataclass(init=True, kw_only=True, repr=True, eq=True, frozen=True)
@@ -144,6 +145,7 @@ async def init(
     image_builder: ImageBuildEngine.ImageBuilderType = "local",
     images: typing.Dict[str, str] | None = None,
     source_config_path: Optional[Path] = None,
+    sync_local_sys_paths: bool = True,
 ) -> None:
     """
     Initialize the Flyte system with the given configuration. This method should be called before any other Flyte
@@ -180,6 +182,8 @@ async def init(
     :param image_builder: Optional image builder configuration, if not provided, the default image builder will be used.
     :param images: Optional dict of images that can be used by referencing the image name.
     :param source_config_path: Optional path to the source configuration file (This is only used for documentation)
+    :param sync_local_sys_paths: Whether to include and synchronize local sys.path entries under the root directory
+     into the remote container (default: True).
     :return: None
     """
     from flyte._utils import get_cwd_editable_install, org_from_endpoint, sanitize_endpoint
@@ -230,6 +234,7 @@ async def init(
             image_builder=image_builder,
             images=images or {},
             source_config_path=source_config_path,
+            sync_local_sys_paths=sync_local_sys_paths,
         )
 
 
@@ -240,6 +245,7 @@ async def init_from_config(
     log_level: int | None = None,
     storage: Storage | None = None,
     images: tuple[str, ...] | None = None,
+    sync_local_sys_paths: bool = True,
 ) -> None:
     """
     Initialize the Flyte system using a configuration file or Config object. This method should be called before any
@@ -253,6 +259,9 @@ async def init_from_config(
     :param log_level: Optional logging level for the framework logger,
         default is set using the default initialization policies
     :param storage: Optional blob store (S3, GCS, Azure) configuration if needed to access (i.e. using Minio)
+    :param images: List of image strings in format "imagename=imageuri" or just "imageuri".
+    :param sync_local_sys_paths: Whether to include and synchronize local sys.path entries under the root directory
+     into the remote container (default: True).
     :return: None
     """
     from rich.highlighter import ReprHighlighter
@@ -306,6 +315,7 @@ async def init_from_config(
         images=cfg.image.image_refs,
         storage=storage,
         source_config_path=cfg_path,
+        sync_local_sys_paths=sync_local_sys_paths,
     )
 
 

flyte/_interface.py

@@ -51,6 +51,8 @@ def extract_return_annotation(return_annotation: Union[Type, Tuple, None]) -> Di
     Note that Options 1 and 2 are identical, just syntactic sugar. In the NamedTuple case, we'll use the names in the
     definition. In all other cases, we'll automatically generate output names, indexed starting at 0.
     """
+    if isinstance(return_annotation, str):
+        raise TypeError("String return annotations are not supported.")
 
     # Handle Option 6
     # We can think about whether we should add a default output name with type None in the future.

flyte/_internal/imagebuild/docker_builder.py

@@ -47,7 +47,7 @@ FLYTE_DOCKER_BUILDER_CACHE_TO = "FLYTE_DOCKER_BUILDER_CACHE_TO"
 
 UV_LOCK_WITHOUT_PROJECT_INSTALL_TEMPLATE = Template("""\
 RUN --mount=type=cache,sharing=locked,mode=0777,target=/root/.cache/uv,id=uv \
-   --mount=type=bind,target=uv.lock,src=$UV_LOCK_PATH \
+   --mount=type=bind,target=uv.lock,src=$UV_LOCK_PATH,rw \
    --mount=type=bind,target=pyproject.toml,src=$PYPROJECT_PATH \
    $SECRET_MOUNT \
    uv sync --active --inexact $PIP_INSTALL_ARGS
@@ -271,6 +271,8 @@ class UVProjectHandler:
             pip_install_args = " ".join(layer.get_pip_install_args())
             if "--no-install-project" not in pip_install_args:
                 pip_install_args += " --no-install-project"
+            if "--no-sources" not in pip_install_args:
+                pip_install_args += " --no-sources"
             # Only Copy pyproject.yaml and uv.lock.
             pyproject_dst = copy_files_to_context(layer.pyproject, context_path)
             uvlock_dst = copy_files_to_context(layer.uvlock, context_path)

flyte/_internal/imagebuild/remote_builder.py

@@ -134,7 +134,7 @@ class RemoteImageBuilder(ImageBuilder):
         if run_details.action_details.raw_phase == run_definition_pb2.PHASE_SUCCEEDED:
             logger.warning(f"[bold green]✅ Build completed in {elapsed}![/bold green]")
         else:
-            raise flyte.errors.ImageBuildError(f"❌ Build failed in {elapsed} at [cyan]{run.url}[/cyan]")
+            raise flyte.errors.ImageBuildError(f"❌ Build failed in {elapsed} at {run.url}")
 
         outputs = await run_details.outputs()
         return _get_fully_qualified_image_name(outputs)
@@ -272,6 +272,8 @@ def _get_layers_proto(image: Image, context_path: Path) -> "image_definition_pb2
                         pip_options.extra_args += " --no-install-project"
                 else:
                     pip_options.extra_args = " --no-install-project"
+                if "--no-sources" not in pip_options.extra_args:
+                    pip_options.extra_args += " --no-sources"
             else:
                 # Copy the entire project
                 docker_ignore_patterns = get_and_list_dockerignore(image)

flyte/_internal/resolvers/_task_module.py

@@ -1,9 +1,7 @@
-import inspect
-import os
 import pathlib
-import sys
 from typing import Tuple
 
+from flyte._module import extract_obj_module
 from flyte._task import AsyncFunctionTaskTemplate, TaskTemplate
 
 
@@ -15,40 +13,9 @@ def extract_task_module(task: TaskTemplate, /, source_dir: pathlib.Path | None =
     :param source_dir: The source directory to use for relative paths.
     :return: A tuple containing the entity name, module
     """
-    entity_name = task.name
     if isinstance(task, AsyncFunctionTaskTemplate):
-        entity_module = inspect.getmodule(task.func)
-        if entity_module is None:
-            raise ValueError(f"Task {entity_name} has no module.")
-
-        fp = entity_module.__file__
-        if fp is None:
-            raise ValueError(f"Task {entity_name} has no module.")
-
-        file_path = pathlib.Path(fp)
-        # Get the relative path to the current directory
-        # Will raise ValueError if the file is not in the source directory
-        relative_path = file_path.relative_to(str(source_dir))
-
-        if relative_path == pathlib.Path("."):
-            entity_module_name = entity_module.__name__
-        else:
-            # Replace file separators with dots and remove the '.py' extension
-            dotted_path = os.path.splitext(str(relative_path))[0].replace(os.sep, ".")
-            entity_module_name = dotted_path
-
         entity_name = task.func.__name__
+        entity_module_name = extract_obj_module(task.func, source_dir)
+        return entity_name, entity_module_name
     else:
-        raise NotImplementedError(f"Task module {entity_name} not implemented.")
-
-    if entity_module_name == "__main__":
-        """
-        This case is for the case in which the task is run from the main module.
-        """
-        fp = sys.modules["__main__"].__file__
-        if fp is None:
-            raise ValueError(f"Task {entity_name} has no module.")
-        main_path = pathlib.Path(fp)
-        entity_module_name = main_path.stem
-
-    return entity_name, entity_module_name
+        raise NotImplementedError(f"Task module {task.name} not implemented.")

flyte/_internal/runtime/convert.py

@@ -143,13 +143,14 @@ async def convert_from_native_to_inputs(
             (default_value is not None and default_value is not inspect.Signature.empty)
             or (default_value is None and is_optional_type(input_type))
             or input_type is None
+            or input_type is type(None)
         ):
             if default_value == NativeInterface.has_default:
                 if interface._remote_defaults is None or input_name not in interface._remote_defaults:
                     raise ValueError(f"Input '{input_name}' has a default value but it is not set in the interface.")
                 already_converted_kwargs[input_name] = interface._remote_defaults[input_name]
-            elif input_type is None:
-                # If the type is None, we assume it's a placeholder for no type
+            elif input_type is None or input_type is type(None):
+                # If the type is 'None' or 'class<None>', we assume it's a placeholder for no type
                 kwargs[input_name] = None
                 type_hints[input_name] = NoneType
             else:

flyte/_internal/runtime/entrypoints.py

@@ -1,4 +1,6 @@
 import importlib
+import os
+import traceback
 from typing import List, Optional, Tuple, Type
 
 import flyte.errors
@@ -10,6 +12,7 @@ from flyte._logging import log, logger
 from flyte._task import TaskTemplate
 from flyte.models import ActionID, Checkpoints, CodeBundle, RawDataPath
 
+from ..._utils import adjust_sys_path
 from .convert import Error, Inputs, Outputs
 from .taskrunner import (
     convert_and_run,
@@ -72,7 +75,26 @@ def load_task(resolver: str, *resolver_args: str) -> TaskTemplate:
     """
     resolver_class = load_class(resolver)
     resolver_instance = resolver_class()
-    return resolver_instance.load_task(resolver_args)
+    try:
+        return resolver_instance.load_task(resolver_args)
+    except ModuleNotFoundError as e:
+        cwd = os.getcwd()
+        files = []
+        try:
+            for root, dirs, filenames in os.walk(cwd):
+                for name in dirs + filenames:
+                    rel_path = os.path.relpath(os.path.join(root, name), cwd)
+                    files.append(rel_path)
+        except Exception as list_err:
+            files = [f"(Failed to list directory: {list_err})"]
+
+        msg = (
+            "\n\nFull traceback:\n" + "".join(traceback.format_exc()) + f"\n[ImportError Diagnostics]\n"
+            f"Module '{e.name}' not found in either the Python virtual environment or the current working directory.\n"
+            f"Current working directory: {cwd}\n"
+            f"Files found under current directory:\n" + "\n".join(f"  - {f}" for f in files)
+        )
+        raise ModuleNotFoundError(msg) from e
 
 
 def load_pkl_task(code_bundle: CodeBundle) -> TaskTemplate:
@@ -100,6 +122,7 @@ async def download_code_bundle(code_bundle: CodeBundle) -> CodeBundle:
     :param code_bundle: The code bundle to download.
     :return: The code bundle with the downloaded path.
     """
+    adjust_sys_path()
     logger.debug(f"Downloading {code_bundle}")
     downloaded_path = await download_bundle(code_bundle)
     return code_bundle.with_downloaded_path(downloaded_path)

flyte/_internal/runtime/rusty.py

@@ -1,5 +1,4 @@
 import asyncio
-import sys
 import time
 from typing import Any, List, Tuple
 
@@ -11,6 +10,7 @@ from flyte._internal.runtime.entrypoints import download_code_bundle, load_pkl_t
 from flyte._internal.runtime.taskrunner import extract_download_run_upload
 from flyte._logging import logger
 from flyte._task import TaskTemplate
+from flyte._utils import adjust_sys_path
 from flyte.models import ActionID, Checkpoints, CodeBundle, PathRewrite, RawDataPath
 
 
@@ -23,7 +23,7 @@ async def download_tgz(destination: str, version: str, tgz: str) -> CodeBundle:
     :return: The CodeBundle object.
     """
     logger.info(f"[rusty] Downloading tgz code bundle from {tgz} to {destination} with version {version}")
-    sys.path.insert(0, ".")
+    adjust_sys_path()
 
     code_bundle = CodeBundle(
         tgz=tgz,
@@ -42,7 +42,7 @@ async def download_load_pkl(destination: str, version: str, pkl: str) -> Tuple[C
     :return: The CodeBundle object.
     """
     logger.info(f"[rusty] Downloading pkl code bundle from {pkl} to {destination} with version {version}")
-    sys.path.insert(0, ".")
+    adjust_sys_path()
 
     code_bundle = CodeBundle(
         pkl=pkl,

flyte/_internal/runtime/task_serde.py

@@ -221,10 +221,25 @@ def _get_urun_container(
         # This computes the image uri, computing hashes as necessary so can fail if done remotely.
         img_uri = task_template.image.uri
     elif serialize_context.image_cache and env_name not in serialize_context.image_cache.image_lookup:
-        img_uri = task_template.image.uri
-
-        logger.warning(
-            f"Image {task_template.image} not found in the image cache: {serialize_context.image_cache.image_lookup}."
+        raise flyte.errors.RuntimeUserError(
+            "MissingEnvironment",
+            f"Environment '{env_name}' not found in image cache.\n\n"
+            "💡 To fix this:\n"
+            "  1. If your parent environment calls a task in another environment,"
+            " declare that dependency using 'depends_on=[...]'.\n"
+            "     Example:\n"
+            "         env1 = flyte.TaskEnvironment(\n"
+            "             name='outer',\n"
+            "             image=flyte.Image.from_debian_base().with_pip_packages('requests'),\n"
+            "             depends_on=[env2, env3],\n"
+            "         )\n"
+            "  2. If you're using os.getenv() to set the environment name,"
+            " make sure the runtime environment has the same environment variable defined.\n"
+            "     Example:\n"
+            "         env = flyte.TaskEnvironment(\n"
+            '             name=os.getenv("my-name"),\n'
+            '             env_vars={"my-name": os.getenv("my-name")},\n'
+            "         )\n",
         )
     else:
         img_uri = serialize_context.image_cache.image_lookup[env_name]

flyte/_internal/runtime/trigger_serde.py

@@ -12,7 +12,7 @@ from flyte import Cron, FixedRate, Trigger, TriggerTime
 def _to_schedule(m: Union[Cron, FixedRate], kickoff_arg_name: str | None = None) -> common_pb2.Schedule:
     if isinstance(m, Cron):
         return common_pb2.Schedule(
-            cron_expression=m.expression,
+            cron_expression=m.timezone_expression,
             kickoff_time_input_arg=kickoff_arg_name,
         )
     elif isinstance(m, FixedRate):
@@ -147,7 +147,7 @@ async def to_task_trigger(
             inputs=common_pb2.Inputs(literals=literals),
         ),
         automation_spec=common_pb2.TriggerAutomationSpec(
-            type=common_pb2.TriggerAutomationSpec.Type.TYPE_SCHEDULE,
+            type=common_pb2.TriggerAutomationSpecType.TYPE_SCHEDULE,
             schedule=automation,
         ),
     )

flyte/_map.py

@@ -189,7 +189,7 @@ class _Mapper(Generic[P, R]):
         group_name: str | None = None,
         concurrency: int = 0,
         return_exceptions: bool = True,
-    ) -> Iterator[R]: ...
+    ) -> Iterator[Union[R, Exception]]: ...
 
     def __call__(
         self,
@@ -309,37 +309,4 @@ async def _map(
         yield result
 
 
-@overload
-def map(
-    func: AsyncFunctionTaskTemplate[P, R, F] | functools.partial[R],
-    *args: Iterable[Any],
-    group_name: str | None = None,
-    concurrency: int = 0,
-) -> Iterator[R]: ...
-
-
-@overload
-def map(
-    func: AsyncFunctionTaskTemplate[P, R, F] | functools.partial[R],
-    *args: Iterable[Any],
-    group_name: str | None = None,
-    concurrency: int = 0,
-    return_exceptions: bool = True,
-) -> Iterator[Union[R, Exception]]: ...
-
-
-def map(
-    func: AsyncFunctionTaskTemplate[P, R, F] | functools.partial[R],
-    *args: Iterable[Any],
-    group_name: str | None = None,
-    concurrency: int = 0,
-    return_exceptions: bool = True,
-) -> Iterator[Union[R, Exception]]:
-    map: _Mapper = _Mapper()
-    return map(
-        func,
-        *args,
-        group_name=group_name,
-        concurrency=concurrency,
-        return_exceptions=return_exceptions,
-    )
+map: _Mapper = _Mapper()

flyte/_module.py

@@ -0,0 +1,68 @@
+import inspect
+import os
+import pathlib
+import sys
+
+
+def extract_obj_module(obj: object, /, source_dir: pathlib.Path | None = None) -> str:
+    """
+    Extract the module from the given object. If source_dir is provided, the module will be relative to the source_dir.
+
+    Args:
+        obj: The object to extract the module from.
+        source_dir: The source directory to use for relative paths.
+
+    Returns:
+        The module name as a string.
+    """
+    # Get the module containing the object
+    entity_module = inspect.getmodule(obj)
+    if entity_module is None:
+        obj_name = getattr(obj, "__name__", str(obj))
+        raise ValueError(f"Object {obj_name} has no module.")
+
+    fp = entity_module.__file__
+    if fp is None:
+        obj_name = getattr(obj, "__name__", str(obj))
+        raise ValueError(f"Object {obj_name} has no module.")
+
+    file_path = pathlib.Path(fp)
+    try:
+        # Get the relative path to the current directory
+        # Will raise ValueError if the file is not in the source directory
+        relative_path = file_path.relative_to(str(source_dir))
+
+        if relative_path == pathlib.Path("_internal/resolvers"):
+            entity_module_name = entity_module.__name__
+        else:
+            # Replace file separators with dots and remove the '.py' extension
+            dotted_path = os.path.splitext(str(relative_path))[0].replace(os.sep, ".")
+            entity_module_name = dotted_path
+    except ValueError:
+        # If source_dir is not provided or file is not in source_dir, fallback to module name
+        # File is not relative to source_dir - check if it's an installed package
+        file_path_str = str(file_path)
+        if "site-packages" in file_path_str or "dist-packages" in file_path_str:
+            # It's an installed package - use the module's __name__ directly
+            # This will be importable via importlib.import_module()
+            entity_module_name = entity_module.__name__
+        else:
+            # File is not in source_dir and not in site-packages - re-raise the error
+            obj_name = getattr(obj, "__name__", str(obj))
+            raise ValueError(
+                f"Object {obj_name} module file {file_path} is not relative to "
+                f"source directory {source_dir} and is not an installed package."
+            )
+
+    if entity_module_name == "__main__":
+        """
+        This case is for the case in which the object is run from the main module.
+        """
+        fp = sys.modules["__main__"].__file__
+        if fp is None:
+            obj_name = getattr(obj, "__name__", str(obj))
+            raise ValueError(f"Object {obj_name} has no module.")
+        main_path = pathlib.Path(fp)
+        entity_module_name = main_path.stem
+
+    return entity_module_name

flyte/_resources.py

@@ -148,16 +148,54 @@ Accelerators = Literal[
     "T4:8",
     # Trn1
     "Trn1:1",
+    "Trn1:4",
+    "Trn1:8",
+    "Trn1:16",
     # Trn1n
     "Trn1n:1",
+    "Trn1n:4",
+    "Trn1n:8",
+    "Trn1n:16",
     # Trn2
     "Trn2:1",
+    "Trn2:4",
+    "Trn2:8",
+    "Trn2:16",
     # Trn2u
     "Trn2u:1",
+    "Trn2u:4",
+    "Trn2u:8",
+    "Trn2u:16",
     # Inf1
     "Inf1:1",
+    "Inf1:2",
+    "Inf1:3",
+    "Inf1:4",
+    "Inf1:5",
+    "Inf1:6",
+    "Inf1:7",
+    "Inf1:8",
+    "Inf1:9",
+    "Inf1:10",
+    "Inf1:11",
+    "Inf1:12",
+    "Inf1:13",
+    "Inf1:14",
+    "Inf1:15",
+    "Inf1:16",
     # Inf2
     "Inf2:1",
+    "Inf2:2",
+    "Inf2:3",
+    "Inf2:4",
+    "Inf2:5",
+    "Inf2:6",
+    "Inf2:7",
+    "Inf2:8",
+    "Inf2:9",
+    "Inf2:10",
+    "Inf2:11",
+    "Inf2:12",
     # MI100
     "MI100:1",
     # MI210

flyte/_run.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import pathlib
+import sys
 import uuid
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Tuple, Union, cast
@@ -29,6 +30,8 @@ from flyte.models import (
 )
 from flyte.syncify import syncify
 
+from ._constants import FLYTE_SYS_PATH
+
 if TYPE_CHECKING:
     from flyte.remote import Run
     from flyte.remote._task import LazyEntity
@@ -131,7 +134,7 @@ class _Runner:
     async def _run_remote(self, obj: TaskTemplate[P, R, F] | LazyEntity, *args: P.args, **kwargs: P.kwargs) -> Run:
         import grpc
         from flyteidl2.common import identifier_pb2
-        from flyteidl2.core import literals_pb2
+        from flyteidl2.core import literals_pb2, security_pb2
         from flyteidl2.task import run_pb2
         from flyteidl2.workflow import run_definition_pb2, run_service_pb2
         from google.protobuf import wrappers_pb2
@@ -172,9 +175,7 @@ class _Runner:
                 if not self._dry_run:
                     image_cache = await build_images.aio(cast(Environment, obj.parent_env()))
                 else:
-                    from ._internal.imagebuild.image_builder import ImageCache
-
-                    image_cache = ImageCache(image_lookup={})
+                    image_cache = None
 
                 if self._interactive_mode:
                     code_bundle = await build_pkl_bundle(
@@ -220,6 +221,12 @@ class _Runner:
             else:
                 env["LOG_LEVEL"] = str(logger.getEffectiveLevel())
 
+        # These paths will be appended to sys.path at runtime.
+        if cfg.sync_local_sys_paths:
+            env[FLYTE_SYS_PATH] = ":".join(
+                f"./{pathlib.Path(p).relative_to(cfg.root_dir)}" for p in sys.path if p.startswith(str(cfg.root_dir))
+            )
+
         if not self._dry_run:
             if get_client() is None:
                 # This can only happen, if the user forces flyte.run(mode="remote") without initializing the client
@@ -264,6 +271,14 @@ class _Runner:
             env_kv = run_pb2.Envs(values=kv_pairs)
             annotations = run_pb2.Annotations(values=self._annotations)
             labels = run_pb2.Labels(values=self._labels)
+            raw_data_storage = (
+                run_pb2.RawDataStorage(raw_data_prefix=self._raw_data_path) if self._raw_data_path else None
+            )
+            security_context = (
+                security_pb2.SecurityContext(run_as=security_pb2.Identity(k8s_service_account=self._service_account))
+                if self._service_account
+                else None
+            )
 
             try:
                 resp = await get_client().run_service.CreateRun(
@@ -281,6 +296,8 @@ class _Runner:
                             labels=labels,
                             envs=env_kv,
                             cluster=self._queue or task.queue,
+                            raw_data_storage=raw_data_storage,
+                            security_context=security_context,
                         ),
                     ),
                 )
@@ -613,8 +630,8 @@ def with_runcontext(
     :param interactive_mode: Optional, can be forced to True or False.
          If not provided, it will be set based on the current environment. For example Jupyter notebooks are considered
          interactive mode, while scripts are not. This is used to determine how the code bundle is created.
-    :param raw_data_path: Use this path to store the raw data for the run. Currently only supported for local runs,
-      and can be used to store raw data in specific locations. TODO coming soon for remote runs as well.
+    :param raw_data_path: Use this path to store the raw data for the run for local and remote, and can be used to
+         store raw data in specific locations.
     :param run_base_dir: Optional The base directory to use for the run. This is used to store the metadata for the run,
      that is passed between tasks.
     :param overwrite_cache: Optional If true, the cache will be overwritten for the run