mlrun 1.9.0rc3__py3-none-any.whl → 1.10.0rc1__py3-none-any.whl

mlrun/projects/operations.py

@@ -11,7 +11,7 @@
 # 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 typing
 import warnings
 from typing import Optional, Union
@@ -81,6 +81,7 @@ def run_function(
     returns: Optional[list[Union[str, dict[str, str]]]] = None,
     builder_env: Optional[list] = None,
     reset_on_run: Optional[bool] = None,
+    output_path: Optional[str] = None,
 ) -> Union[mlrun.model.RunObject, mlrun_pipelines.models.PipelineNodeWrapper]:
     """Run a local or remote task as part of a local/kubeflow pipeline
 
@@ -144,7 +145,7 @@ def run_function(
                             during runtime from `mlrun.DataItem` to the given type hint. The type hint can be given
                             in the key field of the dictionary after a colon, e.g: "<key> : <type_hint>".
     :param outputs:         list of outputs which can pass in the workflow
-    :param workdir:         default input artifacts path
+    :param workdir:         working directory of the executed job and the default path for artifact inputs
     :param labels:          labels to tag the job/run with ({key:val, ..})
     :param base_task:       task object to use as base
     :param watch:           watch/follow run log, True by default
@@ -157,7 +158,8 @@ def run_function(
                             (which will be converted to the class using its `from_crontab` constructor),
                             see this link for help:
                             https://apscheduler.readthedocs.io/en/3.x/modules/triggers/cron.html#module-apscheduler.triggers.cron
-    :param artifact_path:   path to store artifacts, when running in a workflow this will be set automatically
+    :param artifact_path:   (deprecated) path to store artifacts, when running in a workflow this will be set
+                            automatically
     :param notifications:   list of notifications to push when the run is completed
     :param returns:         List of log hints - configurations for how to log the returning values from the handler's
                             run (as artifacts or results). The list's length must be equal to the amount of returning
@@ -174,8 +176,17 @@ def run_function(
     :param reset_on_run:    When True, function python modules would reload prior to code execution.
                             This ensures latest code changes are executed. This argument must be used in
                             conjunction with the local=True argument.
+    :param output_path:     path to store artifacts, when running in a workflow this will be set automatically
     :return: MLRun RunObject or PipelineNodeWrapper
     """
+    if artifact_path:
+        warnings.warn(
+            "'artifact_path' parameter is deprecated in 1.10.0 and will be removed in 1.12.0, "
+            "use 'output_path' instead.",
+            # TODO: Remove this in 1.12.0
+            FutureWarning,
+        )
+    output_path = output_path or artifact_path
     engine, function = _get_engine_and_function(function, project_object)
     task = mlrun.new_task(
         handler=handler,
@@ -210,24 +221,28 @@ def run_function(
             function.spec.command = command
         if local and project and function.spec.build.source:
             workdir = workdir or project.spec.get_code_path()
-        run_result = function.run(
-            name=name,
-            runspec=task,
-            workdir=workdir,
-            verbose=verbose,
-            watch=watch,
-            local=local,
-            artifact_path=artifact_path
-            # workflow artifact_path has precedence over the project artifact_path equivalent to
-            # passing artifact_path to function.run() has precedence over the project.artifact_path and the default one
-            or pipeline_context.workflow_artifact_path
-            or (project.artifact_path if project else None),
-            auto_build=auto_build,
-            schedule=schedule,
-            notifications=notifications,
-            builder_env=builder_env,
-            reset_on_run=reset_on_run,
-        )
+
+        # remove this filter once the artifact_path parameter is deprecated in 1.12.0
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", category=FutureWarning)
+            run_result = function.run(
+                name=name,
+                runspec=task,
+                workdir=workdir,
+                verbose=verbose,
+                watch=watch,
+                local=local,
+                output_path=output_path
+                # workflow output_path has precedence over the project artifact_path equivalent to passing
+                # output_path to function.run() has precedence over the project.artifact_path and the default one
+                or pipeline_context.workflow_artifact_path
+                or (project.artifact_path if project else None),
+                auto_build=auto_build,
+                schedule=schedule,
+                notifications=notifications,
+                builder_env=builder_env,
+                reset_on_run=reset_on_run,
+            )
         if run_result:
             run_result._notified = False
             pipeline_context.runs_map[run_result.uid()] = run_result

mlrun/projects/project.py

@@ -30,7 +30,6 @@ from copy import deepcopy
 from os import environ, makedirs, path
 from typing import Callable, Optional, Union, cast
 
-import deprecated
 import dotenv
 import git
 import git.exc
@@ -470,7 +469,8 @@ def get_or_create_project(
     parameters: Optional[dict] = None,
     allow_cross_project: Optional[bool] = None,
 ) -> "MlrunProject":
-    """Load a project from MLRun DB, or create/import if it does not exist
+    """Load a project from MLRun DB, or create/import if it does not exist.
+    The project will become the default project for the current session.
 
     MLRun looks for a project.yaml file with project definition and objects in the project root path
     and use it to initialize the project, in addition it runs the project_setup.py file (if it exists)
@@ -2143,35 +2143,35 @@ class MlrunProject(ModelObj):
         ),
         reset_policy: mlrun.common.schemas.alert.ResetPolicy = mlrun.common.schemas.alert.ResetPolicy.AUTO,
     ) -> list[mlrun.alerts.alert.AlertConfig]:
-        """
-        Generate alert configurations based on specified model endpoints and result names, which can be defined
+        """Generate alert configurations based on specified model endpoints and result names, which can be defined
         explicitly or using regex patterns.
 
-                :param name:                   The name of the AlertConfig template. It will be combined with
-                                               mep id, app name and result name to generate a unique name.
-                :param summary:                Summary of the alert, will be sent in the generated notifications
-                :param endpoints:              The endpoints from which metrics will be retrieved to configure
-                                               the alerts.
-                                               The ModelEndpointList object is obtained via the `list_model_endpoints`
-                                               method or created manually using `ModelEndpoint` objects.
-                :param events:                 AlertTrigger event types (EventKind).
-                :param notifications:          List of notifications to invoke once the alert is triggered
-                :param result_names:           Optional. Filters the result names used to create the alert
-                                               configuration, constructed from the app and result_name regex.
-
-                                               For example:
-                                               [`app1.result-*`, `*.result1`]
-                                               will match "mep_uid1.app1.result.result-1" and
-                                               "mep_uid1.app2.result.result1".
-                                               A specific result_name (not a wildcard) will always create a new alert
-                                               config, regardless of whether the result name exists.
-                :param severity:               Severity of the alert.
-                :param criteria:               The threshold for triggering the alert based on the
-                                               specified number of events within the defined time period.
-                :param reset_policy:           When to clear the alert. Either "manual" for manual reset of the alert,
-                                               or "auto" if the criteria contains a time period.
-                :returns:                      List of AlertConfig according to endpoints results,
-                                               filtered by result_names.
+        :param name:                   The name of the AlertConfig template. It will be combined with
+                                       mep id, app name and result name to generate a unique name.
+        :param summary:                Summary of the alert, will be sent in the generated notifications
+        :param endpoints:              The endpoints from which metrics will be retrieved to configure
+                                       the alerts.
+                                       The ModelEndpointList object is obtained via the `list_model_endpoints`
+                                       method or created manually using `ModelEndpoint` objects.
+        :param events:                 AlertTrigger event types (EventKind).
+        :param notifications:          List of notifications to invoke once the alert is triggered
+        :param result_names:           Optional. Filters the result names used to create the alert
+                                       configuration, constructed from the app and result_name regex.
+
+                                       For example:
+                                       [`app1.result-*`, `*.result1`]
+                                       will match "mep_uid1.app1.result.result-1" and
+                                       "mep_uid1.app2.result.result1".
+                                       A specific result_name (not a wildcard) will always create a new alert
+                                       config, regardless of whether the result name exists.
+        :param severity:               Severity of the alert.
+        :param criteria:               The threshold for triggering the alert based on the
+                                       specified number of events within the defined time period.
+        :param reset_policy:           When to clear the alert. Either "manual" for manual reset of the alert,
+                                       or "auto" if the criteria contains a time period.
+
+        :returns:                      List of AlertConfig according to endpoints results,
+                                       filtered by result_names.
         """
         db = mlrun.db.get_run_db(secrets=self._secrets)
         matching_results = []
@@ -2860,20 +2860,6 @@ class MlrunProject(ModelObj):
 
         self.spec.set_function(name, function_object, func)
 
-    # TODO: Remove this in 1.10.0
-    @deprecated.deprecated(
-        version="1.8.0",
-        reason="'remove_function' is deprecated and will be removed in 1.10.0. "
-        "Please use `delete_function` instead.",
-        category=FutureWarning,
-    )
-    def remove_function(self, name):
-        """remove the specified function from the project
-
-        :param name:    name of the function (under the project)
-        """
-        self.spec.remove_function(name)
-
     def delete_function(self, name, delete_from_db=False):
         """deletes the specified function from the project
 
@@ -3796,6 +3782,7 @@ class MlrunProject(ModelObj):
         uids: Optional[list[str]] = None,
         latest_only: bool = False,
         tsdb_metrics: bool = True,
+        metric_list: Optional[list[str]] = None,
     ) -> mlrun.common.schemas.ModelEndpointList:
         """
         Returns a list of `ModelEndpoint` objects. Each `ModelEndpoint` object represents the current state of a
@@ -3825,10 +3812,15 @@ class MlrunProject(ModelObj):
             or just `"label"` for key existence.
             - A comma-separated string formatted as `"label1=value1,label2"` to match entities with
             the specified key-value pairs or key existence.
-        :param start:                     The start time to filter by.Corresponding to the `created` field.
-        :param end:                       The end time to filter by. Corresponding to the `created` field.
-        :param top_level: if true will return only routers and endpoint that are NOT children of any router
-        :param uids: if passed will return a list `ModelEndpoint` object with uid in uids
+        :param start:           The start time to filter by.Corresponding to the `created` field.
+        :param end:             The end time to filter by. Corresponding to the `created` field.
+        :param top_level:       If true will return only routers and endpoint that are NOT children of any router.
+        :param uids:            If passed will return a list `ModelEndpoint` object with uid in uids.
+        :param tsdb_metrics:    When True, the time series metrics will be added to the output
+                                of the resulting.
+        :param metric_list:     List of metrics to include from the time series DB. Defaults to all metrics.
+                                If tsdb_metrics=False, this parameter will be ignored and no tsdb metrics
+                                will be included.
 
         :returns: Returns a list of `ModelEndpoint` objects.
         """
@@ -3847,6 +3839,7 @@ class MlrunProject(ModelObj):
             uids=uids,
             latest_only=latest_only,
             tsdb_metrics=tsdb_metrics,
+            metric_list=metric_list,
         )
 
     def run_function(
@@ -3873,6 +3866,7 @@ class MlrunProject(ModelObj):
         returns: Optional[list[Union[str, dict[str, str]]]] = None,
         builder_env: Optional[dict] = None,
         reset_on_run: Optional[bool] = None,
+        output_path: Optional[str] = None,
     ) -> typing.Union[mlrun.model.RunObject, PipelineNodeWrapper]:
         """Run a local or remote task as part of a local/kubeflow pipeline
 
@@ -3903,7 +3897,7 @@ class MlrunProject(ModelObj):
                                 parsed during runtime from `mlrun.DataItem` to the given type hint. The type hint can be
                                 given in the key field of the dictionary after a colon, e.g: "<key> : <type_hint>".
         :param outputs:         list of outputs which can pass in the workflow
-        :param workdir:         default input artifacts path
+        :param workdir:         working directory of the executed job and the default path for artifact inputs
         :param labels:          labels to tag the job/run with ({key:val, ..})
         :param base_task:       task object to use as base
         :param watch:           watch/follow run log, True by default
@@ -3915,7 +3909,8 @@ class MlrunProject(ModelObj):
                                 (which will be converted to the class using its `from_crontab` constructor),
                                 see this link for help:
                                 https://apscheduler.readthedocs.io/en/3.x/modules/triggers/cron.html#module-apscheduler.triggers.cron
-        :param artifact_path:   path to store artifacts, when running in a workflow this will be set automatically
+        :param artifact_path:   (deprecated) path to store artifacts, when running in a workflow this will be set
+                                automatically
         :param notifications:   list of notifications to push when the run is completed
         :param returns:         List of log hints - configurations for how to log the returning values from the
                                 handler's run (as artifacts or results). The list's length must be equal to the amount
@@ -3933,34 +3928,47 @@ class MlrunProject(ModelObj):
         :param reset_on_run:    When True, function python modules would reload prior to code execution.
                                 This ensures latest code changes are executed. This argument must be used in
                                 conjunction with the local=True argument.
+        :param output_path:     path to store artifacts, when running in a workflow this will be set automatically
 
         :return: MLRun RunObject or PipelineNodeWrapper
         """
-        return run_function(
-            function,
-            handler=handler,
-            name=name,
-            params=params,
-            hyperparams=hyperparams,
-            hyper_param_options=hyper_param_options,
-            inputs=inputs,
-            outputs=outputs,
-            workdir=workdir,
-            labels=labels,
-            base_task=base_task,
-            watch=watch,
-            local=local,
-            verbose=verbose,
-            selector=selector,
-            project_object=self,
-            auto_build=auto_build,
-            schedule=schedule,
-            artifact_path=artifact_path,
-            notifications=notifications,
-            returns=returns,
-            builder_env=builder_env,
-            reset_on_run=reset_on_run,
-        )
+        if artifact_path:
+            warnings.warn(
+                "'artifact_path' parameter is deprecated in 1.10.0 and will be removed in 1.12.0, "
+                "use 'output_path' instead.",
+                # TODO: Remove this in 1.12.0
+                FutureWarning,
+            )
+        output_path = output_path or artifact_path
+
+        # remove this filter once the artifact_path parameter is deprecated in 1.12.0
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", category=FutureWarning)
+            return run_function(
+                function,
+                handler=handler,
+                name=name,
+                params=params,
+                hyperparams=hyperparams,
+                hyper_param_options=hyper_param_options,
+                inputs=inputs,
+                outputs=outputs,
+                workdir=workdir,
+                labels=labels,
+                base_task=base_task,
+                watch=watch,
+                local=local,
+                verbose=verbose,
+                selector=selector,
+                project_object=self,
+                auto_build=auto_build,
+                schedule=schedule,
+                output_path=output_path,
+                notifications=notifications,
+                returns=returns,
+                builder_env=builder_env,
+                reset_on_run=reset_on_run,
+            )
 
     def build_function(
         self,

mlrun/run.py

@@ -637,7 +637,7 @@ def code_to_function(
     - databricks: run code on Databricks cluster (python scripts, Spark etc.)
     - application: run a long living application (e.g. a web server, UI, etc.)
 
-    Learn more about [Kinds of function (runtimes)](../concepts/functions-overview.html).
+    Learn more about :doc:`../../concepts/functions-overview`
 
     :param name:         function name, typically best to use hyphen-case
     :param project:      project used to namespace the function, defaults to 'default'

mlrun/runtimes/base.py

@@ -345,6 +345,7 @@ class BaseRuntime(ModelObj):
         returns: Optional[list[Union[str, dict[str, str]]]] = None,
         state_thresholds: Optional[dict[str, int]] = None,
         reset_on_run: Optional[bool] = None,
+        output_path: Optional[str] = "",
         **launcher_kwargs,
     ) -> RunObject:
         """
@@ -358,9 +359,9 @@ class BaseRuntime(ModelObj):
         :param inputs:         Input objects to pass to the handler. Type hints can be given so the input will be parsed
                                during runtime from `mlrun.DataItem` to the given type hint. The type hint can be given
                                in the key field of the dictionary after a colon, e.g: "<key> : <type_hint>".
-        :param out_path:       Default artifact output path.
-        :param artifact_path:  Default artifact output path (will replace out_path).
-        :param workdir:        Default input artifacts path.
+        :param out_path:       (deprecated) Default artifact output path.
+        :param artifact_path:  (deprecated) Default artifact output path (will replace out_path).
+        :param workdir:        Working directory of the executed job and the default path for artifact inputs
         :param watch:          Watch/follow run log.
         :param schedule:       ScheduleCronTrigger class instance or a standard crontab expression string
                                (which will be converted to the class using its `from_crontab` constructor),
@@ -402,8 +403,18 @@ class BaseRuntime(ModelObj):
         :param reset_on_run: When True, function python modules would reload prior to code execution.
                              This ensures latest code changes are executed. This argument must be used in
                              conjunction with the local=True argument.
+        :param output_path:    Default artifact output path.
         :return: Run context object (RunObject) with run metadata, results and status
         """
+        if artifact_path or out_path:
+            deprecated_param = "artifact_path" if artifact_path else "out_path"
+            warnings.warn(
+                f"'{deprecated_param}' parameter is deprecated in 1.10.0 and will be removed in 1.12.0, "
+                "use 'output_path' instead.",
+                # TODO: Remove this in 1.12.0
+                FutureWarning,
+            )
+        output_path = output_path or out_path or artifact_path
         launcher = mlrun.launcher.factory.LauncherFactory().create_launcher(
             self._is_remote, local=local, **launcher_kwargs
         )
@@ -415,9 +426,8 @@ class BaseRuntime(ModelObj):
             project=project,
             params=params,
             inputs=inputs,
-            out_path=out_path,
             workdir=workdir,
-            artifact_path=artifact_path,
+            output_path=output_path,
             watch=watch,
             schedule=schedule,
             hyperparams=hyperparams,
@@ -711,7 +721,7 @@ class BaseRuntime(ModelObj):
                                 given in the key field of the dictionary after a colon, e.g: "<key> : <type_hint>".
         :param outputs:         list of outputs which can pass in the workflow
         :param artifact_path:   default artifact output path (replace out_path)
-        :param workdir:         default input artifacts path
+        :param workdir:         working directory of the executed job and the default path for artifact inputs
         :param image:           container image to use
         :param labels:          labels to tag the job/run with ({key:val, ..})
         :param use_db:          save function spec in the db (vs the workflow file)

mlrun/runtimes/daskjob.py

@@ -495,6 +495,7 @@ class DaskCluster(KubejobRuntime):
         returns: Optional[list[Union[str, dict[str, str]]]] = None,
         state_thresholds: Optional[dict[str, int]] = None,
         reset_on_run: Optional[bool] = None,
+        output_path: Optional[str] = "",
         **launcher_kwargs,
     ) -> RunObject:
         if state_thresholds:
@@ -510,7 +511,7 @@ class DaskCluster(KubejobRuntime):
             inputs=inputs,
             out_path=out_path,
             workdir=workdir,
-            artifact_path=artifact_path,
+            output_path=output_path,
             watch=watch,
             schedule=schedule,
             hyperparams=hyperparams,

mlrun/runtimes/databricks_job/databricks_cancel_task.py

@@ -11,7 +11,6 @@
 # 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 os
 from time import sleep

mlrun/runtimes/databricks_job/databricks_runtime.py

@@ -234,6 +234,7 @@ def run_mlrun_databricks_job(context,task_parameters: dict, **kwargs):
         returns: Optional[list[Union[str, dict[str, str]]]] = None,
         state_thresholds: Optional[dict[str, int]] = None,
         reset_on_run: Optional[bool] = None,
+        output_path: Optional[str] = "",
         **launcher_kwargs,
     ) -> RunObject:
         if local:
@@ -247,7 +248,7 @@ def run_mlrun_databricks_job(context,task_parameters: dict, **kwargs):
             inputs=inputs,
             out_path=out_path,
             workdir=workdir,
-            artifact_path=artifact_path,
+            output_path=output_path,
             watch=watch,
             schedule=schedule,
             hyperparams=hyperparams,

mlrun/runtimes/databricks_job/databricks_wrapper.py

@@ -11,7 +11,6 @@
 # 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 datetime
 import json

mlrun/runtimes/mounts.py

@@ -352,10 +352,12 @@ def auto_mount(
     """Choose the mount based on env variables and params
 
     Volume will be selected by the following order:
+
     - k8s PVC volume when both pvc_name and volume_mount_path are set
     - k8s PVC volume when env var is set: MLRUN_PVC_MOUNT=<pvc-name>:<mount-path>
     - k8s PVC volume if it's configured as the auto mount type
     - iguazio v3io volume when V3IO_ACCESS_KEY and V3IO_USERNAME env vars are set
+
     """
     if pvc_name and volume_mount_path:
         return mount_pvc(

mlrun/runtimes/nuclio/function.py

@@ -651,6 +651,11 @@ class RemoteRuntime(KubeResource):
         logger.info("Starting remote function deploy")
         data = db.deploy_nuclio_function(func=self, builder_env=builder_env)
         self.status = data["data"].get("status")
+
+        # Extract the spec to avoid overwriting server-side updates during the later save in
+        # _enrich_command_from_status.
+        self.spec = data["data"].get("spec")
+
         self._update_credentials_from_remote_build(data["data"])
 
         # when a function is deployed, we wait for it to be ready by default
@@ -1000,7 +1005,7 @@ class RemoteRuntime(KubeResource):
             else:
                 http_client_kwargs["json"] = body
         try:
-            logger.info("Invoking function", method=method, path=path)
+            logger.debug("Invoking function", method=method, path=path)
             if not getattr(self, "_http_session", None):
                 self._http_session = requests.Session()
             resp = self._http_session.request(

mlrun/runtimes/nuclio/serving.py

@@ -800,7 +800,7 @@ class ServingRuntime(RemoteRuntime):
             serving_fn.add_model(
                 "my-classifier",
                 model_path=model_path,
-                class_name="mlrun.frameworks.sklearn.SklearnModelServer",
+                class_name="mlrun.frameworks.sklearn.SKLearnModelServer",
             )
             serving_fn.plot(rankdir="LR")