flyte 0.2.0b25__py3-none-any.whl → 0.2.0b27__py3-none-any.whl

flyte/_bin/runtime.py

@@ -82,6 +82,9 @@ def main(
 ):
     sys.path.insert(0, ".")
 
+    import faulthandler
+    import signal
+
     import flyte
     import flyte._utils as utils
     from flyte._initialize import init
@@ -91,8 +94,10 @@ def main(
     from flyte._logging import logger
     from flyte.models import ActionID, Checkpoints, CodeBundle, RawDataPath
 
-    logger.info(f"Initializing flyte runtime - version {flyte.__version__}")
+    logger.info("Registering faulthandler for SIGUSR1")
+    faulthandler.register(signal.SIGUSR1)
 
+    logger.info(f"Initializing flyte runtime - version {flyte.__version__}")
     assert org, "Org is required for now"
     assert project, "Project is required"
     assert domain, "Domain is required"

flyte/_image.py

@@ -355,7 +355,11 @@ class Image:
 
     @classmethod
     def _get_default_image_for(
-        cls, python_version: Tuple[int, int], flyte_version: Optional[str] = None, install_flyte: bool = True
+        cls,
+        python_version: Tuple[int, int],
+        flyte_version: Optional[str] = None,
+        install_flyte: bool = True,
+        platform: Optional[Tuple[Architecture, ...]] = None,
     ) -> Image:
         # Would love a way to move this outside of this class (but still needs to be accessible via Image.auto())
         # this default image definition may need to be updated once there is a released pypi version
@@ -377,7 +381,7 @@ class Image:
             base_image=f"python:{python_version[0]}.{python_version[1]}-slim-bookworm",
             registry=_BASE_REGISTRY,
             name=_DEFAULT_IMAGE_NAME,
-            platform=("linux/amd64", "linux/arm64"),
+            platform=("linux/amd64", "linux/arm64") if platform is None else platform,
         )
         labels_and_user = _DockerLines(
             (
@@ -430,6 +434,7 @@ class Image:
         install_flyte: bool = True,
         registry: Optional[str] = None,
         name: Optional[str] = None,
+        platform: Optional[Tuple[Architecture, ...]] = None,
     ) -> Image:
         """
         Use this method to start using the default base image, built from this library's base Dockerfile
@@ -440,6 +445,8 @@ class Image:
         :param install_flyte: If True, will install the flyte library in the image
         :param registry: Registry to use for the image
         :param name: Name of the image if you want to override the default name
+        :param platform: Platform to use for the image, default is linux/amd64, use tuple for multiple values
+            Example: ("linux/amd64", "linux/arm64")
 
         :return: Image
         """
@@ -447,7 +454,10 @@ class Image:
             python_version = _detect_python_version()
 
         base_image = cls._get_default_image_for(
-            python_version=python_version, flyte_version=flyte_version, install_flyte=install_flyte
+            python_version=python_version,
+            flyte_version=flyte_version,
+            install_flyte=install_flyte,
+            platform=platform,
         )
 
         if registry and name:
@@ -481,7 +491,7 @@ class Image:
         extra_index_urls: Union[str, List[str], Tuple[str, ...], None] = None,
         pre: bool = False,
         extra_args: Optional[str] = None,
-        arch: Union[Architecture, Tuple[Architecture, ...]] = "linux/amd64",
+        platform: Optional[Tuple[Architecture, ...]] = None,
     ) -> Image:
         """
         Use this method to create a new image with the specified uv script.
@@ -506,7 +516,7 @@ class Image:
         :param python_version: Python version to use for the image, if not specified, will use the current Python
         version
         :param script: path to the uv script
-        :param arch: architecture to use for the image, default is linux/amd64, use tuple for multiple values
+        :param platform: architecture to use for the image, default is linux/amd64, use tuple for multiple values
         :param python_version: Python version for the image, if not specified, will use the current Python version
         :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
@@ -530,7 +540,7 @@ class Image:
             raise ValueError("registry must be specified")
 
         # todo: arch
-        img = cls.from_debian_base(registry=registry, name=name, python_version=python_version)
+        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")

flyte/_internal/controllers/_local_controller.py

@@ -106,10 +106,12 @@ class LocalController:
                 raise exc
             else:
                 raise flyte.errors.RuntimeSystemError("BadError", "Unknown error")
-        if _task.native_interface.outputs and out is not None:
+        if _task.native_interface.outputs:
+            if out is None:
+                raise flyte.errors.RuntimeSystemError("BadOutput", "Task output not captured.")
             result = await convert.convert_outputs_to_native(_task.native_interface, out)
             return result
-        return out
+        return None
 
     def submit_sync(self, _task: TaskTemplate, *args, **kwargs) -> concurrent.futures.Future:
         name = threading.current_thread().name + f"PID:{os.getpid()}"

flyte/_internal/runtime/convert.py

@@ -120,13 +120,19 @@ async def convert_from_native_to_inputs(interface: NativeInterface, *args, **kwa
     for input_name, (input_type, default_value) in interface.inputs.items():
         if input_name in kwargs:
             type_hints[input_name] = input_type
-        elif (default_value is not None and default_value is not inspect.Signature.empty) or (
-            default_value is None and is_optional_type(input_type)
+        elif (
+            (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
         ):
             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
+                kwargs[input_name] = None
+                type_hints[input_name] = NoneType
             else:
                 kwargs[input_name] = default_value
                 type_hints[input_name] = input_type
@@ -150,6 +156,22 @@ async def convert_from_native_to_inputs(interface: NativeInterface, *args, **kwa
     )
 
 
+async def convert_from_inputs_to_native(native_interface: NativeInterface, inputs: Inputs) -> Dict[str, Any]:
+    """
+    Converts the inputs from a run definition proto to a native Python dictionary.
+    :param native_interface: The native interface of the task.
+    :param inputs: The run definition inputs proto.
+    :return: A dictionary of input names to their native Python values.
+    """
+    if not inputs or not inputs.proto_inputs or not inputs.proto_inputs.literals:
+        return {}
+
+    literals = {named_literal.name: named_literal.value for named_literal in inputs.proto_inputs.literals}
+    return await TypeEngine.literal_map_to_kwargs(
+        literals_pb2.LiteralMap(literals=literals), native_interface.get_input_types()
+    )
+
+
 async def convert_from_native_to_outputs(o: Any, interface: NativeInterface, task_name: str = "") -> Outputs:
     # Always make it a tuple even if it's just one item to simplify logic below
     if not isinstance(o, tuple):

flyte/_run.py

@@ -376,9 +376,10 @@ class _Runner:
             raise err
         return outputs
 
-    async def _run_local(self, obj: TaskTemplate[P, R], *args: P.args, **kwargs: P.kwargs) -> R:
+    async def _run_local(self, obj: TaskTemplate[P, R], *args: P.args, **kwargs: P.kwargs) -> Run:
         from flyte._internal.controllers import create_controller
         from flyte._internal.controllers._local_controller import LocalController
+        from flyte.remote import Run
         from flyte.report import Report
 
         controller = cast(LocalController, create_controller("local"))
@@ -409,9 +410,37 @@ class _Runner:
             if obj._call_as_synchronous:
                 fut = controller.submit_sync(obj, *args, **kwargs)
                 awaitable = asyncio.wrap_future(fut)
-                return await awaitable
+                outputs = await awaitable
             else:
-                return await controller.submit(obj, *args, **kwargs)
+                outputs = await controller.submit(obj, *args, **kwargs)
+
+        class _LocalRun(Run):
+            def __init__(self, outputs: Tuple[Any, ...] | Any):
+                from flyte._protos.workflow import run_definition_pb2
+
+                self._outputs = outputs
+                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"),
+                            )
+                        )
+                    )
+                )
+
+            @property
+            def url(self) -> str:
+                return "local-run"
+
+            def wait(self, quiet: bool = False, wait_for: Literal["terminal", "running"] = "terminal"):
+                pass
+
+            def outputs(self) -> R:
+                return cast(R, self._outputs)
+
+        return _LocalRun(outputs)
 
     @syncify
     async def run(

flyte/_task_environment.py

@@ -90,7 +90,11 @@ class TaskEnvironment(Environment):
 
         """
         cache = kwargs.pop("cache", None)
-        reusable = kwargs.pop("reusable", None)
+        reusable = None
+        reusable_set = False
+        if "reusable" in kwargs:
+            reusable_set = True
+            reusable = kwargs.pop("reusable", None)
 
         # validate unknown kwargs if needed
         if kwargs:
@@ -106,7 +110,7 @@ class TaskEnvironment(Environment):
             kwargs["cache"] = cache
         if env is not None:
             kwargs["env"] = env
-        if reusable is not None:
+        if reusable_set:
             kwargs["reusable"] = reusable
         if secrets is not None:
             kwargs["secrets"] = secrets

flyte/_tools.py

@@ -25,3 +25,16 @@ def is_in_cluster() -> bool:
     if os.getenv("_UN_CLS"):
         return True
     return False
+
+
+def ipywidgets_check() -> bool:
+    """
+    Check if the interface is running in IPython with ipywidgets support.
+    :return: True if running in IPython with ipywidgets support, False otherwise.
+    """
+    try:
+        import ipywidgets  # noqa: F401
+
+        return True
+    except (ImportError, NameError):
+        return False

flyte/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.2.0b25'
-__version_tuple__ = version_tuple = (0, 2, 0, 'b25')
+__version__ = version = '0.2.0b27'
+__version_tuple__ = version_tuple = (0, 2, 0, 'b27')

flyte/cli/_get.py

@@ -5,6 +5,8 @@ import rich_click as click
 from rich.console import Console
 from rich.pretty import pretty_repr
 
+import flyte.remote._action
+
 from . import _common as common
 
 
@@ -122,17 +124,18 @@ def action(
     """
     Get all actions for a run or details for a specific action.
     """
-    import flyte.remote as remote
 
     cfg.init(project=project, domain=domain)
 
     console = Console()
     if action_name:
-        console.print(pretty_repr(remote.Action.get(run_name=run_name, name=action_name)))
+        console.print(pretty_repr(flyte.remote._action.Action.get(run_name=run_name, name=action_name)))
     else:
         # List all actions for the run
         console.print(
-            common.get_table(f"Actions for {run_name}", remote.Action.listall(for_run_name=run_name), simple=cfg.simple)
+            common.get_table(
+                f"Actions for {run_name}", flyte.remote._action.Action.listall(for_run_name=run_name), simple=cfg.simple
+            )
         )
 
 
@@ -201,7 +204,7 @@ def logs(
             task.cancel()
 
     if action_name:
-        obj = remote.Action.get(run_name=run_name, name=action_name)
+        obj = flyte.remote._action.Action.get(run_name=run_name, name=action_name)
     else:
         obj = remote.Run.get(run_name)
     asyncio.run(_run_log_view(obj))
@@ -269,20 +272,20 @@ def io(
     cfg.init(project=project, domain=domain)
     console = Console()
     if action_name:
-        obj = remote.ActionDetails.get(run_name=run_name, name=action_name)
+        obj = flyte.remote._action.ActionDetails.get(run_name=run_name, name=action_name)
     else:
         obj = remote.RunDetails.get(run_name)
 
     async def _get_io(
-        details: Union[remote.RunDetails, remote.ActionDetails],
-    ) -> Tuple[remote.ActionInputs | None, remote.ActionOutputs | None | str]:
+        details: Union[remote.RunDetails, flyte.remote._action.ActionDetails],
+    ) -> Tuple[flyte.remote._action.ActionInputs | None, flyte.remote._action.ActionOutputs | None | str]:
         if inputs_only or outputs_only:
             if inputs_only:
                 return await details.inputs(), None
             elif outputs_only:
                 return None, await details.outputs()
         inputs = await details.inputs()
-        outputs: remote.ActionOutputs | None | str = None
+        outputs: flyte.remote._action.ActionOutputs | None | str = None
         try:
             outputs = await details.outputs()
         except Exception:

flyte/remote/__init__.py

@@ -18,9 +18,10 @@ __all__ = [
     "upload_file",
 ]
 
+from ._action import Action, ActionDetails, ActionInputs, ActionOutputs
 from ._client.auth import create_channel
 from ._data import upload_dir, upload_file
 from ._project import Project
-from ._run import Action, ActionDetails, ActionInputs, ActionOutputs, Run, RunDetails
+from ._run import Run, RunDetails
 from ._secret import Secret, SecretTypes
 from ._task import Task