flyte 0.0.1b0__py3-none-any.whl

flyte/_resources.py

@@ -0,0 +1,226 @@
+from dataclasses import dataclass
+from typing import Literal, Optional, Tuple, Union, get_args
+
+import rich.repr
+
+GPUType = Literal["T4", "A100", "A100 80G", "H100", "L4", "L40s"]
+GPUQuantity = Literal[1, 2, 3, 4, 5, 6, 7, 8]
+A100Parts = Literal["1g.5gb", "2g.10gb", "3g.20gb", "4g.20gb", "7g.40gb"]
+"""
+Partitions for NVIDIA A100 GPU.
+"""
+
+A100_80GBParts = Literal["1g.10gb", "2g.20gb", "3g.40gb", "4g.40gb", "7g.80gb"]
+"""
+Partitions for NVIDIA A100 80GB GPU.
+"""
+
+TPUType = Literal["V5P", "V6E"]
+V5EParts = Literal["1x1", "2x2", "2x4", "4x4", "4x8", "8x8", "8x16", "16x16"]
+
+V5PParts = Literal[
+    "2x2x1", "2x2x2", "2x4x4", "4x4x4", "4x4x8", "4x8x8", "8x8x8", "8x8x16", "8x16x16", "16x16x16", "16x16x24"
+]
+"""
+Slices for Google Cloud TPU v5p.
+"""
+
+V6EParts = Literal["1x1", "2x2", "2x4", "4x4", "4x8", "8x8", "8x16", "16x16"]
+"""
+Slices for Google Cloud TPU v6e.
+"""
+
+Accelerators = Literal[
+    "T4:1",
+    "T4:2",
+    "T4:3",
+    "T4:4",
+    "T4:5",
+    "T4:6",
+    "T4:7",
+    "T4:8",
+    "L4:1",
+    "L4:2",
+    "L4:3",
+    "L4:4",
+    "L4:5",
+    "L4:6",
+    "L4:7",
+    "L4:8",
+    "L40s:1",
+    "L40s:2",
+    "L40s:3",
+    "L40s:4",
+    "L40s:5",
+    "L40s:6",
+    "L40s:7",
+    "L40s:8",
+    "A100:1",
+    "A100:2",
+    "A100:3",
+    "A100:4",
+    "A100:5",
+    "A100:6",
+    "A100:7",
+    "A100:8",
+    "A100 80G:1",
+    "A100 80G:2",
+    "A100 80G:3",
+    "A100 80G:4",
+    "A100 80G:5",
+    "A100 80G:6",
+    "A100 80G:7",
+    "A100 80G:8",
+    "H100:1",
+    "H100:2",
+    "H100:3",
+    "H100:4",
+    "H100:5",
+    "H100:6",
+    "H100:7",
+    "H100:8",
+]
+
+
+@rich.repr.auto
+@dataclass(frozen=True, slots=True)
+class Device:
+    """
+     Represents a device type, its quantity and partition if applicable.
+    :param device: The type of device (e.g., "T4", "A100").
+    :param quantity: The number of devices of this type.
+    :param partition: The partition of the device (e.g., "1g.5gb", "2g.10gb" for gpus) or ("1x1", ... for tpus).
+    """
+
+    quantity: int
+    device: str | None = None
+    partition: str | None = None
+
+    def __post_init__(self):
+        if self.quantity < 1:
+            raise ValueError("GPU quantity must be at least 1")
+
+
+def GPU(device: GPUType, quantity: GPUQuantity, partition: A100Parts | A100_80GBParts | None = None) -> Device:
+    """
+    Create a GPU device instance.
+    :param device: The type of GPU (e.g., "T4", "A100").
+    :param quantity: The number of GPUs of this type.
+    :param partition: The partition of the GPU (e.g., "1g.5gb", "2g.10gb" for gpus) or ("1x1", ... for tpus).
+    :return: Device instance.
+    """
+    if quantity < 1:
+        raise ValueError("GPU quantity must be at least 1")
+    if device not in get_args(GPUType):
+        raise ValueError(f"Invalid GPU type: {device}. Must be one of {get_args(GPUType)}")
+    if partition is not None and device == "A100":
+        if partition not in get_args(A100Parts):
+            raise ValueError(f"Invalid partition for A100: {partition}. Must be one of {get_args(A100Parts)}")
+    elif partition is not None and device == "A100 80G":
+        if partition not in get_args(A100_80GBParts):
+            raise ValueError(f"Invalid partition for A100 80G: {partition}. Must be one of {get_args(A100_80GBParts)}")
+    return Device(device=device, quantity=quantity, partition=partition)
+
+
+def TPU(device: TPUType, partition: V5PParts | V6EParts | None = None):
+    """
+    Create a TPU device instance.
+    :param device: Device type (e.g., "V5P", "V6E").
+    :param partition: Partition of the TPU (e.g., "1x1", "2x2", ...).
+    :return: Device instance.
+    """
+    if device not in get_args(TPUType):
+        raise ValueError(f"Invalid TPU type: {device}. Must be one of {get_args(TPUType)}")
+    if partition is not None and device == "V5P":
+        if partition not in get_args(V5PParts):
+            raise ValueError(f"Invalid partition for V5P: {partition}. Must be one of {get_args(V5PParts)}")
+    elif partition is not None and device == "V6E":
+        if partition not in get_args(V6EParts):
+            raise ValueError(f"Invalid partition for V6E: {partition}. Must be one of {get_args(V6EParts)}")
+    elif partition is not None and device == "V5E":
+        if partition not in get_args(V5EParts):
+            raise ValueError(f"Invalid partition for V5E: {partition}. Must be one of {get_args(V5EParts)}")
+    return Device(1, device, partition)
+
+
+CPUBaseType = int | float | str
+
+
+@dataclass
+class Resources:
+    """
+    Resources such as CPU, Memory, and GPU that can be allocated to a task.
+
+    Example:
+    - Single CPU, 1GiB of memory, and 1 T4 GPU:
+    ```python
+    @task(resources=Resources(cpu=1, memory="1GiB", gpu="T4:1"))
+    def my_task() -> int:
+        return 42
+    ```
+    - 1CPU with limit upto 2CPU, 2GiB of memory, and 8 A100 GPUs and 10GiB of disk:
+    ```python
+    @task(resources=Resources(cpu=(1, 2), memory="2GiB", gpu="A100:8", disk="10GiB"))
+    def my_task() -> int:
+        return 42
+    ```
+
+    :param cpu: The amount of CPU to allocate to the task. This can be a string, int, float, list of ints or strings,
+        or a tuple of two ints or strings.
+    :param memory: The amount of memory to allocate to the task. This can be a string, int, float, list of ints or
+        strings, or a tuple of two ints or strings.
+    :param gpu: The amount of GPU to allocate to the task. This can be an Accelerators enum, an int, or None.
+    :param disk: The amount of disk to allocate to the task. This is a string of the form "10GiB".
+    """
+
+    cpu: Union[CPUBaseType, Tuple[CPUBaseType, CPUBaseType], None] = None
+    memory: Union[str, Tuple[str, str], None] = None
+    gpu: Union[Accelerators, int, Device, None] = None
+    disk: Union[str, None] = None
+    shm: Union[str, Literal["auto"], None] = None
+
+    def __post_init__(self):
+        if isinstance(self.cpu, tuple):
+            if len(self.cpu) != 2:
+                raise ValueError("cpu tuple must have exactly two elements")
+        if isinstance(self.memory, tuple):
+            if len(self.memory) != 2:
+                raise ValueError("memory tuple must have exactly two elements")
+        if isinstance(self.cpu, (int, float)):
+            if self.cpu < 0:
+                raise ValueError("cpu must be greater than or equal to 0")
+        if self.gpu is not None:
+            if isinstance(self.gpu, int):
+                if self.gpu < 0:
+                    raise ValueError("gpu must be greater than or equal to 0")
+            elif isinstance(self.gpu, str):
+                if self.gpu not in get_args(Accelerators):
+                    raise ValueError(f"gpu must be one of {Accelerators}")
+
+    def get_device(self) -> Optional[Device]:
+        """
+        Get the accelerator string for the task.
+
+        :return: If GPUs are requested, return a tuple of the device name, and potentially a partition string.
+                 Default cloud provider labels typically use the following values: `1g.5gb`, `2g.10gb`, etc.
+        """
+        if self.gpu is None:
+            return None
+        if isinstance(self.gpu, int):
+            return Device(quantity=self.gpu)
+        if isinstance(self.gpu, str):
+            device, portion = self.gpu.split(":")
+            return Device(device=device, quantity=int(portion))
+        return self.gpu
+
+    def get_shared_memory(self) -> Optional[str]:
+        """
+        Get the shared memory string for the task.
+
+        :return: The shared memory string.
+        """
+        if self.shm is None:
+            return None
+        if self.shm == "auto":
+            return ""
+        return self.shm

flyte/_retry.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+from datetime import timedelta
+from typing import Union
+
+
+@dataclass
+class RetryStrategy:
+    """
+    Retry strategy for the task or task environment. Retry strategy is optional or can be a simple number of retries.
+
+    Example:
+    - This will retry the task 5 times.
+    ```
+    @task(retries=5)
+    def my_task():
+        pass
+    ```
+    - This will retry the task 5 times with a maximum backoff of 10 seconds and a backoff factor of 2.
+    ```
+    @task(retries=RetryStrategy(count=5, max_backoff=10, backoff=2))
+    def my_task():
+        pass
+    ```
+
+    :param count: The number of retries.
+    :param backoff: The maximum backoff time for retries. This can be a float or a timedelta.
+    :param backoff: The backoff exponential factor. This can be an integer or a float.
+    """
+
+    count: int
+    backoff: Union[float, timedelta, None] = None
+    backoff_factor: Union[int, float, None] = None

flyte/_reusable_environment.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from datetime import timedelta
+from typing import Optional, Tuple, Union
+
+
+@dataclass
+class ReusePolicy:
+    """
+    ReusePolicy can be used to configure a task to reuse the environment. This is useful when the environment creation
+    is expensive and the runtime of the task is short. The environment will be reused for the next invocation of the
+    task, even the python process maybe be reused by subsequent task invocations. A good mental model is to think of
+    the environment as a container that is reused for multiple tasks, more like a long-running service.
+
+    Caution: It is important to note that the environment is shared, so managing memory and resources is important.
+
+    :param replicas: Either a single int representing number of replicas or a tuple of two ints representing
+     the min and max
+    :param idle_ttl: The maximum idle duration for an environment replica, specified as either seconds (int) or a
+        timedelta. If not set, the environment's global default will be used.
+        When a replica remains idle — meaning no tasks are running — for this duration, it will be automatically
+        terminated.
+    """
+
+    replicas: Union[int, Tuple[int, int]] = 1
+    idle_ttl: Optional[Union[int, timedelta]] = None

flyte/_run.py

@@ -0,0 +1,411 @@
+from __future__ import annotations
+
+import pathlib
+import uuid
+from typing import TYPE_CHECKING, Any, Literal, Optional, Tuple, Union, cast
+
+import flyte
+import flyte.report
+from flyte import S3
+
+from ._api_commons import syncer
+from ._context import contextual_run, internal_ctx
+from ._datastructures import ActionID, Checkpoints, RawDataPath, SerializationContext, TaskContext
+from ._environment import Environment
+from ._initialize import (
+    ABFS,
+    GCS,
+    _get_init_config,
+    get_client,
+    get_common_config,
+    get_storage,
+    requires_initialization,
+    requires_storage,
+)
+from ._internal import create_controller
+from ._internal.runtime.io import _CHECKPOINT_FILE_NAME
+from ._internal.runtime.taskrunner import run_task
+from ._logging import logger
+from ._protos.common import identifier_pb2
+from ._task import P, R, TaskTemplate
+from ._tools import ipython_check
+from .errors import InitializationError
+
+if TYPE_CHECKING:
+    from flyte.remote import Run
+
+    from ._code_bundle import CopyFiles
+
+Mode = Literal["local", "remote", "hybrid"]
+
+
+@syncer.wrap
+class _Runner:
+    def __init__(
+        self,
+        force_mode: Mode | None = None,
+        name: Optional[str] = None,
+        service_account: Optional[str] = None,
+        version: Optional[str] = None,
+        copy_style: CopyFiles = "loaded_modules",
+        dry_run: bool = False,
+        copy_bundle_to: pathlib.Path | None = None,
+        interactive_mode: bool | None = None,
+        raw_data_path: str | None = None,
+        metadata_path: str | None = None,
+        run_base_dir: str | None = None,
+    ):
+        init_config = _get_init_config()
+        client = init_config.client if init_config else None
+        if not force_mode and client is not None:
+            force_mode = "remote"
+        force_mode = force_mode or "local"
+        logger.debug(f"Effective run mode: {force_mode}, client configured: {client is not None}")
+        self._mode = force_mode
+        self._name = name
+        self._service_account = service_account
+        self._version = version
+        self._copy_files = copy_style
+        self._dry_run = dry_run
+        self._copy_bundle_to = copy_bundle_to
+        self._interactive_mode = interactive_mode if interactive_mode else ipython_check()
+        self._raw_data_path = raw_data_path
+        self._metadata_path = metadata_path or "/tmp"
+        self._run_base_dir = run_base_dir or "/tmp/base"
+
+    @requires_initialization
+    async def _run_remote(self, obj: TaskTemplate[P, R], *args: P.args, **kwargs: P.kwargs) -> Run:
+        from flyte.remote import Run
+
+        from ._code_bundle import build_code_bundle, build_pkl_bundle
+        from ._deploy import build_images, plan_deploy
+        from ._internal.runtime.convert import convert_from_native_to_inputs
+        from ._internal.runtime.task_serde import translate_task_to_wire
+        from ._protos.workflow import run_definition_pb2, run_service_pb2
+
+        cfg = get_common_config()
+
+        if obj.parent_env is None:
+            raise ValueError("Task is not attached to an environment. Please attach the task to an environment.")
+
+        deploy_plan = plan_deploy(cast(Environment, obj.parent_env()))
+        image_cache = await build_images(deploy_plan)
+
+        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
+            )
+        else:
+            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
+                )
+            else:
+                code_bundle = None
+
+        version = self._version or (
+            code_bundle.computed_version if code_bundle and code_bundle.computed_version else None
+        )
+        if not version:
+            raise ValueError("Version is required when running a task")
+        s_ctx = SerializationContext(
+            code_bundle=code_bundle,
+            version=version,
+            image_cache=image_cache,
+            root_dir=cfg.root_dir,
+        )
+        task_spec = translate_task_to_wire(obj, s_ctx)
+        inputs = await convert_from_native_to_inputs(obj.native_interface, *args, **kwargs)
+
+        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
+                raise InitializationError(
+                    "ClientNotInitializedError",
+                    "user",
+                    "flyte.run requires client to be initialized. "
+                    "Call flyte.init() with a valid endpoint or api-key before using this function.",
+                )
+            run_id = None
+            project_id = None
+            if self._name:
+                run_id = run_definition_pb2.RunIdentifier(
+                    project=cfg.project,
+                    domain=cfg.domain,
+                    org=cfg.org,
+                    name=self._name if self._name else None,
+                )
+            else:
+                project_id = identifier_pb2.ProjectIdentifier(
+                    name=cfg.project,
+                    domain=cfg.domain,
+                    organization=cfg.org,
+                )
+            # Fill in task id inside the task template if it's not provided.
+            # Maybe this should be done here, or the backend.
+            if task_spec.task_template.id.project == "":
+                task_spec.task_template.id.project = cfg.project if cfg.project else ""
+            if task_spec.task_template.id.domain == "":
+                task_spec.task_template.id.domain = cfg.domain if cfg.domain else ""
+            if task_spec.task_template.id.org == "":
+                task_spec.task_template.id.org = cfg.org if cfg.org else ""
+            if task_spec.task_template.id.version == "":
+                task_spec.task_template.id.version = version
+
+            resp = await get_client().run_service.CreateRun(
+                run_service_pb2.CreateRunRequest(
+                    run_id=run_id,
+                    project_id=project_id,
+                    task_spec=task_spec,
+                    inputs=inputs.proto_inputs,
+                ),
+            )
+            return Run(pb2=resp.run)
+
+        class DryRun(Run):
+            def __init__(self, _task_spec, _inputs, _code_bundle):
+                super().__init__(
+                    pb2=run_definition_pb2.Run(
+                        action=run_definition_pb2.Action(
+                            id=run_definition_pb2.ActionIdentifier(
+                                name="a0", run=run_definition_pb2.RunIdentifier(name="dry-run")
+                            )
+                        )
+                    )
+                )
+                self.task_spec = _task_spec
+                self.inputs = _inputs
+                self.code_bundle = _code_bundle
+
+        return DryRun(_task_spec=task_spec, _inputs=inputs, _code_bundle=code_bundle)
+
+    @requires_storage
+    @requires_initialization
+    async def _run_hybrid(self, obj: TaskTemplate[P, R], *args: P.args, **kwargs: P.kwargs) -> R:
+        """
+        Run a task in hybrid mode. This means that the parent action will be run locally, but the child actions will be
+        run in the cluster remotely. This is currently only used for testing,
+        over the longer term we will productize this.
+        """
+        from flyte._code_bundle import build_code_bundle, build_pkl_bundle
+        from flyte._datastructures import RawDataPath
+        from flyte._deploy import build_images, plan_deploy
+
+        cfg = get_common_config()
+
+        if obj.parent_env is None:
+            raise ValueError("Task is not attached to an environment. Please attach the task to an environment.")
+
+        deploy_plan = plan_deploy(cast(Environment, obj.parent_env()))
+        image_cache = await build_images(deploy_plan)
+
+        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
+            )
+        else:
+            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
+                )
+            else:
+                code_bundle = None
+
+        version = self._version or (
+            code_bundle.computed_version if code_bundle and code_bundle.computed_version else None
+        )
+        if not version:
+            raise ValueError("Version is required when running a task")
+
+        project = cfg.project or "testproject"
+        domain = cfg.domain or "development"
+        org = cfg.org or "testorg"
+        action_name = "a0"
+        run_name = self._name
+        random_id = str(uuid.uuid4())[:6]
+
+        controller = create_controller(ct="remote", endpoint="localhost:8090", insecure=True)
+        action = ActionID(name=action_name, run_name=run_name, project=project, domain=domain, org=org)
+
+        inputs = obj.native_interface.convert_to_kwargs(*args, **kwargs)
+        # TODO: Ideally we should get this from runService
+        # The API should be:
+        # create new run, from run, in mode hybrid -> new run id, output_base, raw_data_path, inputs_path
+        storage = get_storage()
+        if type(storage) not in (S3, GCS, ABFS):
+            raise ValueError(f"Unsupported storage type: {type(storage)}")
+        if self._run_base_dir is None:
+            raise ValueError(
+                "Raw data path is required when running task, please set it in the run context:",
+                " flyte.with_runcontext(run_base_dir='s3://bucket/metadata/outputs')",
+            )
+        output_path = self._run_base_dir
+        raw_data_path = f"{output_path}/rd/{random_id}"
+        raw_data_path_obj = RawDataPath(path=raw_data_path)
+        checkpoint_path = f"{raw_data_path}/{_CHECKPOINT_FILE_NAME}"
+        prev_checkpoint = f"{raw_data_path}/prev_checkpoint"
+        checkpoints = Checkpoints(checkpoint_path, prev_checkpoint)
+
+        async def _run_task() -> Tuple[Any, Optional[Exception]]:
+            ctx = internal_ctx()
+            tctx = TaskContext(
+                action=action,
+                checkpoints=checkpoints,
+                code_bundle=code_bundle,
+                output_path=output_path,
+                version=version,
+                raw_data_path=raw_data_path_obj,
+                compiled_image_cache=image_cache,
+                run_base_dir=self._run_base_dir,
+                report=flyte.report.Report(name=action.name),
+            )
+            async with ctx.replace_task_context(tctx):
+                return await run_task(tctx=tctx, controller=controller, task=obj, inputs=inputs)
+
+        outputs, err = await contextual_run(_run_task)
+        if err:
+            raise err
+        return outputs
+
+    async def _run_local(self, obj: TaskTemplate[P, R], *args: P.args, **kwargs: P.kwargs) -> R:
+        from flyte._internal.controllers import create_controller
+        from flyte._internal.runtime.convert import (
+            convert_error_to_native,
+            convert_from_native_to_inputs,
+            convert_outputs_to_native,
+        )
+        from flyte._internal.runtime.entrypoints import direct_dispatch
+
+        controller = create_controller(ct="local")
+
+        inputs = await convert_from_native_to_inputs(obj.native_interface, *args, **kwargs)
+        if self._name is None:
+            action = ActionID.create_random()
+        else:
+            action = ActionID(name=self._name)
+        out, err = await direct_dispatch(
+            obj,
+            action=action,
+            raw_data_path=internal_ctx().raw_data,
+            version="na",
+            controller=controller,
+            inputs=inputs,
+            output_path=self._metadata_path,
+            run_base_dir=self._metadata_path,
+            checkpoints=Checkpoints(
+                prev_checkpoint_path=internal_ctx().raw_data.path, checkpoint_path=internal_ctx().raw_data.path
+            ),
+        )  # type: ignore
+        if err:
+            native_err = convert_error_to_native(err)
+            if native_err:
+                raise native_err
+        if obj.native_interface.outputs and len(obj.native_interface.outputs) > 0:
+            if out is not None:
+                return cast(R, await convert_outputs_to_native(obj.native_interface, out))
+        return cast(R, None)
+
+    async def run(self, task: TaskTemplate[P, Union[R, Run]], *args: P.args, **kwargs: P.kwargs) -> Union[R, Run]:
+        """
+        Run an async `@env.task` or `TaskTemplate` instance. The existing async context will be used.
+
+        Example:
+        ```python
+        import flyte
+        env = flyte.TaskEnvironment("example")
+
+        @env.task
+        async def example_task(x: int, y: str) -> str:
+            return f"{x} {y}"
+
+        if __name__ == "__main__":
+            flyte.run(example_task, 1, y="hello")
+        ```
+
+        :param task: TaskTemplate instance `@env.task` or `TaskTemplate`
+        :param args: Arguments to pass to the Task
+        :param kwargs: Keyword arguments to pass to the Task
+        :return: Run instance or the result of the task
+        """
+        if self._mode == "remote":
+            return await self._run_remote(task, *args, **kwargs)
+        if self._mode == "hybrid":
+            return await self._run_hybrid(task, *args, **kwargs)
+
+        # TODO We could use this for remote as well and users could simply pass flyte:// or s3:// or file://
+        async with internal_ctx().new_raw_data_path(
+            raw_data_path=RawDataPath.from_local_folder(local_folder=self._raw_data_path)
+        ):
+            return await self._run_local(task, *args, **kwargs)
+
+
+def with_runcontext(
+    mode: Mode | None = None,
+    *,
+    name: Optional[str] = None,
+    service_account: Optional[str] = None,
+    version: Optional[str] = None,
+    copy_style: CopyFiles = "loaded_modules",
+    dry_run: bool = False,
+    copy_bundle_to: pathlib.Path | None = None,
+    interactive_mode: bool | None = None,
+    raw_data_path: str | None = None,
+    run_base_dir: str | None = None,
+) -> _Runner:
+    """
+    Launch a new run with the given parameters as the context.
+
+    Example:
+    ```python
+    import flyte
+    env = flyte.TaskEnvironment("example")
+
+    @env.task
+    async def example_task(x: int, y: str) -> str:
+        return f"{x} {y}"
+
+    if __name__ == "__main__":
+        flyte.with_runcontext(name="example_run_id").run(example_task, 1, y="hello")
+    ```
+
+    :param mode: Optional The mode to use for the run, if not provided, it will be computed from flyte.init
+    :param version: Optional The version to use for the run, if not provided, it will be computed from the code bundle
+    :param name: Optional The name to use for the run
+    :param service_account: Optional The service account to use for the run context
+    :param copy_style: Optional The copy style to use for the run context
+    :param dry_run: Optional If true, the run will not be executed, but the bundle will be created
+    :param copy_bundle_to: When dry_run is True, the bundle will be copied to this location if specified
+    :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.
+    :return: runner
+    """
+    if mode == "hybrid" and not name and not run_base_dir:
+        raise ValueError("Run name and run base dir are required for hybrid mode")
+    return _Runner(
+        force_mode=mode,
+        name=name,
+        service_account=service_account,
+        version=version,
+        copy_style=copy_style,
+        dry_run=dry_run,
+        copy_bundle_to=copy_bundle_to,
+        interactive_mode=interactive_mode,
+        raw_data_path=raw_data_path,
+        run_base_dir=run_base_dir,
+    )
+
+
+@syncer.wrap
+async def run(task: TaskTemplate[P, R], *args: P.args, **kwargs: P.kwargs) -> Union[R, Run]:
+    """
+    Run a task with the given parameters
+    :param task: task to run
+    :param args: args to pass to the task
+    :param kwargs: kwargs to pass to the task
+    :return: Run | Result of the task
+    """
+    # using syncer causes problems
+    return await _Runner().run.aio(task, *args, **kwargs)  # type: ignore