mlrun 1.10.0rc4__py3-none-any.whl → 1.10.0rc6__py3-none-any.whl

mlrun/model_monitoring/db/tsdb/tdengine/tdengine_connector.py

@@ -12,8 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import threading
 from datetime import datetime, timedelta
-from threading import Lock
 from typing import Callable, Final, Literal, Optional, Union
 
 import pandas as pd
@@ -32,8 +32,8 @@ from mlrun.model_monitoring.db.tsdb.tdengine.tdengine_connection import (
 from mlrun.model_monitoring.helpers import get_invocations_fqn
 from mlrun.utils import logger
 
-_connection = None
-_connection_lock = Lock()
+# Thread-local storage for connections
+_thread_local = threading.local()
 
 
 class TDEngineTimestampPrecision(mlrun.common.types.StrEnum):
@@ -76,16 +76,15 @@ class TDEngineConnector(TSDBConnector):
 
     @property
     def connection(self) -> TDEngineConnection:
-        global _connection
-
-        if _connection:
-            return _connection
-
-        with _connection_lock:
-            if not _connection:
-                _connection = self._create_connection()
-
-        return _connection
+        if not hasattr(_thread_local, "connection"):
+            _thread_local.connection = self._create_connection()
+            logger.debug(
+                "Created new TDEngine connection for thread",
+                project=self.project,
+                thread_name=threading.current_thread().name,
+                thread_id=threading.get_ident(),
+            )
+        return _thread_local.connection
 
     def _create_connection(self) -> TDEngineConnection:
         """Establish a connection to the TSDB server."""
@@ -204,14 +203,27 @@ class TDEngineConnector(TSDBConnector):
         return datetime.fromisoformat(val) if isinstance(val, str) else val
 
     @staticmethod
-    def _get_endpoint_filter(endpoint_id: Union[str, list[str]]) -> str:
-        if isinstance(endpoint_id, str):
-            return f"endpoint_id='{endpoint_id}'"
-        elif isinstance(endpoint_id, list):
-            return f"endpoint_id IN({str(endpoint_id)[1:-1]}) "
+    def _generate_filter_query(
+        filter_column: str, filter_values: Union[str, list[Union[str, int]]]
+    ) -> Optional[str]:
+        """
+        Generate a filter query for TDEngine based on the provided column and values.
+
+        :param filter_column: The column to filter by.
+        :param filter_values: A single value or a list of values to filter by.
+
+        :return: A string representing the filter query.
+        :raise: MLRunInvalidArgumentError if the filter values are not of type string or list.
+        """
+
+        if isinstance(filter_values, str):
+            return f"{filter_column}='{filter_values}'"
+        elif isinstance(filter_values, list):
+            return f"{filter_column} IN ({', '.join(repr(v) for v in filter_values)}) "
         else:
             raise mlrun.errors.MLRunInvalidArgumentError(
-                "Invalid 'endpoint_id' filter: must be a string or a list."
+                f"Invalid filter values {filter_values}: must be a string or a list, "
+                f"got {type(filter_values).__name__}; filter values: {filter_values}"
             )
 
     def _drop_database_query(self) -> str:
@@ -673,7 +685,10 @@ class TDEngineConnector(TSDBConnector):
         start: Optional[datetime] = None,
         end: Optional[datetime] = None,
     ) -> pd.DataFrame:
-        filter_query = self._get_endpoint_filter(endpoint_id=endpoint_ids)
+        filter_query = self._generate_filter_query(
+            filter_column=mm_schemas.EventFieldType.ENDPOINT_ID,
+            filter_values=endpoint_ids,
+        )
         start, end = self._get_start_end(start, end)
         df = self._get_records(
             table=self.tables[mm_schemas.TDEngineSuperTables.PREDICTIONS].super_table,
@@ -714,7 +729,10 @@ class TDEngineConnector(TSDBConnector):
         end: Optional[datetime] = None,
         get_raw: bool = False,
     ) -> pd.DataFrame:
-        filter_query = self._get_endpoint_filter(endpoint_id=endpoint_ids)
+        filter_query = self._generate_filter_query(
+            filter_column=mm_schemas.EventFieldType.ENDPOINT_ID,
+            filter_values=endpoint_ids,
+        )
         start = start or (mlrun.utils.datetime_now() - timedelta(hours=24))
         start, end = self._get_start_end(start, end)
         df = self._get_records(
@@ -741,6 +759,72 @@ class TDEngineConnector(TSDBConnector):
             df.dropna(inplace=True)
         return df
 
+    def count_results_by_status(
+        self,
+        start: Optional[Union[datetime, str]] = None,
+        end: Optional[Union[datetime, str]] = None,
+        endpoint_ids: Optional[Union[str, list[str]]] = None,
+        application_names: Optional[Union[str, list[str]]] = None,
+        result_status_list: Optional[list[int]] = None,
+    ) -> dict[tuple[str, int], int]:
+        filter_query = ""
+        now = mlrun.utils.datetime_now()
+        start = start or (now - timedelta(hours=24))
+        end = end or now
+        if endpoint_ids:
+            filter_query = self._generate_filter_query(
+                filter_column=mm_schemas.EventFieldType.ENDPOINT_ID,
+                filter_values=endpoint_ids,
+            )
+        if application_names:
+            app_filter_query = self._generate_filter_query(
+                filter_column=mm_schemas.ApplicationEvent.APPLICATION_NAME,
+                filter_values=application_names,
+            )
+            if filter_query:
+                filter_query += f" AND {app_filter_query}"
+            else:
+                filter_query = app_filter_query
+        if result_status_list:
+            status_filter_query = self._generate_filter_query(
+                filter_column=mm_schemas.ResultData.RESULT_STATUS,
+                filter_values=result_status_list,
+            )
+            if filter_query:
+                filter_query += f" AND {status_filter_query}"
+            else:
+                filter_query = status_filter_query
+
+        df = self._get_records(
+            table=self.tables[mm_schemas.TDEngineSuperTables.APP_RESULTS].super_table,
+            start=start,
+            end=end,
+            columns=[
+                mm_schemas.WriterEvent.APPLICATION_NAME,
+                mm_schemas.ResultData.RESULT_STATUS,
+                mm_schemas.ResultData.RESULT_VALUE,
+            ],
+            filter_query=filter_query,
+            timestamp_column=mm_schemas.WriterEvent.END_INFER_TIME,
+            group_by=[
+                mm_schemas.WriterEvent.APPLICATION_NAME,
+                mm_schemas.ResultData.RESULT_STATUS,
+            ],
+            agg_funcs=["count"],
+            preform_agg_columns=[mm_schemas.ResultData.RESULT_VALUE],
+        )
+        if df.empty:
+            return {}
+
+        # Convert DataFrame to a dictionary
+        return {
+            (
+                row[mm_schemas.WriterEvent.APPLICATION_NAME],
+                row[mm_schemas.ResultData.RESULT_STATUS],
+            ): row["count(result_value)"]
+            for _, row in df.iterrows()
+        }
+
     def get_metrics_metadata(
         self,
         endpoint_id: Union[str, list[str]],
@@ -757,7 +841,10 @@ class TDEngineConnector(TSDBConnector):
                 mm_schemas.MetricData.METRIC_NAME,
                 mm_schemas.EventFieldType.ENDPOINT_ID,
             ],
-            filter_query=self._get_endpoint_filter(endpoint_id=endpoint_id),
+            filter_query=self._generate_filter_query(
+                filter_column=mm_schemas.EventFieldType.ENDPOINT_ID,
+                filter_values=endpoint_id,
+            ),
             timestamp_column=mm_schemas.WriterEvent.END_INFER_TIME,
             group_by=[
                 mm_schemas.WriterEvent.APPLICATION_NAME,
@@ -795,7 +882,10 @@ class TDEngineConnector(TSDBConnector):
                 mm_schemas.ResultData.RESULT_KIND,
                 mm_schemas.EventFieldType.ENDPOINT_ID,
             ],
-            filter_query=self._get_endpoint_filter(endpoint_id=endpoint_id),
+            filter_query=self._generate_filter_query(
+                filter_column=mm_schemas.EventFieldType.ENDPOINT_ID,
+                filter_values=endpoint_id,
+            ),
             timestamp_column=mm_schemas.WriterEvent.END_INFER_TIME,
             group_by=[
                 mm_schemas.WriterEvent.APPLICATION_NAME,
@@ -824,7 +914,10 @@ class TDEngineConnector(TSDBConnector):
         end: Optional[datetime] = None,
         get_raw: bool = False,
     ) -> pd.DataFrame:
-        filter_query = self._get_endpoint_filter(endpoint_id=endpoint_ids)
+        filter_query = self._generate_filter_query(
+            filter_column=mm_schemas.EventFieldType.ENDPOINT_ID,
+            filter_values=endpoint_ids,
+        )
         filter_query += f"AND {mm_schemas.EventFieldType.ERROR_TYPE} = '{mm_schemas.EventFieldType.INFER_ERROR}'"
         start, end = self._get_start_end(start, end)
         df = self._get_records(

mlrun/model_monitoring/db/tsdb/v3io/v3io_connector.py

@@ -417,6 +417,7 @@ class V3IOTSDBConnector(TSDBConnector):
             mm_schemas.WriterEvent.END_INFER_TIME,
             mm_schemas.WriterEvent.ENDPOINT_ID,
             mm_schemas.WriterEvent.APPLICATION_NAME,
+            mm_schemas.WriterEvent.ENDPOINT_NAME,
         ]
 
         if kind == mm_schemas.WriterEventKind.METRIC:
@@ -694,22 +695,26 @@ class V3IOTSDBConnector(TSDBConnector):
         )
 
     @staticmethod
-    def _get_endpoint_filter(endpoint_id: Union[str, list[str]]) -> Optional[str]:
-        if isinstance(endpoint_id, str):
-            return f"endpoint_id=='{endpoint_id}'"
-        elif isinstance(endpoint_id, list):
-            if len(endpoint_id) > V3IO_FRAMESD_MEPS_LIMIT:
+    def _generate_filter_query(
+        filter_key: str, filter_values: Union[str, list[str]]
+    ) -> Optional[str]:
+        if isinstance(filter_values, str):
+            return f"{filter_key}=='{filter_values}'"
+        elif isinstance(filter_values, list):
+            if len(filter_values) > V3IO_FRAMESD_MEPS_LIMIT:
                 logger.info(
-                    "The number of endpoint ids exceeds the v3io-engine filter-expression limit, "
-                    "retrieving all the model endpoints from the db.",
+                    "The number of filter values exceeds the v3io-engine filter-expression limit, "
+                    "retrieving all the values from the db.",
+                    filter_key=filter_key,
                     limit=V3IO_FRAMESD_MEPS_LIMIT,
-                    amount=len(endpoint_id),
+                    amount=len(filter_values),
                 )
                 return None
-            return f"endpoint_id IN({str(endpoint_id)[1:-1]}) "
+            return f"{filter_key} IN ({', '.join(repr(v) for v in filter_values)}) "
         else:
             raise mlrun.errors.MLRunInvalidArgumentError(
-                f"Invalid 'endpoint_id' filter: must be a string or a list, endpoint_id: {endpoint_id}"
+                f"Invalid filter key {filter_key}: must be a string or a list, got {type(filter_values).__name__}; "
+                f"filter values: {filter_values}"
             )
 
     def read_metrics_data(
@@ -946,7 +951,11 @@ class V3IOTSDBConnector(TSDBConnector):
         end: Optional[datetime] = None,
         get_raw: bool = False,
     ) -> Union[pd.DataFrame, list[v3io_frames.client.RawFrame]]:
-        filter_query = self._get_endpoint_filter(endpoint_id=endpoint_ids)
+        filter_query = self._generate_filter_query(
+            filter_key=mm_schemas.ApplicationEvent.ENDPOINT_ID,
+            filter_values=endpoint_ids,
+        )
+
         start = start or (mlrun.utils.datetime_now() - timedelta(hours=24))
         start, end = self._get_start_end(start, end)
         res = self._get_records(
@@ -976,7 +985,10 @@ class V3IOTSDBConnector(TSDBConnector):
         end: Optional[datetime] = None,
     ) -> pd.DataFrame:
         start, end = self._get_start_end(start, end)
-        filter_query = self._get_endpoint_filter(endpoint_id=endpoint_id)
+        filter_query = self._generate_filter_query(
+            filter_key=mm_schemas.ApplicationEvent.ENDPOINT_ID,
+            filter_values=endpoint_id,
+        )
         df = self._get_records(
             table=mm_schemas.V3IOTSDBTables.METRICS,
             start=start,
@@ -998,7 +1010,10 @@ class V3IOTSDBConnector(TSDBConnector):
         end: Optional[datetime] = None,
     ) -> pd.DataFrame:
         start, end = self._get_start_end(start, end)
-        filter_query = self._get_endpoint_filter(endpoint_id=endpoint_id)
+        filter_query = self._generate_filter_query(
+            filter_key=mm_schemas.ApplicationEvent.ENDPOINT_ID,
+            filter_values=endpoint_id,
+        )
         df = self._get_records(
             table=mm_schemas.V3IOTSDBTables.APP_RESULTS,
             start=start,
@@ -1025,7 +1040,10 @@ class V3IOTSDBConnector(TSDBConnector):
         end: Optional[datetime] = None,
         get_raw: bool = False,
     ) -> Union[pd.DataFrame, list[v3io_frames.client.RawFrame]]:
-        filter_query = self._get_endpoint_filter(endpoint_id=endpoint_ids)
+        filter_query = self._generate_filter_query(
+            filter_key=mm_schemas.ApplicationEvent.ENDPOINT_ID,
+            filter_values=endpoint_ids,
+        )
         if filter_query:
             filter_query += f"AND {mm_schemas.EventFieldType.ERROR_TYPE} == '{mm_schemas.EventFieldType.INFER_ERROR}'"
         else:
@@ -1062,7 +1080,10 @@ class V3IOTSDBConnector(TSDBConnector):
         end: Optional[datetime] = None,
         get_raw: bool = False,
     ) -> Union[pd.DataFrame, list[v3io_frames.client.RawFrame]]:
-        filter_query = self._get_endpoint_filter(endpoint_id=endpoint_ids)
+        filter_query = self._generate_filter_query(
+            filter_key=mm_schemas.ApplicationEvent.ENDPOINT_ID,
+            filter_values=endpoint_ids,
+        )
         start = start or (mlrun.utils.datetime_now() - timedelta(hours=24))
         start, end = self._get_start_end(start, end)
         res = self._get_records(
@@ -1177,3 +1198,73 @@ class V3IOTSDBConnector(TSDBConnector):
             mep.status.last_request = last_request_dictionary.get(
                 uid, mep.status.last_request
             )
+
+    def count_results_by_status(
+        self,
+        start: Optional[Union[datetime, str]] = None,
+        end: Optional[Union[datetime, str]] = None,
+        endpoint_ids: Optional[Union[str, list[str]]] = None,
+        application_names: Optional[Union[str, list[str]]] = None,
+        result_status_list: Optional[list[int]] = None,
+    ) -> dict[tuple[str, int], int]:
+        now = mlrun.utils.datetime_now()
+        start = start or (now - timedelta(hours=24))
+        end = end or now
+        filter_query = ""
+        if endpoint_ids:
+            filter_query = self._generate_filter_query(
+                filter_key=mm_schemas.ApplicationEvent.ENDPOINT_ID,
+                filter_values=endpoint_ids,
+            )
+        if application_names:
+            app_filter_query = self._generate_filter_query(
+                filter_key=mm_schemas.ApplicationEvent.APPLICATION_NAME,
+                filter_values=application_names,
+            )
+            if filter_query:
+                filter_query += f" AND {app_filter_query}"
+            else:
+                filter_query = app_filter_query
+
+        df = self._get_records(
+            table=mm_schemas.V3IOTSDBTables.APP_RESULTS,
+            start=start,
+            end=end,
+            columns=[
+                mm_schemas.ResultData.RESULT_VALUE,
+                mm_schemas.ResultData.RESULT_STATUS,
+            ],
+            filter_query=filter_query,
+        )
+
+        # filter result status
+        if result_status_list and not df.empty:
+            df = df[df[mm_schemas.ResultData.RESULT_STATUS].isin(result_status_list)]
+
+        if df.empty:
+            return {}
+        else:
+            # convert application name to lower case
+            df[mm_schemas.ApplicationEvent.APPLICATION_NAME] = df[
+                mm_schemas.ApplicationEvent.APPLICATION_NAME
+            ].str.lower()
+
+            df = (
+                df[
+                    [
+                        mm_schemas.ApplicationEvent.APPLICATION_NAME,
+                        mm_schemas.ResultData.RESULT_STATUS,
+                        mm_schemas.ResultData.RESULT_VALUE,
+                    ]
+                ]
+                .groupby(
+                    [
+                        mm_schemas.ApplicationEvent.APPLICATION_NAME,
+                        mm_schemas.ResultData.RESULT_STATUS,
+                    ],
+                    observed=True,
+                )
+                .count()
+            )
+
+            return df[mm_schemas.ResultData.RESULT_VALUE].to_dict()

mlrun/projects/project.py

@@ -1409,7 +1409,10 @@ class MlrunProject(ModelObj):
                               https://apscheduler.readthedocs.io/en/3.x/modules/triggers/cron.html#module-apscheduler.triggers.cron
                               Note that "local" engine does not support this argument
         :param ttl:           Pipeline ttl in secs (after that the pods will be removed)
-        :param image:         Image for workflow runner job, only for scheduled and remote workflows
+        :param image:         Image for workflow runner job, only for scheduled and remote workflows.
+                              The image must have mlrun[kfp] installed which requires python 3.9.
+                              Therefore, the project default image will not be used for the workflow,
+                              and the image must be specified explicitly.
         :param args:          Argument values (key=value, ..)
         """
 
@@ -4971,6 +4974,42 @@ class MlrunProject(ModelObj):
             labels=model_monitoring_labels_list,
         )
 
+    def get_monitoring_function_summaries(
+        self,
+        start: Optional[datetime.datetime] = None,
+        end: Optional[datetime.datetime] = None,
+        names: Optional[Union[list[str], str]] = None,
+        labels: Optional[Union[str, dict[str, Optional[str]], list[str]]] = None,
+        include_stats: bool = False,
+        include_infra: bool = True,
+    ) -> list[mlrun.common.schemas.model_monitoring.FunctionSummary]:
+        """Get monitoring function summaries for the specified project.
+        :param start: Start time for filtering the results (optional).
+        :param end: End time for filtering the results (optional).
+        :param names: List of function names to filter by (optional).
+        :param labels: Labels to filter by (optional).
+        :param include_stats: Whether to include statistics in the response (default is False).
+        :param include_infra: whether to include model monitoring infrastructure functions (default is True).
+        :return: A list of FunctionSummary objects containing information about the monitoring functions.
+        """
+
+        if start is not None and end is not None:
+            if start.tzinfo is None or end.tzinfo is None:
+                raise mlrun.errors.MLRunInvalidArgumentTypeError(
+                    "Custom start and end times must contain the timezone."
+                )
+
+        db = mlrun.db.get_run_db(secrets=self._secrets)
+        return db.get_monitoring_function_summaries(
+            project=self.metadata.name,
+            start=start,
+            end=end,
+            names=names,
+            labels=labels,
+            include_stats=include_stats,
+            include_infra=include_infra,
+        )
+
     def list_runs(
         self,
         name: Optional[str] = None,

mlrun/runtimes/base.py

@@ -74,7 +74,6 @@ spec_fields = [
     "pythonpath",
     "disable_auto_mount",
     "allow_empty_resources",
-    "clone_target_dir",
     "reset_on_run",
 ]
 
@@ -117,7 +116,6 @@ class FunctionSpec(ModelObj):
         default_handler=None,
         pythonpath=None,
         disable_auto_mount=False,
-        clone_target_dir=None,
     ):
         self.command = command or ""
         self.image = image or ""
@@ -134,9 +132,6 @@ class FunctionSpec(ModelObj):
         self.entry_points = entry_points or {}
         self.disable_auto_mount = disable_auto_mount
         self.allow_empty_resources = None
-        # The build.source is cloned/extracted to the specified clone_target_dir
-        # if a relative path is specified, it will be enriched with a temp dir path
-        self._clone_target_dir = clone_target_dir or None
 
     @property
     def build(self) -> ImageBuilder:
@@ -146,28 +141,6 @@ class FunctionSpec(ModelObj):
     def build(self, build):
         self._build = self._verify_dict(build, "build", ImageBuilder)
 
-    @property
-    def clone_target_dir(self):
-        # TODO: remove this property in 1.10.0
-        if self.build.source_code_target_dir:
-            warnings.warn(
-                "The clone_target_dir attribute is deprecated in 1.6.2 and will be removed in 1.10.0. "
-                "Use spec.build.source_code_target_dir instead.",
-                FutureWarning,
-            )
-        return self.build.source_code_target_dir
-
-    @clone_target_dir.setter
-    def clone_target_dir(self, clone_target_dir):
-        # TODO: remove this property in 1.10.0
-        if clone_target_dir:
-            warnings.warn(
-                "The clone_target_dir attribute is deprecated in 1.6.2 and will be removed in 1.10.0. "
-                "Use spec.build.source_code_target_dir instead.",
-                FutureWarning,
-            )
-        self.build.source_code_target_dir = clone_target_dir
-
     def enrich_function_preemption_spec(self):
         pass
 

mlrun/runtimes/daskjob.py

@@ -91,7 +91,6 @@ class DaskSpec(KubeResourceSpec):
         tolerations=None,
         preemption_mode=None,
         security_context=None,
-        clone_target_dir=None,
         state_thresholds=None,
     ):
         super().__init__(
@@ -121,7 +120,6 @@ class DaskSpec(KubeResourceSpec):
             tolerations=tolerations,
             preemption_mode=preemption_mode,
             security_context=security_context,
-            clone_target_dir=clone_target_dir,
             state_thresholds=state_thresholds,
         )
         self.args = args
@@ -192,7 +190,9 @@ class DaskCluster(KubejobRuntime):
         super().__init__(spec, metadata)
         self._cluster = None
         self.use_remote = not mlrun.k8s_utils.is_running_inside_kubernetes_cluster()
-        self.spec.build.base_image = self.spec.build.base_image or "daskdev/dask:latest"
+        self.spec.build.base_image = (
+            self.spec.build.base_image or mlrun.mlconf.default_base_image
+        )
 
     @property
     def spec(self) -> DaskSpec:
@@ -248,14 +248,18 @@ class DaskCluster(KubejobRuntime):
         if not self.is_deployed():
             raise RunError(
                 "Function image is not built/ready, use .deploy()"
-                " method first, or set base dask image (daskdev/dask:latest)"
+                " method first, or set base dask image to mlrun/mlrun"
             )
 
         self.save(versioned=False)
         background_task = db.start_function(func_url=self._function_uri())
         if watch:
             now = datetime.datetime.utcnow()
-            timeout = now + datetime.timedelta(minutes=10)
+            timeout = now + datetime.timedelta(
+                seconds=int(
+                    mlrun.mlconf.background_tasks.default_timeouts.runtimes.dask_cluster_start
+                )
+            )
             while now < timeout:
                 background_task = db.get_project_background_task(
                     background_task.metadata.project, background_task.metadata.name
@@ -282,6 +286,9 @@ class DaskCluster(KubejobRuntime):
                         return
                 time.sleep(5)
                 now = datetime.datetime.utcnow()
+            raise mlrun.errors.MLRunTimeoutError(
+                "Timeout waiting for Dask cluster to start"
+            )
 
     def close(self, running=True):
         from dask.distributed import default_client

mlrun/runtimes/databricks_job/databricks_runtime.py

@@ -82,7 +82,6 @@ class DatabricksSpec(pod.KubeResourceSpec):
         tolerations=None,
         preemption_mode=None,
         security_context=None,
-        clone_target_dir=None,
         state_thresholds=None,
     ):
         super().__init__(
@@ -112,7 +111,6 @@ class DatabricksSpec(pod.KubeResourceSpec):
             tolerations=tolerations,
             preemption_mode=preemption_mode,
             security_context=security_context,
-            clone_target_dir=clone_target_dir,
             state_thresholds=state_thresholds,
         )
         self._termination_grace_period_seconds = 60

mlrun/runtimes/mpijob/abstract.py

@@ -53,7 +53,6 @@ class MPIResourceSpec(KubeResourceSpec):
         tolerations=None,
         preemption_mode=None,
         security_context=None,
-        clone_target_dir=None,
         state_thresholds=None,
     ):
         super().__init__(
@@ -83,7 +82,6 @@ class MPIResourceSpec(KubeResourceSpec):
             tolerations=tolerations,
             preemption_mode=preemption_mode,
             security_context=security_context,
-            clone_target_dir=clone_target_dir,
             state_thresholds=state_thresholds,
         )
         self.mpi_args = mpi_args or [

mlrun/runtimes/mpijob/v1.py

@@ -48,7 +48,6 @@ class MPIV1ResourceSpec(MPIResourceSpec):
         tolerations=None,
         preemption_mode=None,
         security_context=None,
-        clone_target_dir=None,
         state_thresholds=None,
     ):
         super().__init__(
@@ -79,7 +78,6 @@ class MPIV1ResourceSpec(MPIResourceSpec):
             tolerations=tolerations,
             preemption_mode=preemption_mode,
             security_context=security_context,
-            clone_target_dir=clone_target_dir,
             state_thresholds=state_thresholds,
         )
         self.clean_pod_policy = clean_pod_policy or MPIJobV1CleanPodPolicies.default()

mlrun/runtimes/nuclio/application/application.py

@@ -76,7 +76,6 @@ class ApplicationSpec(NuclioSpec):
         security_context=None,
         service_type=None,
         add_templated_ingress_host_mode=None,
-        clone_target_dir=None,
         state_thresholds=None,
         disable_default_http_trigger=None,
         internal_application_port=None,
@@ -119,7 +118,6 @@ class ApplicationSpec(NuclioSpec):
             security_context=security_context,
             service_type=service_type,
             add_templated_ingress_host_mode=add_templated_ingress_host_mode,
-            clone_target_dir=clone_target_dir,
             state_thresholds=state_thresholds,
             disable_default_http_trigger=disable_default_http_trigger,
         )
@@ -274,7 +272,6 @@ class ApplicationRuntime(RemoteRuntime):
         project="",
         tag="",
         verbose=False,
-        auth_info: schemas.AuthInfo = None,
         builder_env: typing.Optional[dict] = None,
         force_build: bool = False,
         with_mlrun=None,
@@ -291,7 +288,6 @@ class ApplicationRuntime(RemoteRuntime):
         :param project:                     Project name
         :param tag:                         Function tag
         :param verbose:                     Set True for verbose logging
-        :param auth_info:                   Service AuthInfo (deprecated and ignored)
         :param builder_env:                 Env vars dict for source archive config/credentials
                                             e.g. builder_env={"GIT_TOKEN": token}
         :param force_build:                 Set True for force building the application image
@@ -332,7 +328,6 @@ class ApplicationRuntime(RemoteRuntime):
             project=project,
             tag=tag,
             verbose=verbose,
-            auth_info=auth_info,
             builder_env=builder_env,
         )
         logger.info(