flyte 0.2.0b24__py3-none-any.whl → 0.2.0b26__py3-none-any.whl

flyte/_task.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import asyncio
 import weakref
 from dataclasses import dataclass, field, replace
-from functools import cached_property
 from inspect import iscoroutinefunction
 from typing import (
     TYPE_CHECKING,
@@ -368,10 +367,6 @@ class AsyncFunctionTaskTemplate(TaskTemplate[P, R]):
         if not iscoroutinefunction(self.func):
             self._call_as_synchronous = True
 
-    @cached_property
-    def native_interface(self) -> NativeInterface:
-        return NativeInterface.from_callable(self.func)
-
     def forward(self, *args: P.args, **kwargs: P.kwargs) -> Coroutine[Any, Any, R] | R:
         # In local execution, we want to just call the function. Note we're not awaiting anything here.
         # If the function was a coroutine function, the coroutine is returned and the await that the caller has

flyte/_task_environment.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import inspect
 import weakref
 from dataclasses import dataclass, field, replace
 from datetime import timedelta
@@ -68,6 +69,11 @@ class TaskEnvironment(Environment):
 
     _tasks: Dict[str, TaskTemplate] = field(default_factory=dict, init=False)
 
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        if self.reusable is not None and self.plugin_config is not None:
+            raise ValueError("Cannot set plugin_config when environment is reusable.")
+
     def clone_with(
         self,
         name: str,
@@ -144,6 +150,13 @@ class TaskEnvironment(Environment):
             friendly_name = name or func.__name__
             task_name = self.name + "." + func.__name__
 
+            if not inspect.iscoroutinefunction(func) and self.reusable is not None:
+                if self.reusable.concurrency > 1:
+                    raise ValueError(
+                        "Reusable environments with concurrency greater than 1 are only supported for async tasks. "
+                        "Please use an async function or set concurrency to 1."
+                    )
+
             if self.plugin_config is not None:
                 from flyte.extend import TaskPluginRegistry
 
@@ -156,7 +169,7 @@ class TaskEnvironment(Environment):
                         f"Please register a plugin using flyte.extend.TaskPluginRegistry.register() api."
                     )
             else:
-                task_template_class = AsyncFunctionTaskTemplate
+                task_template_class = AsyncFunctionTaskTemplate[P, R]
 
             task_template_class = cast(type[AsyncFunctionTaskTemplate[P, R]], task_template_class)
             tmpl = task_template_class(

flyte/_version.py

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

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/models.py

@@ -256,6 +256,7 @@ class NativeInterface:
     _remote_defaults: Optional[Dict[str, literals_pb2.Literal]] = field(default=None, repr=False)
 
     has_default: ClassVar[Type[_has_default]] = _has_default  # This can be used to indicate if a specific input
+
     # has a default value or not, in the case when the default value is not known. An example would be remote tasks.
 
     def has_outputs(self) -> bool:
@@ -298,7 +299,15 @@ class NativeInterface:
         sig = inspect.signature(func)
 
         # Extract parameter details (name, type, default value)
-        param_info = {name: (param.annotation, param.default) for name, param in sig.parameters.items()}
+        param_info = {}
+        for name, param in sig.parameters.items():
+            if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+                raise ValueError(f"Function {func.__name__} cannot have variable positional or keyword arguments.")
+            if param.annotation is inspect.Parameter.empty:
+                logger.warning(
+                    f"Function {func.__name__} has parameter {name} without type annotation. Data will be pickled."
+                )
+            param_info[name] = (param.annotation, param.default)
 
         # Get return type
         outputs = extract_return_annotation(sig.return_annotation)

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