flyte 2.0.0b25__py3-none-any.whl → 2.0.0b28__py3-none-any.whl

flyte/connectors/_connector.py

@@ -0,0 +1,270 @@
+import asyncio
+import json
+import typing
+from abc import ABC, abstractmethod
+from dataclasses import asdict, dataclass
+from typing import Any, Dict, List, Optional
+
+from flyteidl2.core import tasks_pb2
+from flyteidl2.core.execution_pb2 import TaskExecution, TaskLog
+from flyteidl2.plugins import connector_pb2
+from flyteidl2.plugins.connector_pb2 import (
+    Connector,
+    GetTaskLogsResponse,
+    GetTaskMetricsResponse,
+    TaskCategory,
+    TaskExecutionMetadata,
+)
+from google.protobuf import json_format
+from google.protobuf.struct_pb2 import Struct
+
+from flyte import Secret
+from flyte._context import internal_ctx
+from flyte._initialize import get_init_config
+from flyte._internal.runtime.convert import convert_from_native_to_outputs
+from flyte._internal.runtime.task_serde import get_proto_task
+from flyte._logging import logger
+from flyte._task import TaskTemplate
+from flyte.connectors.utils import is_terminal_phase
+from flyte.models import NativeInterface, SerializationContext
+from flyte.types._type_engine import dataclass_from_dict
+
+
+@dataclass(frozen=True)
+class ConnectorRegistryKey:
+    task_type_name: str
+    task_type_version: int
+
+
+@dataclass
+class ResourceMeta:
+    """
+    This is the metadata for the job. For example, the id of the job.
+    """
+
+    def encode(self) -> bytes:
+        """
+        Encode the resource meta to bytes.
+        """
+        return json.dumps(asdict(self)).encode("utf-8")
+
+    @classmethod
+    def decode(cls, data: bytes) -> "ResourceMeta":
+        """
+        Decode the resource meta from bytes.
+        """
+        return dataclass_from_dict(cls, json.loads(data.decode("utf-8")))
+
+
+@dataclass
+class Resource:
+    """
+    This is the output resource of the job.
+
+    Attributes
+    ----------
+        phase : TaskExecution.Phase
+            The phase of the job.
+        message : Optional[str]
+            The return message from the job.
+        log_links : Optional[List[TaskLog]]
+            The log links of the job. For example, the link to the BigQuery Console.
+        outputs : Optional[Union[LiteralMap, typing.Dict[str, Any]]]
+            The outputs of the job. If return python native types, the agent will convert them to flyte literals.
+        custom_info : Optional[typing.Dict[str, Any]]
+            The custom info of the job. For example, the job config.
+    """
+
+    phase: TaskExecution.Phase
+    message: Optional[str] = None
+    log_links: Optional[List[TaskLog]] = None
+    outputs: Optional[Dict[str, Any]] = None
+    custom_info: Optional[typing.Dict[str, Any]] = None
+
+
+class AsyncConnector(ABC):
+    """
+    This is the base class for all async connectors, and it defines the interface that all connectors must implement.
+    The connector service is responsible for invoking connectors.
+    The executor will communicate with the connector service to create tasks, get the status of tasks, and delete tasks.
+
+    All the connectors should be registered in the ConnectorRegistry.
+    Connector Service will look up the connector based on the task type and version.
+    """
+
+    name = "Async Connector"
+    task_type_name: str
+    task_type_version: int = 0
+    metadata_type: ResourceMeta
+
+    @abstractmethod
+    async def create(
+        self,
+        task_template: tasks_pb2.TaskTemplate,
+        output_prefix: str,
+        inputs: Optional[Dict[str, typing.Any]] = None,
+        task_execution_metadata: Optional[TaskExecutionMetadata] = None,
+        **kwargs,
+    ) -> ResourceMeta:
+        """
+        Return a resource meta that can be used to get the status of the task.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    async def get(self, resource_meta: ResourceMeta, **kwargs) -> Resource:
+        """
+        Return the status of the task, and return the outputs in some cases. For example, bigquery job
+        can't write the structured dataset to the output location, so it returns the output literals to the propeller,
+        and the propeller will write the structured dataset to the blob store.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    async def delete(self, resource_meta: ResourceMeta, **kwargs):
+        """
+        Delete the task. This call should be idempotent. It should raise an error if fails to delete the task.
+        """
+        raise NotImplementedError
+
+    async def get_metrics(self, resource_meta: ResourceMeta, **kwargs) -> GetTaskMetricsResponse:
+        """
+        Return the metrics for the task.
+        """
+        raise NotImplementedError
+
+    async def get_logs(self, resource_meta: ResourceMeta, **kwargs) -> GetTaskLogsResponse:
+        """
+        Return the metrics for the task.
+        """
+        raise NotImplementedError
+
+
+class ConnectorRegistry(object):
+    """
+    This is the registry for all connectors.
+    The connector service will look up the connector registry based on the task type and version.
+    """
+
+    _REGISTRY: typing.ClassVar[Dict[ConnectorRegistryKey, AsyncConnector]] = {}
+    _METADATA: typing.ClassVar[Dict[str, Connector]] = {}
+
+    @staticmethod
+    def register(connector: AsyncConnector, override: bool = False):
+        key = ConnectorRegistryKey(
+            task_type_name=connector.task_type_name, task_type_version=connector.task_type_version
+        )
+        if key in ConnectorRegistry._REGISTRY and override is False:
+            raise ValueError(
+                f"Duplicate connector for task type: {connector.task_type_name}"
+                f" and version: {connector.task_type_version}"
+            )
+        ConnectorRegistry._REGISTRY[key] = connector
+
+        task_category = TaskCategory(name=connector.task_type_name, version=connector.task_type_version)
+
+        if connector.name in ConnectorRegistry._METADATA:
+            connector_metadata = ConnectorRegistry.get_connector_metadata(connector.name)
+            connector_metadata.supported_task_categories.append(task_category)
+        else:
+            connector_metadata = Connector(
+                name=connector.name,
+                supported_task_categories=[task_category],
+            )
+            ConnectorRegistry._METADATA[connector.name] = connector_metadata
+
+    @staticmethod
+    def get_connector(task_type_name: str, task_type_version: int = 0) -> AsyncConnector:
+        key = ConnectorRegistryKey(task_type_name=task_type_name, task_type_version=task_type_version)
+        if key not in ConnectorRegistry._REGISTRY:
+            raise FlyteConnectorNotFound(
+                f"Cannot find connector for task type: {task_type_name} and version: {task_type_version}"
+            )
+        return ConnectorRegistry._REGISTRY[key]
+
+    @staticmethod
+    def list_connectors() -> List[Connector]:
+        return list(ConnectorRegistry._METADATA.values())
+
+    @staticmethod
+    def get_connector_metadata(name: str) -> Connector:
+        if name not in ConnectorRegistry._METADATA:
+            raise FlyteConnectorNotFound(f"Cannot find connector for name: {name}.")
+        return ConnectorRegistry._METADATA[name]
+
+
+class ConnectorSecretsMixin:
+    def __init__(self, secrets: Dict[str, str]):
+        # Key is the id of the secret, value is the secret name.
+        self._secrets = secrets
+
+    @property
+    def secrets(self) -> List[Secret]:
+        return [Secret(key=k, as_env_var=v) for k, v in self._secrets.items()]
+
+
+class AsyncConnectorExecutorMixin:
+    """
+    This mixin class is used to run the connector task locally, and it's only used for local execution.
+    Task should inherit from this class if the task can be run in the connector.
+    """
+
+    async def execute(self, **kwargs) -> Any:
+        task = typing.cast(TaskTemplate, self)
+        connector = ConnectorRegistry.get_connector(task.task_type, task.task_type_version)
+
+        ctx = internal_ctx()
+        tctx = internal_ctx().data.task_context
+        cfg = get_init_config()
+
+        if tctx is None:
+            raise RuntimeError("Task context is not set.")
+
+        sc = SerializationContext(
+            project=tctx.action.project,
+            domain=tctx.action.domain,
+            org=tctx.action.org,
+            code_bundle=tctx.code_bundle,
+            version=tctx.version,
+            image_cache=tctx.compiled_image_cache,
+            root_dir=cfg.root_dir,
+        )
+        tt = get_proto_task(task, sc)
+        resource_meta = await connector.create(task_template=tt, output_prefix=ctx.raw_data.path, inputs=kwargs)
+        resource = Resource(phase=TaskExecution.RUNNING)
+
+        while not is_terminal_phase(resource.phase):
+            resource = await connector.get(resource_meta=resource_meta)
+
+            if resource.log_links:
+                for link in resource.log_links:
+                    logger.info(f"{link.name}: {link.uri}")
+            await asyncio.sleep(1)
+
+        if resource.phase != TaskExecution.SUCCEEDED:
+            raise RuntimeError(f"Failed to run the task {task.name} with error: {resource.message}")
+
+        # TODO: Support abort
+
+        if resource.outputs is None:
+            return None
+        return tuple(resource.outputs.values())
+
+
+async def get_resource_proto(resource: Resource) -> connector_pb2.Resource:
+    if resource.outputs:
+        interface = NativeInterface.from_types(inputs={}, outputs={k: type(v) for k, v in resource.outputs.items()})
+        outputs = await convert_from_native_to_outputs(tuple(resource.outputs.values()), interface)
+    else:
+        outputs = None
+
+    return connector_pb2.Resource(
+        phase=resource.phase,
+        message=resource.message,
+        log_links=resource.log_links,
+        outputs=outputs,
+        custom_info=(json_format.Parse(json.dumps(resource.custom_info), Struct()) if resource.custom_info else None),
+    )
+
+
+class FlyteConnectorNotFound(ValueError): ...

flyte/connectors/_server.py

@@ -0,0 +1,183 @@
+import inspect
+from http import HTTPStatus
+from typing import Callable, Dict, Tuple, Type, Union
+
+import grpc
+from flyteidl2.core.security_pb2 import Connection
+from flyteidl2.plugins.connector_pb2 import (
+    CreateTaskRequest,
+    CreateTaskResponse,
+    DeleteTaskRequest,
+    DeleteTaskResponse,
+    GetConnectorRequest,
+    GetConnectorResponse,
+    GetTaskLogsRequest,
+    GetTaskLogsResponse,
+    GetTaskMetricsRequest,
+    GetTaskMetricsResponse,
+    GetTaskRequest,
+    GetTaskResponse,
+    ListConnectorsRequest,
+    ListConnectorsResponse,
+)
+from flyteidl2.service.connector_pb2_grpc import (
+    AsyncConnectorServiceServicer,
+    ConnectorMetadataServiceServicer,
+)
+from prometheus_client import Counter, Summary
+
+from flyte._internal.runtime.convert import Inputs, convert_from_inputs_to_native
+from flyte._logging import logger
+from flyte.connectors._connector import ConnectorRegistry, FlyteConnectorNotFound, get_resource_proto
+from flyte.models import NativeInterface, _has_default
+from flyte.types import TypeEngine
+
+metric_prefix = "flyte_connector_"
+create_operation = "create"
+get_operation = "get"
+delete_operation = "delete"
+
+# Follow the naming convention. https://prometheus.io/docs/practices/naming/
+request_success_count = Counter(
+    f"{metric_prefix}requests_success_total",
+    "Total number of successful requests",
+    ["task_type", "operation"],
+)
+request_failure_count = Counter(
+    f"{metric_prefix}requests_failure_total",
+    "Total number of failed requests",
+    ["task_type", "operation", "error_code"],
+)
+request_latency = Summary(
+    f"{metric_prefix}request_latency_seconds",
+    "Time spent processing connector request",
+    ["task_type", "operation"],
+)
+input_literal_size = Summary(f"{metric_prefix}input_literal_bytes", "Size of input literal", ["task_type"])
+
+
+def _handle_exception(e: Exception, context: grpc.ServicerContext, task_type: str, operation: str):
+    if isinstance(e, FlyteConnectorNotFound):
+        error_message = f"Cannot find connector for task type: {task_type}."
+        logger.error(error_message)
+        context.set_code(grpc.StatusCode.NOT_FOUND)
+        context.set_details(error_message)
+        request_failure_count.labels(task_type=task_type, operation=operation, error_code=HTTPStatus.NOT_FOUND).inc()
+    else:
+        error_message = f"failed to {operation} {task_type} task with error:\n {e}."
+        logger.error(error_message)
+        context.set_code(grpc.StatusCode.INTERNAL)
+        context.set_details(error_message)
+        request_failure_count.labels(
+            task_type=task_type, operation=operation, error_code=HTTPStatus.INTERNAL_SERVER_ERROR
+        ).inc()
+
+
+def record_connector_metrics(func: Callable):
+    async def wrapper(
+        self,
+        request: Union[CreateTaskRequest, GetTaskRequest, DeleteTaskRequest],
+        context: grpc.ServicerContext,
+        *args,
+        **kwargs,
+    ):
+        if isinstance(request, CreateTaskRequest):
+            task_type = request.template.type
+            operation = create_operation
+            if request.inputs:
+                input_literal_size.labels(task_type=task_type).observe(request.inputs.ByteSize())
+        elif isinstance(request, GetTaskRequest):
+            task_type = request.task_category.name
+            operation = get_operation
+        elif isinstance(request, DeleteTaskRequest):
+            task_type = request.task_category.name
+            operation = delete_operation
+        else:
+            context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+            context.set_details("Method not implemented!")
+            return None
+
+        try:
+            with request_latency.labels(task_type=task_type, operation=operation).time():
+                res = await func(self, request, context, *args, **kwargs)
+            request_success_count.labels(task_type=task_type, operation=operation).inc()
+            return res
+        except Exception as e:
+            _handle_exception(e, context, task_type, operation)
+
+    return wrapper
+
+
+def _get_connection_kwargs(request: Connection) -> Dict[str, str]:
+    kwargs = {}
+
+    for k, v in request.secrets.items():
+        kwargs[k] = v
+    for k, v in request.configs.items():
+        kwargs[k] = v
+
+    return kwargs
+
+
+class AsyncConnectorService(AsyncConnectorServiceServicer):
+    @record_connector_metrics
+    async def CreateTask(self, request: CreateTaskRequest, context: grpc.ServicerContext) -> CreateTaskResponse:
+        template = request.template
+        connector = ConnectorRegistry.get_connector(template.type, template.task_type_version)
+        logger.info(f"{connector.name} start creating the job")
+        python_interface_inputs: Dict[str, Tuple[Type, Type[_has_default] | Type[inspect._empty]]] = {
+            name: (TypeEngine.guess_python_type(lt.type), inspect.Parameter.empty)
+            for name, lt in template.interface.inputs.variables.items()
+        }
+        native_interface = NativeInterface.from_types(inputs=python_interface_inputs, outputs={})
+        native_inputs = await convert_from_inputs_to_native(native_interface, Inputs(proto_inputs=request.inputs))
+        resource_meta = await connector.create(
+            task_template=request.template,
+            inputs=native_inputs,
+            output_prefix=request.output_prefix,
+            task_execution_metadata=request.task_execution_metadata,
+            connection=_get_connection_kwargs(request.connection),
+        )
+        return CreateTaskResponse(resource_meta=resource_meta.encode())
+
+    @record_connector_metrics
+    async def GetTask(self, request: GetTaskRequest, context: grpc.ServicerContext) -> GetTaskResponse:
+        connector = ConnectorRegistry.get_connector(request.task_category.name, request.task_category.version)
+        logger.info(f"{connector.name} start checking the status of the job")
+        res = await connector.get(
+            resource_meta=connector.metadata_type.decode(request.resource_meta),
+            connection=_get_connection_kwargs(request.connection),
+        )
+        return GetTaskResponse(resource=await get_resource_proto(res))
+
+    @record_connector_metrics
+    async def DeleteTask(self, request: DeleteTaskRequest, context: grpc.ServicerContext) -> DeleteTaskResponse:
+        connector = ConnectorRegistry.get_connector(request.task_category.name, request.task_category.version)
+        logger.info(f"{connector.name} start deleting the job")
+        await connector.delete(
+            resource_meta=connector.metadata_type.decode(request.resource_meta),
+            connection=_get_connection_kwargs(request.connection),
+        )
+        return DeleteTaskResponse()
+
+    async def GetTaskMetrics(
+        self, request: GetTaskMetricsRequest, context: grpc.ServicerContext
+    ) -> GetTaskMetricsResponse:
+        connector = ConnectorRegistry.get_connector(request.task_category.name, request.task_category.version)
+        logger.info(f"{connector.name} start getting metrics of the job")
+        return await connector.get_metrics(resource_meta=connector.metadata_type.decode(request.resource_meta))
+
+    async def GetTaskLogs(self, request: GetTaskLogsRequest, context: grpc.ServicerContext) -> GetTaskLogsResponse:
+        connector = ConnectorRegistry.get_connector(request.task_category.name, request.task_category.version)
+        logger.info(f"{connector.name} start getting logs of the job")
+        return await connector.get_logs(resource_meta=connector.metadata_type.decode(request.resource_meta))
+
+
+class ConnectorMetadataService(ConnectorMetadataServiceServicer):
+    async def GetConnector(self, request: GetConnectorRequest, context: grpc.ServicerContext) -> GetConnectorResponse:
+        return GetConnectorResponse(connector=ConnectorRegistry.get_connector_metadata(request.name))
+
+    async def ListConnectors(
+        self, request: ListConnectorsRequest, context: grpc.ServicerContext
+    ) -> ListConnectorsResponse:
+        return ListConnectorsResponse(connectors=ConnectorRegistry.list_connectors())

flyte/connectors/utils.py

@@ -0,0 +1,26 @@
+from flyteidl2.core.execution_pb2 import TaskExecution
+
+
+def is_terminal_phase(phase: TaskExecution.Phase) -> bool:
+    """
+    Return true if the phase is terminal.
+    """
+    return phase in [TaskExecution.SUCCEEDED, TaskExecution.ABORTED, TaskExecution.FAILED]
+
+
+def convert_to_flyte_phase(state: str) -> TaskExecution.Phase:
+    """
+    Convert the state from the connector to the phase in flyte.
+    """
+    state = state.lower()
+    if state in ["failed", "timeout", "timedout", "canceled", "cancelled", "skipped"]:
+        return TaskExecution.FAILED
+    if state in ["internal_error"]:
+        return TaskExecution.RETRYABLE_FAILED
+    elif state in ["done", "succeeded", "success", "completed"]:
+        return TaskExecution.SUCCEEDED
+    elif state in ["running", "terminating"]:
+        return TaskExecution.RUNNING
+    elif state in ["pending"]:
+        return TaskExecution.INITIALIZING
+    raise ValueError(f"Unrecognized state: {state}")

flyte/models.py

@@ -355,10 +355,18 @@ class NativeInterface:
         """
         Extract the native interface from the given function. This is used to create a native interface for the task.
         """
+        # Get function parameters, defaults, varargs info (POSITIONAL_ONLY, VAR_POSITIONAL, KEYWORD_ONLY, etc.).
         sig = inspect.signature(func)
 
         # Extract parameter details (name, type, default value)
         param_info = {}
+        try:
+            # Get fully evaluated, real Python types for type checking.
+            hints = typing.get_type_hints(func, include_extras=True)
+        except Exception as e:
+            logger.warning(f"Could not get type hints for function {func.__name__}: {e}")
+            raise
+
         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.")
@@ -366,13 +374,14 @@ class NativeInterface:
                 logger.warning(
                     f"Function {func.__name__} has parameter {name} without type annotation. Data will be pickled."
                 )
-            if typing.get_origin(param.annotation) is Literal:
-                param_info[name] = (literal_to_enum(param.annotation), param.default)
+            arg_type = hints.get(name, param.annotation)
+            if typing.get_origin(arg_type) is Literal:
+                param_info[name] = (literal_to_enum(arg_type), param.default)
             else:
-                param_info[name] = (param.annotation, param.default)
+                param_info[name] = (arg_type, param.default)
 
         # Get return type
-        outputs = extract_return_annotation(sig.return_annotation)
+        outputs = extract_return_annotation(hints.get("return", sig.return_annotation))
         return cls(inputs=param_info, outputs=outputs)
 
     def convert_to_kwargs(self, *args, **kwargs) -> Dict[str, Any]:

flyte/remote/_client/auth/_channel.py

@@ -7,6 +7,7 @@ import httpx
 from grpc.experimental.aio import init_grpc_aio
 
 from flyte._logging import logger
+from flyte._utils.org_discovery import hostname_from_url
 
 from ._authenticators.base import get_async_session
 from ._authenticators.factory import (
@@ -30,16 +31,19 @@ def bootstrap_ssl_from_server(endpoint: str) -> grpc.ChannelCredentials:
     :param endpoint: The endpoint URL to retrieve the SSL certificate from, may include port number
     :return: gRPC channel credentials created from the retrieved certificate
     """
+    hostname = hostname_from_url(endpoint)
+
     # Get port from endpoint or use 443
-    endpoint_parts = endpoint.rsplit(":", 1)
+    endpoint_parts = hostname.rsplit(":", 1)
     if len(endpoint_parts) == 2 and endpoint_parts[1].isdigit():
         server_address = (endpoint_parts[0], int(endpoint_parts[1]))
     else:
-        logger.warning(f"Unrecognized port in endpoint [{endpoint}], defaulting to 443.")
-        server_address = (endpoint, 443)
+        logger.warning(f"Unrecognized port in endpoint [{hostname}], defaulting to 443.")
+        server_address = (hostname, 443)
 
-    # Run the blocking SSL certificate retrieval in a thread pool
-    cert = ssl.get_server_certificate(server_address)
+    # Run the blocking SSL certificate retrieval with a timeout
+    logger.debug(f"Retrieving SSL certificate from {server_address}")
+    cert = ssl.get_server_certificate(server_address, timeout=10)
     return grpc.ssl_channel_credentials(str.encode(cert))
 
 

flyte/remote/_console.py

@@ -9,8 +9,9 @@ def _get_http_domain(endpoint: str, insecure: bool) -> str:
     else:
         domain = parsed.netloc or parsed.path
     # TODO: make console url configurable
-    if domain.split(":")[0] == "localhost":
-        domain = "localhost:8080"
+    domain_split = domain.split(":")
+    if domain_split[0] == "localhost":
+        domain = domain if len(domain_split) > 1 else f"{domain}:8080"
     return f"{scheme}://{domain}"
 
 

flyte/remote/_secret.py

@@ -79,21 +79,23 @@ class Secret(ToJSONMixin):
     async def listall(cls, limit: int = 100) -> AsyncIterator[Secret]:
         ensure_client()
         cfg = get_init_config()
-        token = None
+        per_cluster_tokens = None
         while True:
             resp = await get_client().secrets_service.ListSecrets(  # type: ignore
                 request=payload_pb2.ListSecretsRequest(
                     organization=cfg.org,
                     project=cfg.project,
                     domain=cfg.domain,
-                    token=token,
+                    per_cluster_tokens=per_cluster_tokens,
                     limit=limit,
                 ),
             )
-            token = resp.token
+            per_cluster_tokens = resp.per_cluster_tokens
+            round_items = [v for _, v in per_cluster_tokens.items() if v]
+            has_next = any(round_items)
             for r in resp.secrets:
                 yield cls(r)
-            if not token:
+            if not has_next:
                 break
 
     @syncify

flyte/remote/_trigger.py

@@ -284,9 +284,9 @@ class Trigger(ToJSONMixin):
         return self.pb2.active
 
     def _rich_automation(self, automation: common_pb2.TriggerAutomationSpec):
-        if automation.type == common_pb2.TriggerAutomationSpec.TYPE_NONE:
+        if automation.type == common_pb2.TriggerAutomationSpec.type.TYPE_NONE:
             yield "none", None
-        elif automation.type == common_pb2.TriggerAutomationSpec.TYPE_SCHEDULE:
+        elif automation.type == common_pb2.TriggerAutomationSpec.type.TYPE_SCHEDULE:
             if automation.schedule.cron_expression is not None:
                 yield "cron", automation.schedule.cron_expression
             elif automation.schedule.rate is not None:

flyte/types/_type_engine.py

@@ -1911,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
@@ -1991,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
 
 

{flyte-2.0.0b25.data → flyte-2.0.0b28.data}/scripts/runtime.py

@@ -12,6 +12,7 @@ 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
@@ -27,6 +28,7 @@ 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"
 
@@ -139,6 +141,12 @@ def main(
             controller_kwargs["insecure"] = True
         logger.debug(f"Using controller endpoint: {ep} with kwargs: {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)

{flyte-2.0.0b25.dist-info → flyte-2.0.0b28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flyte
-Version: 2.0.0b25
+Version: 2.0.0b28
 Summary: Add your description here
 Author-email: Ketan Umare <kumare3@users.noreply.github.com>
 Requires-Python: >=3.10
@@ -25,9 +25,13 @@ 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.0a10
+Requires-Dist: flyteidl2==2.0.0a11
 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 🚀