flyte 2.0.0b13__py3-none-any.whl → 2.0.0b30__py3-none-any.whl

flyte/types/__init__.py

@@ -19,6 +19,10 @@ It is always possible to bypass the type system and use the `FlytePickle` type t
  written in python. The Pickled objects cannot be represented in the UI, and may be in-efficient for large datasets.
 """
 
+from importlib.metadata import entry_points
+
+from flyte._logging import logger
+
 from ._interface import guess_interface
 from ._pickle import FlytePickle
 from ._renderer import Renderable
@@ -34,3 +38,15 @@ __all__ = [
     "guess_interface",
     "literal_string_repr",
 ]
+
+
+def _load_custom_type_transformers():
+    plugins = entry_points(group="flyte.plugins.types")
+    for ep in plugins:
+        try:
+            logger.info(f"Loading type transformer: {ep.name}")
+            loaded = ep.load()
+            if callable(loaded):
+                loaded()
+        except Exception as e:
+            logger.warning(f"Failed to load type transformer {ep.name} with error: {e}")

flyte/types/_interface.py

@@ -1,9 +1,9 @@
 import inspect
 from typing import Any, Dict, Iterable, Tuple, Type, cast
 
-from flyteidl.core import interface_pb2, literals_pb2
+from flyteidl2.core import interface_pb2, literals_pb2
+from flyteidl2.task import common_pb2
 
-from flyte._protos.workflow import common_pb2
 from flyte.models import NativeInterface
 
 

flyte/types/_pickle.py

@@ -1,17 +1,19 @@
 import hashlib
 import os
+import sys
 import typing
 from typing import Type
 
 import aiofiles
 import cloudpickle
-from flyteidl.core import literals_pb2, types_pb2
+from flyteidl2.core import literals_pb2, types_pb2
 
 import flyte.storage as storage
 
 from ._type_engine import TypeEngine, TypeTransformer
 
 T = typing.TypeVar("T")
+DEFAULT_PICKLE_BYTES_LIMIT = 2**10 * 10  # 10KB
 
 
 class FlytePickle(typing.Generic[T]):
@@ -76,8 +78,13 @@ class FlytePickleTransformer(TypeTransformer[FlytePickle]):
         ...
 
     async def to_python_value(self, lv: literals_pb2.Literal, expected_python_type: Type[T]) -> T:
-        uri = lv.scalar.blob.uri
-        return await FlytePickle.from_pickle(uri)
+        if lv.scalar.blob and lv.scalar.blob.uri:
+            uri = lv.scalar.blob.uri
+            return await FlytePickle.from_pickle(uri)
+        elif lv.scalar.binary and lv.scalar.binary.value:
+            return cloudpickle.loads(lv.scalar.binary.value)
+        else:
+            raise ValueError(f"Cannot convert {lv} to {expected_python_type}")
 
     async def to_literal(
         self,
@@ -92,8 +99,15 @@ class FlytePickleTransformer(TypeTransformer[FlytePickle]):
                 format=self.PYTHON_PICKLE_FORMAT, dimensionality=types_pb2.BlobType.BlobDimensionality.SINGLE
             )
         )
-        remote_path = await FlytePickle.to_pickle(python_val)
-        return literals_pb2.Literal(scalar=literals_pb2.Scalar(blob=literals_pb2.Blob(metadata=meta, uri=remote_path)))
+        if sys.getsizeof(python_val) > DEFAULT_PICKLE_BYTES_LIMIT:
+            remote_path = await FlytePickle.to_pickle(python_val)
+            return literals_pb2.Literal(
+                scalar=literals_pb2.Scalar(blob=literals_pb2.Blob(metadata=meta, uri=remote_path))
+            )
+        else:
+            return literals_pb2.Literal(
+                scalar=literals_pb2.Scalar(binary=literals_pb2.Binary(value=cloudpickle.dumps(python_val)))
+            )
 
     def guess_python_type(self, literal_type: types_pb2.LiteralType) -> typing.Type[FlytePickle[typing.Any]]:
         if (
@@ -102,14 +116,27 @@ class FlytePickleTransformer(TypeTransformer[FlytePickle]):
             and literal_type.blob.format == FlytePickleTransformer.PYTHON_PICKLE_FORMAT
         ):
             return FlytePickle
+        if literal_type.simple == types_pb2.SimpleType.BINARY:
+            return FlytePickle
 
         raise ValueError(f"Transformer {self} cannot reverse {literal_type}")
 
     def get_literal_type(self, t: Type[T]) -> types_pb2.LiteralType:
         lt = types_pb2.LiteralType(
-            blob=types_pb2.BlobType(
-                format=self.PYTHON_PICKLE_FORMAT, dimensionality=types_pb2.BlobType.BlobDimensionality.SINGLE
-            )
+            union_type=types_pb2.UnionType(
+                variants=[
+                    types_pb2.LiteralType(
+                        blob=types_pb2.BlobType(
+                            format=self.PYTHON_PICKLE_FORMAT,
+                            dimensionality=types_pb2.BlobType.BlobDimensionality.SINGLE,
+                        ),
+                        structure=types_pb2.TypeStructure(tag=self.name),
+                    ),
+                    types_pb2.LiteralType(
+                        simple=types_pb2.SimpleType.BINARY, structure=types_pb2.TypeStructure(tag=self.name)
+                    ),
+                ]
+            ),
         )
         lt.metadata = {"python_class_name": str(t)}
         return lt

flyte/types/_string_literals.py

@@ -3,11 +3,10 @@ import json
 from typing import Any, Dict, Union
 
 import msgpack
-from flyteidl.core import literals_pb2
+from flyteidl2.core import literals_pb2
+from flyteidl2.task import common_pb2
 from google.protobuf.json_format import MessageToDict
 
-from flyte._protos.workflow import run_definition_pb2
-
 
 def _primitive_to_string(primitive: literals_pb2.Primitive) -> Any:
     """
@@ -88,9 +87,9 @@ def _dict_literal_repr(lmd: Dict[str, literals_pb2.Literal]) -> Dict[str, Any]:
 def literal_string_repr(
     lm: Union[
         literals_pb2.Literal,
-        run_definition_pb2.NamedLiteral,
-        run_definition_pb2.Inputs,
-        run_definition_pb2.Outputs,
+        common_pb2.NamedLiteral,
+        common_pb2.Inputs,
+        common_pb2.Outputs,
         literals_pb2.LiteralMap,
         Dict[str, literals_pb2.Literal],
     ],
@@ -105,13 +104,13 @@ def literal_string_repr(
             return _literal_string_repr(lm)
         case literals_pb2.LiteralMap():
             return _dict_literal_repr(lm.literals)
-        case run_definition_pb2.NamedLiteral():
+        case common_pb2.NamedLiteral():
             lmd = {lm.name: lm.value}
             return _dict_literal_repr(lmd)
-        case run_definition_pb2.Inputs():
+        case common_pb2.Inputs():
             lmd = {n.name: n.value for n in lm.literals}
             return _dict_literal_repr(lmd)
-        case run_definition_pb2.Outputs():
+        case common_pb2.Outputs():
             lmd = {n.name: n.value for n in lm.literals}
             return _dict_literal_repr(lmd)
         case dict():

flyte/types/_type_engine.py

@@ -20,9 +20,9 @@ from types import GenericAlias, NoneType
 from typing import Any, Dict, NamedTuple, Optional, Type, cast
 
 import msgpack
-from flyteidl.core import interface_pb2, literals_pb2, types_pb2
-from flyteidl.core.literals_pb2 import Binary, Literal, LiteralCollection, LiteralMap, Primitive, Scalar, Union, Void
-from flyteidl.core.types_pb2 import LiteralType, SimpleType, TypeAnnotation, TypeStructure, UnionType
+from flyteidl2.core import interface_pb2, literals_pb2, types_pb2
+from flyteidl2.core.literals_pb2 import Binary, Literal, LiteralCollection, LiteralMap, Primitive, Scalar, Union, Void
+from flyteidl2.core.types_pb2 import LiteralType, SimpleType, TypeAnnotation, TypeStructure, UnionType
 from fsspec.asyn import _run_coros_in_chunks  # pylint: disable=W0212
 from google.protobuf import json_format as _json_format
 from google.protobuf import struct_pb2
@@ -39,7 +39,6 @@ from pydantic import BaseModel
 from typing_extensions import Annotated, get_args, get_origin
 
 import flyte.storage as storage
-from flyte._hash import HashMethod
 from flyte._logging import logger
 from flyte._utils.helpers import load_proto_from_file
 from flyte.models import NativeInterface
@@ -456,35 +455,6 @@ class DataclassTransformer(TypeTransformer[object]):
     2. Deserialization: The dataclass transformer converts the MessagePack Bytes back to a dataclass.
         (1) Convert MessagePack Bytes to a dataclass using mashumaro.
         (2) Handle dataclass attributes to ensure they are of the correct types.
-
-    TODO: Update the example using mashumaro instead of the older library
-
-    Example
-
-    .. code-block:: python
-
-        @dataclass
-        class Test:
-           a: int
-           b: str
-
-        t = Test(a=10,b="e")
-        JSONSchema().dump(t.schema())
-
-    Output will look like
-
-    .. code-block:: json
-
-        {'$schema': 'http://json-schema.org/draft-07/schema#',
-         'definitions': {'TestSchema': {'properties': {'a': {'title': 'a',
-             'type': 'number',
-             'format': 'integer'},
-            'b': {'title': 'b', 'type': 'string'}},
-           'type': 'object',
-           'additionalProperties': False}},
-         '$ref': '#/definitions/TestSchema'}
-
-
     """
 
     def __init__(self) -> None:
@@ -616,7 +586,7 @@ class DataclassTransformer(TypeTransformer[object]):
             }
         )
 
-        # The type engine used to publish a type structure for attribute access. As of v2, this is no longer needed.
+        # The type engine used to publish the type `structure` for attribute access. As of v2, this is no longer needed.
         return types_pb2.LiteralType(
             simple=types_pb2.SimpleType.STRUCT,
             metadata=schema,
@@ -816,6 +786,13 @@ class EnumTransformer(TypeTransformer[enum.Enum]):
         return LiteralType(enum_type=types_pb2.EnumType(values=values))
 
     async def to_literal(self, python_val: enum.Enum, python_type: Type[T], expected: LiteralType) -> Literal:
+        if isinstance(python_val, str):
+            # this is the case when python Literals are used as enums
+            if python_val not in expected.enum_type.values:
+                raise TypeTransformerFailedError(
+                    f"Value {python_val} is not valid value, expected - {expected.enum_type.values}"
+                )
+            return Literal(scalar=Scalar(primitive=Primitive(string_value=python_val)))  # type: ignore
         if type(python_val).__class__ != enum.EnumMeta:
             raise TypeTransformerFailedError("Expected an enum")
         if type(python_val.value) is not str:
@@ -826,6 +803,12 @@ class EnumTransformer(TypeTransformer[enum.Enum]):
     async def to_python_value(self, lv: Literal, expected_python_type: Type[T]) -> T:
         if lv.HasField("scalar") and lv.scalar.HasField("binary"):
             return self.from_binary_idl(lv.scalar.binary, expected_python_type)  # type: ignore
+        from flyte._interface import LITERAL_ENUM
+
+        if expected_python_type.__name__ is LITERAL_ENUM:
+            # This is the case when python Literal types are used as enums. The class name is always LiteralEnum an
+            # hardcoded in flyte.models
+            return lv.scalar.primitive.string_value
         return expected_python_type(lv.scalar.primitive.string_value)  # type: ignore
 
     def guess_python_type(self, literal_type: LiteralType) -> Type[enum.Enum]:
@@ -1096,23 +1079,6 @@ class TypeEngine(typing.Generic[T]):
         ):
             raise TypeTransformerFailedError(f"Python value cannot be None, expected {python_type}/{expected}")
 
-    @classmethod
-    def calculate_hash(cls, python_val: typing.Any, python_type: Type[T]) -> Optional[str]:
-        # In case the value is an annotated type we inspect the annotations and look for hash-related annotations.
-        hsh = None
-        if is_annotated(python_type):
-            # We are now dealing with one of two cases:
-            # 1. The annotated type is a `HashMethod`, which indicates that we should produce the hash using
-            #    the method indicated in the annotation.
-            # 2. The annotated type is being used for a different purpose other than calculating hash values,
-            #    in which case we should just continue.
-            for annotation in get_args(python_type)[1:]:
-                if not isinstance(annotation, HashMethod):
-                    continue
-                hsh = annotation.calculate(python_val)
-                break
-        return hsh
-
     @classmethod
     async def to_literal(
         cls, python_val: typing.Any, python_type: Type[T], expected: types_pb2.LiteralType
@@ -1125,8 +1091,6 @@ class TypeEngine(typing.Generic[T]):
         lv = await transformer.to_literal(python_val, python_type, expected)
 
         modify_literal_uris(lv)
-        calculated_hash = cls.calculate_hash(python_val, python_type) or ""
-        lv.hash = calculated_hash
         return lv
 
     @classmethod
@@ -1204,20 +1168,26 @@ class TypeEngine(typing.Generic[T]):
                 f"Received more input values {len(lm.literals)}"
                 f" than allowed by the input spec {len(python_interface_inputs)}"
             )
+        # Create tasks for converting each kwarg
+        tasks = {}
+        for k in lm.literals:
+            tasks[k] = asyncio.create_task(TypeEngine.to_python_value(lm.literals[k], python_interface_inputs[k]))
+
+        # Gather all tasks, returning exceptions instead of raising them
+        results = await asyncio.gather(*tasks.values(), return_exceptions=True)
+
+        # Check for exceptions and raise with specific kwarg name
         kwargs = {}
-        try:
-            for i, k in enumerate(lm.literals):
-                kwargs[k] = asyncio.create_task(TypeEngine.to_python_value(lm.literals[k], python_interface_inputs[k]))
-            await asyncio.gather(*kwargs.values())
-        except Exception as e:
-            raise TypeTransformerFailedError(
-                f"Error converting input:\n"
-                f"Literal value: {lm.literals[k]}\n"
-                f"Expected Python type: {python_interface_inputs[k]}\n"
-                f"Exception: {e}"
-            )
+        for (key, task), result in zip(tasks.items(), results):
+            if isinstance(result, Exception):
+                raise TypeTransformerFailedError(
+                    f"Error converting input '{key}':\n"
+                    f"Literal value: {lm.literals[key]}\n"
+                    f"Expected Python type: {python_interface_inputs[key]}\n"
+                    f"Exception: {result}"
+                ) from result
+            kwargs[key] = result
 
-        kwargs = {k: v.result() for k, v in kwargs.items() if v is not None}
         return kwargs
 
     @classmethod
@@ -1252,7 +1222,7 @@ class TypeEngine(typing.Generic[T]):
                 e: BaseException = literal_map[k].exception()  # type: ignore
                 if isinstance(e, TypeError):
                     raise TypeError(
-                        f"Error converting: Var:{k}, type:{type(v)}, into:{python_type}, received_value {v}"
+                        f"Error converting: Var:{k}, type:{type(d[k])}, into:{python_type}, received_value {d[k]}"
                     )
                 else:
                     raise e
@@ -1795,7 +1765,6 @@ class DictTransformer(TypeTransformer[dict]):
         for k, v in python_val.items():
             if type(k) is not str:
                 raise ValueError("Flyte MapType expects all keys to be strings")
-            # TODO: log a warning for Annotated objects that contain HashMethod
 
             _, v_type = self.extract_types(python_type)
             lit_map[k] = TypeEngine.to_literal(v, cast(type, v_type), expected.map_value_type)
@@ -1942,7 +1911,6 @@ def _get_element_type(element_property: typing.Dict[str, str]) -> Type:
     return str
 
 
-# pr: han-ru is this still needed?
 def dataclass_from_dict(cls: type, src: typing.Dict[str, typing.Any]) -> typing.Any:
     """
     Utility function to construct a dataclass object from dict
@@ -2022,7 +1990,7 @@ def _handle_flyte_console_float_input_to_int(lv: Literal) -> int:
 
 def _check_and_convert_void(lv: Literal) -> None:
     if not lv.scalar.HasField("none_type"):
-        raise TypeTransformerFailedError(f"Cannot convert literal {lv} to None")
+        raise TypeTransformerFailedError(f"Cannot convert literal '{lv}' to None")
     return None
 
 
@@ -2083,7 +2051,9 @@ DateTransformer = SimpleTransformer(
     lambda x: Literal(
         scalar=Scalar(primitive=Primitive(datetime=datetime.datetime.combine(x, datetime.time.min)))
     ),  # convert datetime to date
-    lambda x: x.scalar.primitive.datetime.date() if x.scalar.primitive.HasField("datetime") else None,
+    lambda x: x.scalar.primitive.datetime.ToDatetime().replace(tzinfo=datetime.timezone.utc).date()
+    if x.scalar.primitive.HasField("datetime")
+    else None,
 )
 
 NoneTransformer = SimpleTransformer(

flyte/types/_utils.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import importlib
 import typing
 
-from flyteidl.core.types_pb2 import EnumType, LiteralType, UnionType
+from flyteidl2.core.types_pb2 import EnumType, LiteralType, UnionType
 
 T = typing.TypeVar("T")
 

flyte-2.0.0b30.data/scripts/debug.py

@@ -0,0 +1,38 @@
+import click
+
+
+@click.group()
+def _debug():
+    """Debug commands for Flyte."""
+
+
+@_debug.command("resume")
+@click.option("--pid", "-m", type=int, required=True, help="PID of the vscode server.")
+def resume(pid):
+    """
+    Resume a Flyte task for debugging purposes.
+
+    Args:
+        pid (int): PID of the vscode server.
+    """
+    import os
+    import signal
+
+    print("Terminating server and resuming task.")
+    answer = (
+        input(
+            "This operation will kill the server. All unsaved data will be lost,"
+            " and you will no longer be able to connect to it. Do you really want to terminate? (Y/N): "
+        )
+        .strip()
+        .upper()
+    )
+    if answer == "Y":
+        os.kill(pid, signal.SIGTERM)
+        print("The server has been terminated and the task has been resumed.")
+    else:
+        print("Operation canceled.")
+
+
+if __name__ == "__main__":
+    _debug()

{flyte-2.0.0b13.data → flyte-2.0.0b30.data}/scripts/runtime.py

@@ -12,6 +12,9 @@ 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
 # ACTION_NAME = "_U_ACTION_NAME"
 # RUN_NAME = "_U_RUN_NAME"
@@ -21,14 +24,16 @@ import click
 
 ACTION_NAME = "ACTION_NAME"
 RUN_NAME = "RUN_NAME"
-PROJECT_NAME = "FLYTE_INTERNAL_TASK_PROJECT"
-DOMAIN_NAME = "FLYTE_INTERNAL_TASK_DOMAIN"
+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"
 
-# TODO: Remove this after proper auth is implemented
 _UNION_EAGER_API_KEY_ENV_VAR = "_UNION_EAGER_API_KEY"
+_F_PATH_REWRITE = "_F_PATH_REWRITE"
 
 
 @click.group()
@@ -49,6 +54,8 @@ def _pass_through():
 @click.option("--project", envvar=PROJECT_NAME, required=False)
 @click.option("--domain", envvar=DOMAIN_NAME, required=False)
 @click.option("--org", envvar=ORG_NAME, required=False)
+@click.option("--debug", envvar=FLYTE_ENABLE_VSCODE_KEY, type=click.BOOL, required=False)
+@click.option("--interactive-mode", type=click.BOOL, required=False)
 @click.option("--image-cache", required=False)
 @click.option("--tgz", required=False)
 @click.option("--pkl", required=False)
@@ -59,12 +66,16 @@ def _pass_through():
     type=click.UNPROCESSED,
     nargs=-1,
 )
+@click.pass_context
 def main(
+    ctx: click.Context,
     run_name: str,
     name: str,
     project: str,
     domain: str,
     org: str,
+    debug: bool,
+    interactive_mode: bool,
     image_cache: str,
     version: str,
     inputs: str,
@@ -87,6 +98,7 @@ def main(
     import flyte
     import flyte._utils as utils
     import flyte.errors
+    import flyte.storage as storage
     from flyte._initialize import init
     from flyte._internal.controllers import create_controller
     from flyte._internal.imagebuild.image_builder import ImageCache
@@ -109,6 +121,13 @@ def main(
     if name.startswith("{{"):
         name = os.getenv("ACTION_NAME", "")
 
+    logger.warning(f"Flyte runtime started for action {name} with run name {run_name}")
+
+    if debug and name == "a0":
+        from flyte._debug.vscode import _start_vscode_server
+
+        asyncio.run(_start_vscode_server(ctx))
+
     # Figure out how to connect
     # This detection of api key is a hack for now.
     controller_kwargs: dict[str, Any] = {"insecure": False}
@@ -122,19 +141,40 @@ def main(
             controller_kwargs["insecure"] = True
         logger.debug(f"Using controller endpoint: {ep} with kwargs: {controller_kwargs}")
 
-    bundle = CodeBundle(tgz=tgz, pkl=pkl, destination=dest, computed_version=version)
-    init(org=org, project=project, domain=domain, **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)
+    init(org=org, project=project, domain=domain, image_builder="remote", **controller_kwargs)
     # Controller is created with the same kwargs as init, so that it can be used to run tasks
     controller = create_controller(ct="remote", **controller_kwargs)
 
     ic = ImageCache.from_transport(image_cache) if image_cache else None
 
+    path_rewrite_cfg = os.getenv(_F_PATH_REWRITE, None)
+    path_rewrite = None
+    if path_rewrite_cfg:
+        potential_path_rewrite = PathRewrite.from_str(path_rewrite_cfg)
+        if storage.exists_sync(potential_path_rewrite.new_prefix):
+            path_rewrite = potential_path_rewrite
+            logger.info(f"Path rewrite configured for {path_rewrite.new_prefix}")
+        else:
+            logger.error(
+                f"Path rewrite failed for path {potential_path_rewrite.new_prefix}, "
+                f"not found, reverting to original path {potential_path_rewrite.old_prefix}"
+            )
+
     # Create a coroutine to load the task and run it
     task_coroutine = load_and_run_task(
         resolver=resolver,
         resolver_args=resolver_args,
         action=ActionID(name=name, run_name=run_name, project=project, domain=domain, org=org),
-        raw_data_path=RawDataPath(path=raw_data_path),
+        raw_data_path=RawDataPath(path=raw_data_path, path_rewrite=path_rewrite),
         checkpoints=Checkpoints(checkpoint_path, prev_checkpoint),
         code_bundle=bundle,
         input_path=inputs,
@@ -143,6 +183,7 @@ def main(
         version=version,
         controller=controller,
         image_cache=ic,
+        interactive_mode=interactive_mode or debug,
     )
     # Create a coroutine to watch for errors
     controller_failure = controller.watch_for_errors()
@@ -151,10 +192,23 @@ def main(
     async def _run_and_stop():
         loop = asyncio.get_event_loop()
         loop.set_exception_handler(flyte.errors.silence_grpc_polling_error)
-        await utils.run_coros(controller_failure, task_coroutine)
-        await controller.stop()
+        try:
+            await utils.run_coros(controller_failure, task_coroutine)
+            await controller.stop()
+        except flyte.errors.RuntimeSystemError as e:
+            logger.error(f"Runtime system error: {e}")
+            from flyte._internal.runtime.convert import convert_from_native_to_error
+            from flyte._internal.runtime.io import upload_error
+
+            logger.error(f"Flyte runtime failed for action {name} with run name {run_name}, error: {e}")
+            err = convert_from_native_to_error(e)
+            path = await upload_error(err.err, outputs_path)
+            logger.error(f"Run {run_name} Action {name} failed with error: {err}. Uploaded error to {path}")
+            await controller.stop()
+            raise
 
     asyncio.run(_run_and_stop())
+    logger.warning(f"Flyte runtime completed for action {name} with run name {run_name}")
 
 
 if __name__ == "__main__":

{flyte-2.0.0b13.dist-info → flyte-2.0.0b30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flyte
-Version: 2.0.0b13
+Version: 2.0.0b30
 Summary: Add your description here
 Author-email: Ketan Umare <kumare3@users.noreply.github.com>
 Requires-Python: >=3.10
@@ -8,7 +8,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiofiles>=24.1.0
 Requires-Dist: click>=8.2.1
-Requires-Dist: flyteidl>=1.15.4b0
+Requires-Dist: flyteidl<2.0.0,>=1.15.4b0
 Requires-Dist: cloudpickle>=3.1.1
 Requires-Dist: fsspec>=2025.3.0
 Requires-Dist: grpcio>=1.71.0
@@ -16,7 +16,7 @@ Requires-Dist: obstore>=0.7.3
 Requires-Dist: protobuf>=6.30.1
 Requires-Dist: pydantic>=2.10.6
 Requires-Dist: pyyaml>=6.0.2
-Requires-Dist: rich-click>=1.8.9
+Requires-Dist: rich-click==1.8.9
 Requires-Dist: httpx<1.0.0,>=0.28.1
 Requires-Dist: keyring>=25.6.0
 Requires-Dist: msgpack>=1.1.0
@@ -24,6 +24,14 @@ Requires-Dist: toml>=0.10.2
 Requires-Dist: async-lru>=2.0.5
 Requires-Dist: mashumaro
 Requires-Dist: dataclasses_json
+Requires-Dist: aiolimiter>=1.2.1
+Requires-Dist: flyteidl2==2.0.0a14
+Provides-Extra: aiosqlite
+Requires-Dist: aiosqlite>=0.21.0; extra == "aiosqlite"
+Provides-Extra: connector
+Requires-Dist: grpcio-health-checking; extra == "connector"
+Requires-Dist: httpx; extra == "connector"
+Requires-Dist: prometheus-client; extra == "connector"
 Dynamic: license-file
 
 # Flyte 2 SDK 🚀