flyte 0.2.0b10__py3-none-any.whl → 0.2.0b12__py3-none-any.whl

flyte/_protos/workflow/task_service_pb2_grpc.py

@@ -25,6 +25,11 @@ class TaskServiceStub(object):
                 request_serializer=workflow_dot_task__service__pb2.GetTaskDetailsRequest.SerializeToString,
                 response_deserializer=workflow_dot_task__service__pb2.GetTaskDetailsResponse.FromString,
                 )
+        self.ListTasks = channel.unary_unary(
+                '/cloudidl.workflow.TaskService/ListTasks',
+                request_serializer=workflow_dot_task__service__pb2.ListTasksRequest.SerializeToString,
+                response_deserializer=workflow_dot_task__service__pb2.ListTasksResponse.FromString,
+                )
 
 
 class TaskServiceServicer(object):
@@ -45,6 +50,13 @@ class TaskServiceServicer(object):
         context.set_details('Method not implemented!')
         raise NotImplementedError('Method not implemented!')
 
+    def ListTasks(self, request, context):
+        """Lists tasks, one per task name, returning the latest version and who it was deployed by.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
 
 def add_TaskServiceServicer_to_server(servicer, server):
     rpc_method_handlers = {
@@ -58,6 +70,11 @@ def add_TaskServiceServicer_to_server(servicer, server):
                     request_deserializer=workflow_dot_task__service__pb2.GetTaskDetailsRequest.FromString,
                     response_serializer=workflow_dot_task__service__pb2.GetTaskDetailsResponse.SerializeToString,
             ),
+            'ListTasks': grpc.unary_unary_rpc_method_handler(
+                    servicer.ListTasks,
+                    request_deserializer=workflow_dot_task__service__pb2.ListTasksRequest.FromString,
+                    response_serializer=workflow_dot_task__service__pb2.ListTasksResponse.SerializeToString,
+            ),
     }
     generic_handler = grpc.method_handlers_generic_handler(
             'cloudidl.workflow.TaskService', rpc_method_handlers)
@@ -102,3 +119,20 @@ class TaskService(object):
             workflow_dot_task__service__pb2.GetTaskDetailsResponse.FromString,
             options, channel_credentials,
             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def ListTasks(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/cloudidl.workflow.TaskService/ListTasks',
+            workflow_dot_task__service__pb2.ListTasksRequest.SerializeToString,
+            workflow_dot_task__service__pb2.ListTasksResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

flyte/_task.py

@@ -23,6 +23,7 @@ from typing import (
 
 from flyteidl.core.tasks_pb2 import DataLoadingConfig
 
+from flyte._pod import PodTemplate
 from flyte.errors import RuntimeSystemError, RuntimeUserError
 
 from ._cache import Cache, CacheRequest
@@ -37,8 +38,6 @@ from ._timeout import TimeoutType
 from .models import NativeInterface, SerializationContext
 
 if TYPE_CHECKING:
-    from kubernetes.client import V1PodTemplate
-
     from ._task_environment import TaskEnvironment
 
 P = ParamSpec("P")  # capture the function's parameters
@@ -96,8 +95,7 @@ class TaskTemplate(Generic[P, R]):
     env: Optional[Dict[str, str]] = None
     secrets: Optional[SecretRequest] = None
     timeout: Optional[TimeoutType] = None
-    primary_container_name: str = "primary"
-    pod_template: Optional[Union[str, V1PodTemplate]] = None
+    pod_template: Optional[Union[str, PodTemplate]] = None
     report: bool = False
 
     parent_env: Optional[weakref.ReferenceType[TaskEnvironment]] = None
@@ -108,15 +106,6 @@ class TaskTemplate(Generic[P, R]):
     _call_as_synchronous: bool = False
 
     def __post_init__(self):
-        # If pod_template is set to a pod, verify
-        if self.pod_template is not None and not isinstance(self.pod_template, str):
-            try:
-                from kubernetes.client import V1PodTemplate  # noqa: F401
-            except ImportError as e:
-                raise ImportError(
-                    "kubernetes is not installed, please install kubernetes package to use pod_template"
-                ) from e
-
         # Auto set the image based on the image request
         if self.image == "auto":
             self.image = Image.auto()

flyte/_trace.py

@@ -112,10 +112,8 @@ def trace(func: Callable[..., T]) -> Callable[..., T]:
     # Choose the appropriate wrapper based on the function type
     if inspect.iscoroutinefunction(func):
         # This handles async functions that return normal values
-        print(f"Coroutine function {func.__name__}")
         return cast(Callable[..., T], wrapper_async)
     elif inspect.isasyncgenfunction(func):
-        print(f"Async generator function {func.__name__}")
         return cast(Callable[..., T], wrapper_async_iterator)
     else:
         # For regular sync functions

flyte/_utils/__init__.py

@@ -9,14 +9,18 @@ from .coro_management import run_coros
 from .file_handling import filehash_update, update_hasher_for_source
 from .helpers import get_cwd_editable_install
 from .lazy_module import lazy_module
+from .org_discovery import hostname_from_url, org_from_endpoint, sanitize_endpoint
 from .uv_script_parser import parse_uv_script_file
 
 __all__ = [
     "AsyncLRUCache",
     "filehash_update",
     "get_cwd_editable_install",
+    "hostname_from_url",
     "lazy_module",
+    "org_from_endpoint",
     "parse_uv_script_file",
     "run_coros",
+    "sanitize_endpoint",
     "update_hasher_for_source",
 ]

flyte/_utils/org_discovery.py

@@ -0,0 +1,57 @@
+def hostname_from_url(url: str) -> str:
+    """Parse a URL and return the hostname part."""
+
+    # Handle dns:/// format specifically (gRPC convention)
+    if url.startswith("dns:///"):
+        return url[7:]  # Skip the "dns:///" prefix
+
+    # Handle standard URL formats
+    import urllib.parse
+
+    parsed = urllib.parse.urlparse(url)
+    return parsed.netloc or parsed.path.lstrip("/").rsplit("/")[0]
+
+
+def org_from_endpoint(endpoint: str | None) -> str | None:
+    """
+    Extracts the organization from the endpoint URL. The organization is assumed to be the first part of the domain.
+    This is temporary until we have a proper organization discovery mechanism through APIs.
+
+    :param endpoint: The endpoint URL
+    :return: The organization name or None if not found
+    """
+    if not endpoint:
+        return None
+
+    hostname = hostname_from_url(endpoint)
+    domain_parts = hostname.split(".")
+    if len(domain_parts) > 2:
+        # Assuming the organization is the first part of the domain
+        return domain_parts[0]
+    return None
+
+
+def sanitize_endpoint(endpoint: str | None) -> str | None:
+    """
+    Sanitize the endpoint URL by ensuring it has a valid scheme.
+    :param endpoint: The endpoint URL to sanitize
+    :return: Sanitized endpoint URL or None if the input was None
+    """
+    if not endpoint:
+        return None
+    if "://" not in endpoint:
+        endpoint = f"dns:///{endpoint}"
+    else:
+        if endpoint.startswith("https://"):
+            # If the endpoint starts with dns:///, we assume it's a gRPC endpoint
+            endpoint = f"dns:///{endpoint[8:]}"
+        elif endpoint.startswith("http://"):
+            # If the endpoint starts with http://, we assume it's a REST endpoint
+            endpoint = f"dns:///{endpoint[7:]}"
+        elif not endpoint.startswith("dns:///"):
+            raise RuntimeError(
+                f"Invalid endpoint {endpoint}, expected format is "
+                f"dns:///<hostname> or https://<hostname> or http://<hostname>"
+            )
+    endpoint = endpoint.removesuffix("/")
+    return endpoint

flyte/_version.py

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

flyte/cli/_abort.py

@@ -1,4 +1,5 @@
 import rich_click as click
+from rich.console import Console
 
 from flyte.cli import _common as common
 
@@ -22,5 +23,6 @@ def run(cfg: common.CLIConfig, run_name: str, project: str | None = None, domain
     cfg.init(project=project, domain=domain)
     r = Run.get(name=run_name)
     if r:
-        r.abort(r)
-        print(f"Run '{run_name}' has been aborted.")
+        console = Console()
+        r.abort()
+        console.print(f"Run '{run_name}' has been aborted.")

flyte/cli/_common.py

@@ -78,7 +78,7 @@ class CLIConfig:
     log_level: int | None = logging.ERROR
     endpoint: str | None = None
     insecure: bool = False
-    org_override: str | None = None
+    org: str | None = None
 
     def replace(self, **kwargs) -> CLIConfig:
         """
@@ -90,7 +90,7 @@ class CLIConfig:
         from flyte.config._config import TaskConfig
 
         task_cfg = TaskConfig(
-            org=self.org_override or self.config.task.org,
+            org=self.org or self.config.task.org,
             project=project or self.config.task.project,
             domain=domain or self.config.task.domain,
         )
@@ -310,12 +310,18 @@ def get_table(title: str, vals: Iterable[Any]) -> Table:
         border_style=PREFERRED_BORDER_COLOR,
     )
     headers = None
+    has_rich_repr = False
     for p in vals:
+        if hasattr(p, "__rich_repr__"):
+            has_rich_repr = True
+        elif not isinstance(p, (list, tuple)):
+            raise ValueError("Expected a list or tuple of values, or an object with __rich_repr__ method.")
+        o = p.__rich_repr__() if has_rich_repr else p
         if headers is None:
-            headers = [k for k, _ in p.__rich_repr__()]
+            headers = [k for k, _ in o]
             for h in headers:
                 table.add_column(h.capitalize())
-        table.add_row(*[str(v) for _, v in p.__rich_repr__()])
+        table.add_row(*[str(v) for _, v in o])
     return table
 
 

flyte/cli/_create.py

@@ -4,7 +4,7 @@ from typing import Any, Dict, get_args
 import rich_click as click
 
 import flyte.cli._common as common
-from flyte.remote._secret import SecretTypes
+from flyte.remote import SecretTypes
 
 
 @click.group(name="create")
@@ -86,11 +86,9 @@ def secret(
     default=False,
     help="Force overwrite of the configuration file if it already exists.",
     show_default=True,
-    prompt="Are you sure you want to overwrite the configuration file?",
-    confirmation_prompt=True,
 )
 def config(
-    output: Path,
+    output: str,
     endpoint: str | None = None,
     insecure: bool = False,
     org: str | None = None,
@@ -105,15 +103,26 @@ def config(
     """
     import yaml
 
-    if output.exists() and not force:
-        raise click.BadParameter(f"Output file {output} already exists. Use --force to overwrite.")
+    from flyte._utils import org_from_endpoint, sanitize_endpoint
+
+    output_path = Path(output)
+
+    if output_path.exists() and not force:
+        force = click.confirm(f"Overwrite [{output_path}]?", default=False)
+        if not force:
+            click.echo(f"Will not overwrite the existing config file at {output_path}")
+            return
 
     admin: Dict[str, Any] = {}
     if endpoint:
+        endpoint = sanitize_endpoint(endpoint)
         admin["endpoint"] = endpoint
     if insecure:
         admin["insecure"] = insecure
 
+    if not org and endpoint:
+        org = org_from_endpoint(endpoint)
+
     task: Dict[str, str] = {}
     if org:
         task["org"] = org
@@ -125,7 +134,7 @@ def config(
     if not admin and not task:
         raise click.BadParameter("At least one of --endpoint or --org must be provided.")
 
-    with open(output, "w") as f:
+    with open(output_path, "w") as f:
         d: Dict[str, Any] = {}
         if admin:
             d["admin"] = admin
@@ -133,4 +142,4 @@ def config(
             d["task"] = task
         yaml.dump(d, f)
 
-    click.echo(f"Config file created at {output}")
+    click.echo(f"Config file written to {output_path}")

flyte/cli/_deploy.py

@@ -74,15 +74,22 @@ class DeployEnvCommand(click.Command):
         super().__init__(*args, **kwargs)
 
     def invoke(self, ctx: Context):
-        print(f"Deploying environment: {self.obj_name}")
+        from rich.console import Console
+
+        console = Console()
+        console.print(f"Deploying root - environment: {self.obj_name}")
         obj: CLIConfig = ctx.obj
         obj.init(self.deploy_args.project, self.deploy_args.domain)
-        return flyte.deploy(
-            self.obj,
-            dryrun=self.deploy_args.dry_run,
-            copy_style=self.deploy_args.copy_style,
-            version=self.deploy_args.version,
-        )
+        with console.status("Deploying...", spinner="dots"):
+            deployment = flyte.deploy(
+                self.obj,
+                dryrun=self.deploy_args.dry_run,
+                copy_style=self.deploy_args.copy_style,
+                version=self.deploy_args.version,
+            )
+
+        console.print(common.get_table("Environments", deployment.env_repr()))
+        console.print(common.get_table("Tasks", deployment.task_repr()))
 
 
 class EnvPerFileGroup(common.ObjectsPerFileGroup):

flyte/cli/_get.py

@@ -40,7 +40,6 @@ def project(cfg: common.CLIConfig, name: str | None = None):
     """
     from flyte.remote import Project
 
-    print(cfg)
     cfg.init()
 
     console = Console()
@@ -76,10 +75,12 @@ def run(cfg: common.CLIConfig, name: str | None = None, project: str | None = No
 @get.command(cls=common.CommandBase)
 @click.argument("name", type=str, required=False)
 @click.argument("version", type=str, required=False)
+@click.option("--limit", type=int, default=100, help="Limit the number of tasks to show.")
 @click.pass_obj
 def task(
     cfg: common.CLIConfig,
     name: str | None = None,
+    limit: int = 100,
     version: str | None = None,
     project: str | None = None,
     domain: str | None = None,
@@ -95,16 +96,16 @@ def task(
 
     console = Console()
     if name:
-        if not version:
-            raise click.BadParameter("Version is required when getting a task by name.")
-        v = Task.get(name=name, version=version)
-        if v is None:
-            raise click.BadParameter(f"Task {name} not found.")
-        t = v.fetch(v)
-        console.print(pretty_repr(t))
+        if version:
+            v = Task.get(name=name, version=version)
+            if v is None:
+                raise click.BadParameter(f"Task {name} not found.")
+            t = v.fetch()
+            console.print(pretty_repr(t))
+        else:
+            console.print(common.get_table("Tasks", Task.listall(by_task_name=name, limit=limit)))
     else:
-        raise click.BadParameter("Task listing is not supported yet, please provide a name.")
-        # console.print(common.get_table("Tasks", Task.listall()))
+        console.print(common.get_table("Tasks", Task.listall(limit=limit)))
 
 
 @get.command(cls=common.CommandBase)

flyte/cli/_params.py

@@ -110,7 +110,7 @@ class FileParamType(click.ParamType):
             p = pathlib.Path(value)
             if not p.exists() or not p.is_file():
                 raise click.BadParameter(f"parameter should be a valid file path, {value}")
-        return File(path=value)
+        return File.from_existing_remote(value)
 
 
 class PickleParamType(click.ParamType):

flyte/cli/_run.py

@@ -97,7 +97,7 @@ class RunTaskCommand(click.Command):
         if obj is None:
             import flyte.config
 
-            obj = CLIConfig(flyte.config.auto())
+            obj = CLIConfig(flyte.config.auto(), ctx)
 
         if not self.run_args.local:
             assert obj.endpoint, "CLI Config should have an endpoint"

flyte/cli/main.py

@@ -146,15 +146,11 @@ def main(
     cfg = config.auto(config_file=config_file)
     logger.debug(f"Using config file discovered at location {cfg.source}")
 
-    final_insecure = cfg.platform.insecure
-    if insecure is not None:
-        final_insecure = insecure
-
     ctx.obj = CLIConfig(
         log_level=log_level,
-        endpoint=endpoint or cfg.platform.endpoint,
-        insecure=final_insecure,
-        org_override=org or cfg.task.org,
+        endpoint=endpoint,
+        insecure=insecure,
+        org=org,
         config=cfg,
         ctx=ctx,
     )

flyte/errors.py

@@ -150,3 +150,14 @@ class LogsNotYetAvailableError(BaseRuntimeError):
 
     def __init__(self, message: str):
         super().__init__("LogsNotYetAvailable", "system", message, None)
+
+
+class RuntimeDataValidationError(RuntimeUserError):
+    """
+    This error is raised when the user tries to access a resource that does not exist or is invalid.
+    """
+
+    def __init__(self, var: str, e: Exception, task_name: str = ""):
+        super().__init__(
+            "DataValiationError", f"In task {task_name} variable {var}, failed to serialize/deserialize because {e}"
+        )

flyte/extras/_container.py

@@ -9,8 +9,6 @@ from flyte._logging import logger
 from flyte._task import TaskTemplate
 from flyte.models import NativeInterface, SerializationContext
 
-_PRIMARY_CONTAINER_NAME_FIELD = "primary_container_name"
-
 
 def _extract_command_key(cmd: str, **kwargs) -> List[Any] | None:
     """
@@ -263,8 +261,3 @@ class ContainerTask(TaskTemplate):
 
     def container_args(self, sctx: SerializationContext) -> List[str]:
         return self._cmd + (self._args if self._args else [])
-
-    def config(self, sctx: SerializationContext) -> Dict[str, str]:
-        if self.pod_template is None:
-            return {}
-        return {_PRIMARY_CONTAINER_NAME_FIELD: self.primary_container_name}

flyte/remote/__init__.py

@@ -11,6 +11,7 @@ __all__ = [
     "Run",
     "RunDetails",
     "Secret",
+    "SecretTypes",
     "Task",
     "create_channel",
     "upload_dir",
@@ -21,5 +22,5 @@ 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 ._secret import Secret
+from ._secret import Secret, SecretTypes
 from ._task import Task

flyte/remote/_client/_protocols.py

@@ -58,6 +58,8 @@ class TaskService(Protocol):
         self, request: task_service_pb2.GetTaskDetailsRequest
     ) -> task_service_pb2.GetTaskDetailsResponse: ...
 
+    async def ListTasks(self, request: task_service_pb2.ListTasksRequest) -> task_service_pb2.ListTasksResponse: ...
+
 
 class RunService(Protocol):
     async def CreateRun(self, request: run_service_pb2.CreateRunRequest) -> run_service_pb2.CreateRunResponse: ...

flyte/remote/_data.py

@@ -100,7 +100,8 @@ async def _upload_single_file(
             if put_resp.status_code != 200:
                 raise RuntimeSystemError(
                     "UploadFailed",
-                    f"Failed to upload {fp} to {resp.signed_url}, status code: {put_resp.status_code}",
+                    f"Failed to upload {fp} to {resp.signed_url}, status code: {put_resp.status_code}, "
+                    f"response: {put_resp.text}",
                 )
         # TODO in old code we did this
         #             if self._config.platform.insecure_skip_verify is True