mlrun 1.10.0rc35__tar.gz → 1.10.0rc37__tar.gz

{mlrun-1.10.0rc35/mlrun.egg-info → mlrun-1.10.0rc37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mlrun
-Version: 1.10.0rc35
+Version: 1.10.0rc37
 Summary: Tracking and config of machine learning runs
 Home-page: https://github.com/mlrun/mlrun
 Author: Yaron Haviv

{mlrun-1.10.0rc35 → mlrun-1.10.0rc37}/mlrun/common/schemas/hub.py

@@ -138,4 +138,4 @@ class HubCatalog(BaseModel):
 
 class HubModuleType(mlrun.common.types.StrEnum):
     generic = "generic"
-    monitoring_app = "monitoring-app"
+    monitoring_app = "monitoring_application"

{mlrun-1.10.0rc35 → mlrun-1.10.0rc37}/mlrun/config.py

@@ -304,6 +304,7 @@ default_config = {
         "application": {
             "default_sidecar_internal_port": 8050,
             "default_authentication_mode": mlrun.common.schemas.APIGatewayAuthenticationMode.none,
+            "default_worker_number": 10000,
         },
     },
     # TODO: function defaults should be moved to the function spec config above

{mlrun-1.10.0rc35 → mlrun-1.10.0rc37}/mlrun/db/base.py

@@ -722,7 +722,9 @@ class RunDBInterface(ABC):
         tsdb_metrics: bool = False,
         metric_list: Optional[list[str]] = None,
         top_level: bool = False,
-        modes: Optional[list[mm_constants.EndpointMode]] = None,
+        modes: Optional[
+            Union[mm_constants.EndpointMode, list[mm_constants.EndpointMode]]
+        ] = None,
         uids: Optional[list[str]] = None,
         latest_only: bool = False,
     ) -> mlrun.common.schemas.ModelEndpointList:

{mlrun-1.10.0rc35 → mlrun-1.10.0rc37}/mlrun/db/httpdb.py

@@ -3771,7 +3771,9 @@ class HTTPRunDB(RunDBInterface):
         tsdb_metrics: bool = False,
         metric_list: Optional[list[str]] = None,
         top_level: bool = False,
-        modes: Optional[list[mm_constants.EndpointMode]] = None,
+        modes: Optional[
+            Union[mm_constants.EndpointMode, list[mm_constants.EndpointMode]]
+        ] = None,
         uids: Optional[list[str]] = None,
         latest_only: bool = False,
     ) -> mlrun.common.schemas.ModelEndpointList:
@@ -3802,8 +3804,13 @@ class HTTPRunDB(RunDBInterface):
         labels = self._parse_labels(labels)
         if names and isinstance(names, str):
             names = [names]
-        if isinstance(modes, mm_constants.EndpointMode):
-            modes = [modes]
+        if modes:
+            # Ensure backward compatibility with Python 3.9 clients by converting IntEnum modes to integer values
+            modes = (
+                [modes.value]
+                if isinstance(modes, mm_constants.EndpointMode)
+                else [mode.value for mode in modes]
+            )
         response = self.api_call(
             method=mlrun.common.types.HTTPMethod.GET,
             path=path,

{mlrun-1.10.0rc35 → mlrun-1.10.0rc37}/mlrun/db/nopdb.py

@@ -626,7 +626,9 @@ class NopDB(RunDBInterface):
         tsdb_metrics: bool = False,
         metric_list: Optional[list[str]] = None,
         top_level: bool = False,
-        modes: Optional[list[mm_constants.EndpointMode]] = None,
+        modes: Optional[
+            Union[mm_constants.EndpointMode, list[mm_constants.EndpointMode]]
+        ] = None,
         uids: Optional[list[str]] = None,
         latest_only: bool = False,
     ) -> mlrun.common.schemas.ModelEndpointList:

{mlrun-1.10.0rc35 → mlrun-1.10.0rc37}/mlrun/hub/module.py

@@ -26,6 +26,7 @@ from mlrun.common.schemas.hub import HubModuleType, HubSourceType
 from mlrun.run import function_to_module, get_object
 from mlrun.utils import logger
 
+from ..errors import MLRunBadRequestError
 from ..model import ModelObj
 from ..utils import extend_hub_uri_if_needed
 
@@ -109,19 +110,33 @@ class HubModule(ModelObj):
             f.write(data)
 
     @staticmethod
-    def verify_directory(path: str) -> Path:
-        """Validate that the given path is an existing directory."""
+    def verify_directory(path: Optional[str] = None) -> Path:
+        """
+        Validate that the given path is an existing directory.
+        If no path has been provided, returns current working directory.
+        """
         if path:
             path = Path(path)
             if not path.exists():
                 raise ValueError(f"Path does not exist: {path}")
             if not path.is_dir():
                 raise ValueError(f"Path is not a directory: {path}")
-        return path
+            return path
+        return Path(os.getcwd())
+
+    def get_module_file_path(self):
+        if not self.local_path:
+            raise MLRunBadRequestError(
+                "module files haven't been downloaded yet, try calling download_module_files() first"
+            )
+        return str(Path(self.local_path) / self.filename)
 
 
 def get_hub_module(
-    url="", download_files=True, secrets=None, local_path=None
+    url: str = "",
+    download_files: Optional[bool] = True,
+    secrets: Optional[dict] = None,
+    local_path: Optional[str] = None,
 ) -> HubModule:
     """
     Get a hub-module object containing metadata of the requested module.

{mlrun-1.10.0rc35 → mlrun-1.10.0rc37}/mlrun/model.py

@@ -667,7 +667,7 @@ class ImageBuilder(ModelObj):
         """
         requirements = requirements or []
         self._verify_list(requirements, "requirements")
-        resolved_requirements = self._resolve_requirements(
+        resolved_requirements = self.resolve_requirements(
             requirements, requirements_file
         )
         requirements = self.requirements or [] if not overwrite else []
@@ -680,7 +680,7 @@ class ImageBuilder(ModelObj):
         self.requirements = requirements
 
     @staticmethod
-    def _resolve_requirements(requirements: list, requirements_file: str = "") -> list:
+    def resolve_requirements(requirements: list, requirements_file: str = "") -> list:
         requirements = requirements or []
         requirements_to_resolve = []
 

{mlrun-1.10.0rc35 → mlrun-1.10.0rc37}/mlrun/model_monitoring/api.py

@@ -30,8 +30,9 @@ from mlrun.common.schemas.model_monitoring import (
     FunctionURI,
 )
 from mlrun.data_types.infer import InferOptions, get_df_stats
-from mlrun.utils import datetime_now, logger
+from mlrun.utils import check_if_hub_uri, datetime_now, logger, merge_requirements
 
+from ..common.schemas.hub import HubModuleType
 from .helpers import update_model_endpoint_last_request
 
 # A union of all supported dataset types:
@@ -548,8 +549,9 @@ def _create_model_monitoring_function_base(
     name: typing.Optional[str] = None,
     image: typing.Optional[str] = None,
     tag: typing.Optional[str] = None,
-    requirements: typing.Union[str, list[str], None] = None,
+    requirements: typing.Union[list[str], None] = None,
     requirements_file: str = "",
+    local_path: typing.Optional[str] = None,
     **application_kwargs,
 ) -> mlrun.runtimes.ServingRuntime:
     """
@@ -567,6 +569,19 @@ def _create_model_monitoring_function_base(
         )
     if func is None:
         func = ""
+    if check_if_hub_uri(func):
+        hub_module = mlrun.get_hub_module(url=func, local_path=local_path)
+        if hub_module.kind != HubModuleType.monitoring_app:
+            raise mlrun.errors.MLRunInvalidArgumentError(
+                "The provided module is not a monitoring application"
+            )
+        requirements = mlrun.model.ImageBuilder.resolve_requirements(
+            requirements, requirements_file
+        )
+        requirements = merge_requirements(
+            reqs_priority=requirements, reqs_secondary=hub_module.requirements
+        )
+        func = hub_module.get_module_file_path()
     func_obj = typing.cast(
         mlrun.runtimes.ServingRuntime,
         mlrun.code_to_function(

{mlrun-1.10.0rc35 → mlrun-1.10.0rc37}/mlrun/model_monitoring/applications/base.py

@@ -233,7 +233,7 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
         try:
             yield endpoints_output, application_schedules.__enter__()
         finally:
-            if write_output:
+            if write_output and any(endpoints_output.values()):
                 logger.debug(
                     "Pushing model monitoring application job data to the writer stream",
                     passed_stream_profile=str(stream_profile),
@@ -344,7 +344,7 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
                 return result
 
             if endpoints is not None:
-                resolved_endpoints = self._validate_endpoints(
+                resolved_endpoints = self._normalize_and_validate_endpoints(
                     project=project, endpoints=endpoints
                 )
                 if (
@@ -390,6 +390,16 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
                         context.log_result(
                             result_key, self._flatten_data_result(result)
                         )
+                # Check if no result was produced for any endpoint (e.g., due to no data in all windows)
+                if not any(endpoints_output.values()):
+                    context.logger.warning(
+                        "No data was found for any of the specified endpoints. "
+                        "No results were produced",
+                        application_name=application_name,
+                        endpoints=endpoints,
+                        start=start,
+                        end=end,
+                    )
             else:
                 result = call_do_tracking(
                     mm_context.MonitoringApplicationContext._from_ml_ctx(
@@ -421,69 +431,97 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
             )
 
     @classmethod
-    def _validate_endpoints(
+    def _normalize_and_validate_endpoints(
         cls,
         project: "mlrun.MlrunProject",
         endpoints: Union[
             list[tuple[str, str]], list[list[str]], list[str], Literal["all"]
         ],
-    ) -> Union[list[tuple[str, str]], list[list[str]]]:
-        if not endpoints:
-            raise mlrun.errors.MLRunValueError(
-                "The endpoints list cannot be empty. If you want to run on all the endpoints, "
-                'use `endpoints="all"`.'
-            )
-
-        if isinstance(endpoints, list) and isinstance(endpoints[0], (tuple, list)):
-            return endpoints
-
-        if not (isinstance(endpoints, list) and isinstance(endpoints[0], str)):
-            if isinstance(endpoints, str):
-                if endpoints != "all":
-                    raise mlrun.errors.MLRunValueError(
-                        'A string input for `endpoints` can only be "all" for all the model endpoints in '
-                        "the project. If you want to select a single model endpoint with the given name, "
-                        f'use a list: `endpoints=["{endpoints}"]`.'
+    ) -> list[tuple[str, str]]:
+        if isinstance(endpoints, list):
+            if all(
+                isinstance(endpoint, (tuple, list)) and len(endpoint) == 2
+                for endpoint in endpoints
+            ):
+                # A list of [(name, uid), ...] / [[name, uid], ...] tuples/lists
+                endpoint_uids_to_names = {
+                    endpoint[1]: endpoint[0] for endpoint in endpoints
+                }
+                endpoints_list = project.list_model_endpoints(
+                    uids=list(endpoint_uids_to_names.keys()), latest_only=True
+                ).endpoints
+
+                # Check for missing endpoint uids or name/uid mismatches
+                for endpoint in endpoints_list:
+                    if (
+                        endpoint_uids_to_names[cast(str, endpoint.metadata.uid)]
+                        != endpoint.metadata.name
+                    ):
+                        raise mlrun.errors.MLRunNotFoundError(
+                            "Could not find model endpoint with name "
+                            f"'{endpoint_uids_to_names[cast(str, endpoint.metadata.uid)]}' "
+                            f"and uid '{endpoint.metadata.uid}'"
+                        )
+                missing = set(endpoint_uids_to_names.keys()) - {
+                    cast(str, endpoint.metadata.uid) for endpoint in endpoints_list
+                }
+                if missing:
+                    raise mlrun.errors.MLRunNotFoundError(
+                        "Could not find model endpoints with the following uids: "
+                        f"{missing}"
                     )
-            else:
-                raise mlrun.errors.MLRunValueError(
-                    f"Could not resolve endpoints as list of [(name, uid)], {endpoints=}"
-                )
 
-        if endpoints == "all":
-            endpoint_names = None
-        else:
-            endpoint_names = endpoints
-
-        endpoints_list = project.list_model_endpoints(
-            names=endpoint_names, latest_only=True
-        ).endpoints
+            elif all(isinstance(endpoint, str) for endpoint in endpoints):
+                # A list of [name, ...] strings
+                endpoint_names = cast(list[str], endpoints)
+                endpoints_list = project.list_model_endpoints(
+                    names=endpoint_names, latest_only=True
+                ).endpoints
 
-        cls._check_endpoints_first_request(endpoints_list)
-
-        if endpoints_list:
-            list_endpoints_result = [
-                (endpoint.metadata.name, endpoint.metadata.uid)
-                for endpoint in endpoints_list
-            ]
-            if endpoints != "all":
+                # Check for missing endpoint names
                 missing = set(endpoints) - {
-                    endpoint[0] for endpoint in list_endpoints_result
+                    endpoint.metadata.name for endpoint in endpoints_list
                 }
                 if missing:
                     logger.warning(
                         "Could not list all the required endpoints",
-                        missing_endpoint=missing,
-                        endpoints=list_endpoints_result,
+                        missing_endpoints=missing,
+                        endpoints_list=endpoints_list,
                     )
-            return list_endpoints_result
+            else:
+                raise mlrun.errors.MLRunValueError(
+                    "Could not resolve the following list as a list of endpoints:\n"
+                    f"{endpoints}\n"
+                    "The list must be either a list of (name, uid) tuples/lists or a list of names."
+                )
+        elif endpoints == "all":
+            endpoints_list = project.list_model_endpoints(latest_only=True).endpoints
+        elif isinstance(endpoints, str):
+            raise mlrun.errors.MLRunValueError(
+                'A string input for `endpoints` can only be "all" for all the model endpoints in '
+                "the project. If you want to select a single model endpoint with the given name, "
+                f'use a list: `endpoints=["{endpoints}"]`.'
+            )
         else:
-            if endpoints != "all":
-                err_msg_suffix = f" named '{endpoints}'"
+            raise mlrun.errors.MLRunValueError(
+                "Could not resolve the `endpoints` parameter. The parameter must be either:\n"
+                "- a list of (name, uid) tuples/lists\n"
+                "- a list of names\n"
+                '- the string "all" for all the model endpoints in the project.'
+            )
+
+        if not endpoints_list:
             raise mlrun.errors.MLRunNotFoundError(
-                f"Did not find any model endpoints {err_msg_suffix}"
+                f"Did not find any model endpoints {endpoints=}"
             )
 
+        cls._check_endpoints_first_request(endpoints_list)
+
+        return [
+            (endpoint.metadata.name, cast(str, endpoint.metadata.uid))
+            for endpoint in endpoints_list
+        ]
+
     @staticmethod
     def _validate_and_get_window_length(
         *, base_period: int, start_dt: datetime, end_dt: datetime

{mlrun-1.10.0rc35 → mlrun-1.10.0rc37}/mlrun/projects/project.py

@@ -2386,8 +2386,9 @@ class MlrunProject(ModelObj):
         handler: Optional[str] = None,
         with_repo: Optional[bool] = None,
         tag: Optional[str] = None,
-        requirements: Optional[typing.Union[str, list[str]]] = None,
+        requirements: Optional[list[str]] = None,
         requirements_file: str = "",
+        local_path: Optional[str] = None,
         **application_kwargs,
     ) -> mlrun.runtimes.RemoteRuntime:
         """
@@ -2402,7 +2403,8 @@ class MlrunProject(ModelObj):
             )
 
         :param func:                    Remote function object or spec/code URL. :code:`None` refers to the current
-                                        notebook.
+                                        notebook. May also be a hub URL of a module of kind model-monitoring-app in the
+                                        format: hub://[{source}/]{name}[:{tag}].
         :param name:                    Name of the function (under the project), can be specified with a tag to support
                                         versions (e.g. myfunc:v1).
         :param image:                   Docker image to be used, can also be specified in
@@ -2417,6 +2419,8 @@ class MlrunProject(ModelObj):
         :param application_class:       Name or an Instance of a class that implements the monitoring application.
         :param application_kwargs:      Additional keyword arguments to be passed to the
                                         monitoring application's constructor.
+        :param local_path:              Path to a local directory to save the downloaded monitoring-app code files in,
+                                        in case 'func' is a hub URL (defaults to current working directory).
         :returns:                       The model monitoring remote function object.
         """
         (
@@ -2433,6 +2437,7 @@ class MlrunProject(ModelObj):
             tag,
             requirements,
             requirements_file,
+            local_path,
             **application_kwargs,
         )
         # save to project spec
@@ -2511,8 +2516,9 @@ class MlrunProject(ModelObj):
         handler: typing.Optional[str] = None,
         with_repo: typing.Optional[bool] = None,
         tag: typing.Optional[str] = None,
-        requirements: typing.Union[str, list[str], None] = None,
+        requirements: typing.Union[list[str], None] = None,
         requirements_file: str = "",
+        local_path: typing.Optional[str] = None,
         **application_kwargs,
     ) -> tuple[str, mlrun.runtimes.RemoteRuntime, dict]:
         import mlrun.model_monitoring.api
@@ -2529,6 +2535,7 @@ class MlrunProject(ModelObj):
                 tag=tag,
                 requirements=requirements,
                 requirements_file=requirements_file,
+                local_path=local_path,
                 **application_kwargs,
             )
         elif isinstance(func, str) and isinstance(handler, str):

{mlrun-1.10.0rc35 → mlrun-1.10.0rc37}/mlrun/run.py

@@ -609,7 +609,7 @@ def code_to_function(
     code_output: Optional[str] = "",
     embed_code: bool = True,
     description: Optional[str] = "",
-    requirements: Optional[Union[str, list[str]]] = None,
+    requirements: Optional[list[str]] = None,
     categories: Optional[list[str]] = None,
     labels: Optional[dict[str, str]] = None,
     with_doc: Optional[bool] = True,

{mlrun-1.10.0rc35 → mlrun-1.10.0rc37}/mlrun/runtimes/nuclio/application/application.py

@@ -413,8 +413,7 @@ class ApplicationRuntime(RemoteRuntime):
                 show_on_failure=show_on_failure,
             )
 
-        # This is a class method that accepts a function instance, so we pass self as the function instance
-        self._ensure_reverse_proxy_configurations(self)
+        self._ensure_reverse_proxy_configurations()
         self._configure_application_sidecar()
 
         # We only allow accessing the application via the API Gateway
@@ -799,27 +798,42 @@ class ApplicationRuntime(RemoteRuntime):
             with_mlrun=with_mlrun,
         )
 
-    @staticmethod
-    def _ensure_reverse_proxy_configurations(function: RemoteRuntime):
-        if function.spec.build.functionSourceCode or function.status.container_image:
+    def _ensure_reverse_proxy_configurations(self):
+        # If an HTTP trigger already exists in the spec,
+        # it means the user explicitly defined a custom configuration,
+        # so, skip automatic creation.
+        skip_http_trigger_creation = False
+        for key, value in self.spec.config.items():
+            if key.startswith("spec.triggers"):
+                if isinstance(value, dict):
+                    if value.get("kind") == "http":
+                        skip_http_trigger_creation = True
+                        break
+        if not skip_http_trigger_creation:
+            self.with_http(
+                workers=mlrun.mlconf.function.application.default_worker_number,
+                trigger_name="application-http",
+            )
+
+        if self.spec.build.functionSourceCode or self.status.container_image:
             return
 
         filename, handler = ApplicationRuntime.get_filename_and_handler()
         name, spec, code = nuclio.build_file(
             filename,
-            name=function.metadata.name,
+            name=self.metadata.name,
             handler=handler,
         )
-        function.spec.function_handler = mlrun.utils.get_in(spec, "spec.handler")
-        function.spec.build.functionSourceCode = mlrun.utils.get_in(
+        self.spec.function_handler = mlrun.utils.get_in(spec, "spec.handler")
+        self.spec.build.functionSourceCode = mlrun.utils.get_in(
             spec, "spec.build.functionSourceCode"
         )
-        function.spec.nuclio_runtime = mlrun.utils.get_in(spec, "spec.runtime")
+        self.spec.nuclio_runtime = mlrun.utils.get_in(spec, "spec.runtime")
 
         # default the reverse proxy logger level to info
         logger_sinks_key = "spec.loggerSinks"
-        if not function.spec.config.get(logger_sinks_key):
-            function.set_config(
+        if not self.spec.config.get(logger_sinks_key):
+            self.set_config(
                 logger_sinks_key, [{"level": "info", "sink": "myStdoutLoggerSink"}]
             )
 

{mlrun-1.10.0rc35 → mlrun-1.10.0rc37}/mlrun/runtimes/nuclio/function.py

@@ -1224,11 +1224,6 @@ class RemoteRuntime(KubeResource):
         # try to infer the invocation url from the internal and if not exists, use external.
         # $$$$ we do not want to use the external invocation url (e.g.: ingress, nodePort, etc.)
 
-        # check function state before invocation
-        state, _, _ = self._get_state()
-        if state not in ["ready", "scaledToZero"]:
-            logger.warning(f"Function is in the {state} state")
-
         # prefer internal invocation url if running inside k8s cluster
         if (
             not force_external_address

{mlrun-1.10.0rc35 → mlrun-1.10.0rc37}/mlrun/runtimes/nuclio/serving.py

@@ -679,9 +679,13 @@ class ServingRuntime(RemoteRuntime):
                         f"function {function} is used in steps and is not defined, "
                         "use the .add_child_function() to specify child function attributes"
                     )
-        if isinstance(self.spec.graph, RootFlowStep) and any(
-            isinstance(step_type, mlrun.serving.states.ModelRunnerStep)
-            for step_type in self.spec.graph.steps.values()
+        if (
+            isinstance(self.spec.graph, RootFlowStep)
+            and any(
+                isinstance(step_type, mlrun.serving.states.ModelRunnerStep)
+                for step_type in self.spec.graph.steps.values()
+            )
+            and self.spec.build.functionSourceCode
         ):
             # Add import for LLModel
             decoded_code = b64decode(self.spec.build.functionSourceCode).decode("utf-8")

{mlrun-1.10.0rc35 → mlrun-1.10.0rc37}/mlrun/secrets.py

@@ -11,9 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
+import json
 from ast import literal_eval
-from os import environ, getenv
+from os import environ
 from typing import Callable, Optional, Union
 
 from .utils import AzureVaultStore, list2dict
@@ -161,6 +161,9 @@ def get_secret_or_env(
     4. An MLRun-generated env. variable, mounted from a project secret (to be used in MLRun runtimes)
     5. The default value
 
+    Also supports discovering the value inside any environment variable that contains a JSON-encoded list
+    of dicts with fields: {'name': 'KEY', 'value': 'VAL', 'value_from': ...}. This fallback is applied
+    after checking normal environment variables and before returning the default.
     Example::
 
         secrets = {"KEY1": "VALUE1"}
@@ -187,18 +190,56 @@ def get_secret_or_env(
     if prefix:
         key = f"{prefix}_{key}"
 
-    value = None
     if secret_provider:
         if isinstance(secret_provider, (dict, SecretsStore)):
-            value = secret_provider.get(key)
+            secret_value = secret_provider.get(key)
         else:
-            value = secret_provider(key)
-        if value:
-            return value
+            secret_value = secret_provider(key)
+        if secret_value:
+            return secret_value
+
+    direct_environment_value = environ.get(key)
+    if direct_environment_value:
+        return direct_environment_value
+
+    json_list_value = _find_value_in_json_env_lists(key)
+    if json_list_value is not None:
+        return json_list_value
+
+    mlrun_env_key = SecretsStore.k8s_env_variable_name_for_secret(key)
+    mlrun_env_value = environ.get(mlrun_env_key)
+    if mlrun_env_value:
+        return mlrun_env_value
 
-    return (
-        value
-        or getenv(key)
-        or getenv(SecretsStore.k8s_env_variable_name_for_secret(key))
-        or default
-    )
+    return default
+
+
+def _find_value_in_json_env_lists(
+    secret_name: str,
+) -> Optional[str]:
+    """
+    Scan all environment variables. If any env var contains a JSON-encoded list
+    of dicts shaped like {'name': str, 'value': str|None, 'value_from': ...},
+    return the 'value' for the entry whose 'name' matches secret_name.
+    """
+    for environment_variable_value in environ.values():
+        if not environment_variable_value or not isinstance(
+            environment_variable_value, str
+        ):
+            continue
+        # Fast precheck to skip obvious non-JSON strings
+        first_char = environment_variable_value.lstrip()[:1]
+        if first_char not in ("[", "{"):
+            continue
+        try:
+            parsed_value = json.loads(environment_variable_value)
+        except ValueError:
+            continue
+        if isinstance(parsed_value, list):
+            for entry in parsed_value:
+                if isinstance(entry, dict) and entry.get("name") == secret_name:
+                    value_in_entry = entry.get("value")
+                    # Match original semantics: empty string is treated as "not found"
+                    if value_in_entry:
+                        return value_in_entry
+    return None

{mlrun-1.10.0rc35 → mlrun-1.10.0rc37}/mlrun/serving/server.py

@@ -584,6 +584,16 @@ async def async_execute_graph(
     read_as_lists: bool,
     nest_under_inputs: bool,
 ) -> list[Any]:
+    # Validate that data parameter is a DataItem and not passed via params
+    if not isinstance(data, DataItem):
+        raise MLRunInvalidArgumentError(
+            f"Parameter 'data' has type hint 'DataItem' but got {type(data).__name__} instead. "
+            f"Data files and artifacts must be passed via the 'inputs' parameter, not 'params'. "
+            f"The 'params' parameter is for simple configuration values (strings, numbers, booleans), "
+            f"while 'inputs' is for data files that need to be loaded. "
+            f"Example: run_function(..., inputs={{'data': 'path/to/data.csv'}}, params={{other_config: value}})"
+        )
+
     spec = mlrun.utils.get_serving_spec()
     modname = None
     code = os.getenv("MLRUN_EXEC_CODE")