mlrun 1.8.0rc43__py3-none-any.whl → 1.8.0rc45__py3-none-any.whl

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

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import math
-from datetime import datetime, timedelta, timezone
+from datetime import datetime, timedelta
 from io import StringIO
 from typing import Callable, Literal, Optional, Union
 
@@ -33,7 +33,12 @@ _TSDB_BE = "tsdb"
 _TSDB_RATE = "1/s"
 _CONTAINER = "users"
 
-V3IO_MEPS_LIMIT = 200
+V3IO_FRAMESD_MEPS_LIMIT = (
+    200  # Maximum number of model endpoints per single request when using V3IO Frames
+)
+V3IO_CLIENT_MEPS_LIMIT = (
+    150  # Maximum number of model endpoints per single request when using V3IO Client
+)
 
 
 def _is_no_schema_error(exc: v3io_frames.Error) -> bool:
@@ -72,6 +77,15 @@ class V3IOTSDBConnector(TSDBConnector):
         self._frames_client: Optional[v3io_frames.client.ClientBase] = None
         self._init_tables_path()
         self._create_table = create_table
+        self._v3io_client = None
+
+    @property
+    def v3io_client(self):
+        if not self._v3io_client:
+            self._v3io_client = mlrun.utils.v3io_clients.get_v3io_client(
+                endpoint=mlrun.mlconf.v3io_api, access_key=self._v3io_access_key
+            )
+        return self._v3io_client
 
     @property
     def frames_client(self) -> v3io_frames.client.ClientBase:
@@ -147,6 +161,21 @@ class V3IOTSDBConnector(TSDBConnector):
         )
         self.tables[mm_schemas.V3IOTSDBTables.PREDICTIONS] = monitoring_predictions_path
 
+        # initialize kv table
+        last_request_full_table_path = (
+            mlrun.mlconf.get_model_monitoring_file_target_path(
+                project=self.project,
+                kind=mm_schemas.FileTargetKind.LAST_REQUEST,
+            )
+        )
+        (
+            _,
+            _,
+            self.last_request_table,
+        ) = mlrun.common.model_monitoring.helpers.parse_model_endpoint_store_prefix(
+            last_request_full_table_path
+        )
+
     def create_tables(self) -> None:
         """
         Create the tables using the TSDB connector. These are the tables that are stored in the V3IO TSDB:
@@ -252,6 +281,16 @@ class V3IOTSDBConnector(TSDBConnector):
             key=mm_schemas.EventFieldType.ENDPOINT_ID,
         )
 
+        # Write last request timestamp to KV table
+        graph.add_step(
+            "storey.NoSqlTarget",
+            name="KVLastRequest",
+            after="tsdb_predictions",
+            table=f"v3io:///users/{self.last_request_table}",
+            columns=[EventFieldType.LAST_REQUEST_TIMESTAMP],
+            index_cols=[EventFieldType.ENDPOINT_ID],
+        )
+
         # Emits the event in window size of events based on sample_window size (10 by default)
         graph.add_step(
             "storey.steps.SampleWindow",
@@ -441,8 +480,8 @@ class V3IOTSDBConnector(TSDBConnector):
         tables = mm_schemas.V3IOTSDBTables.list()
 
         # Split the endpoint ids into chunks to avoid exceeding the v3io-engine filter-expression limit
-        for i in range(0, len(endpoint_ids), V3IO_MEPS_LIMIT):
-            endpoint_id_chunk = endpoint_ids[i : i + V3IO_MEPS_LIMIT]
+        for i in range(0, len(endpoint_ids), V3IO_FRAMESD_MEPS_LIMIT):
+            endpoint_id_chunk = endpoint_ids[i : i + V3IO_FRAMESD_MEPS_LIMIT]
             filter_query = f"endpoint_id IN({str(endpoint_id_chunk)[1:-1]}) "
             for table in tables:
                 try:
@@ -458,12 +497,31 @@ class V3IOTSDBConnector(TSDBConnector):
                         error=mlrun.errors.err_to_str(e),
                         project=self.project,
                     )
+
+        # Clean the last request records from the KV table
+        self._delete_last_request_records(endpoint_ids=endpoint_ids)
+
         logger.debug(
             "Deleted all model endpoint resources using the V3IO connector",
             project=self.project,
             number_of_endpoints_to_delete=len(endpoint_ids),
         )
 
+    def _delete_last_request_records(self, endpoint_ids: list[str]):
+        for endpoint_id in endpoint_ids:
+            try:
+                self.v3io_client.kv.delete(
+                    container=self.container,
+                    table=self.last_request_table,
+                    key=endpoint_id,
+                )
+            except Exception as e:
+                logger.warning(
+                    f"Failed to delete last request record for endpoint '{endpoint_id}'",
+                    error=mlrun.errors.err_to_str(e),
+                    project=self.project,
+                )
+
     def get_model_endpoint_real_time_metrics(
         self, endpoint_id: str, metrics: list[str], start: str, end: str
     ) -> dict[str, list[tuple[str, float]]]:
@@ -631,11 +689,11 @@ class V3IOTSDBConnector(TSDBConnector):
         if isinstance(endpoint_id, str):
             return f"endpoint_id=='{endpoint_id}'"
         elif isinstance(endpoint_id, list):
-            if len(endpoint_id) > V3IO_MEPS_LIMIT:
+            if len(endpoint_id) > 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.",
-                    limit=V3IO_MEPS_LIMIT,
+                    limit=V3IO_FRAMESD_MEPS_LIMIT,
                     amount=len(endpoint_id),
                 )
                 return None
@@ -826,41 +884,51 @@ class V3IOTSDBConnector(TSDBConnector):
         endpoint_ids: Union[str, list[str]],
         start: Optional[datetime] = None,
         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)
-        start, end = self._get_start_end(start, end)
-
-        res = self._get_records(
-            table=mm_schemas.V3IOTSDBTables.PREDICTIONS,
-            start=start,
-            end=end,
-            filter_query=filter_query,
-            agg_funcs=["last"],
-            get_raw=get_raw,
-        )
+    ) -> dict[str, float]:
+        # Get the last request timestamp for each endpoint from the KV table.
+        # The result of the query is a list of dictionaries,
+        # each dictionary contains the endpoint id and the last request timestamp.
+        last_request_timestamps = {}
+        if isinstance(endpoint_ids, str):
+            endpoint_ids = [endpoint_ids]
 
-        if get_raw:
-            return res
+        try:
+            if len(endpoint_ids) > V3IO_CLIENT_MEPS_LIMIT:
+                logger.warning(
+                    "The number of endpoint ids exceeds the v3io-engine filter-expression limit, "
+                    "retrieving last request for all the model endpoints from the KV table.",
+                    limit=V3IO_CLIENT_MEPS_LIMIT,
+                    amount=len(endpoint_ids),
+                )
 
-        df = res
-        if not df.empty:
-            df.rename(
-                columns={
-                    f"last({mm_schemas.EventFieldType.LAST_REQUEST_TIMESTAMP})": mm_schemas.EventFieldType.LAST_REQUEST,
-                    f"last({mm_schemas.EventFieldType.LATENCY})": f"last_{mm_schemas.EventFieldType.LATENCY}",
-                },
-                inplace=True,
-            )
-            df[mm_schemas.EventFieldType.LAST_REQUEST] = df[
-                mm_schemas.EventFieldType.LAST_REQUEST
-            ].map(
-                lambda last_request: datetime.fromtimestamp(
-                    last_request, tz=timezone.utc
+                res = self.v3io_client.kv.new_cursor(
+                    container=self.container,
+                    table_path=self.last_request_table,
+                ).all()
+                last_request_timestamps.update(
+                    {d["__name"]: d["last_request_timestamp"] for d in res}
                 )
+            else:
+                filter_expression = " OR ".join(
+                    [f"__name=='{endpoint_id}'" for endpoint_id in endpoint_ids]
+                )
+                res = self.v3io_client.kv.new_cursor(
+                    container=self.container,
+                    table_path=self.last_request_table,
+                    filter_expression=filter_expression,
+                ).all()
+                last_request_timestamps.update(
+                    {d["__name"]: d["last_request_timestamp"] for d in res}
+                )
+        except Exception as e:
+            logger.warning(
+                "Failed to get last request timestamp from V3IO KV table.",
+                err=mlrun.errors.err_to_str(e),
+                project=self.project,
+                table=self.last_request_table,
             )
 
-        return df.reset_index(drop=True)
+        return last_request_timestamps
 
     def get_drift_status(
         self,
@@ -1037,7 +1105,6 @@ class V3IOTSDBConnector(TSDBConnector):
             model_endpoint_objects_by_uid[uid] = model_endpoint_object
 
         error_count_res = self.get_error_count(endpoint_ids=uids, get_raw=True)
-        last_request_res = self.get_last_request(endpoint_ids=uids, get_raw=True)
         avg_latency_res = self.get_avg_latency(endpoint_ids=uids, get_raw=True)
         drift_status_res = self.get_drift_status(endpoint_ids=uids, get_raw=True)
 
@@ -1060,11 +1127,7 @@ class V3IOTSDBConnector(TSDBConnector):
             "count(error_count)",
             error_count_res,
         )
-        add_metric(
-            "last_request",
-            "last(last_request_timestamp)",
-            last_request_res,
-        )
+
         add_metric(
             "avg_latency",
             "avg(latency)",
@@ -1075,4 +1138,23 @@ class V3IOTSDBConnector(TSDBConnector):
             "max(result_status)",
             drift_status_res,
         )
+
+        self._enrich_mep_with_last_request(
+            model_endpoint_objects_by_uid=model_endpoint_objects_by_uid
+        )
+
         return list(model_endpoint_objects_by_uid.values())
+
+    def _enrich_mep_with_last_request(
+        self,
+        model_endpoint_objects_by_uid: dict[str, mlrun.common.schemas.ModelEndpoint],
+    ):
+        last_request_dictionary = self.get_last_request(
+            endpoint_ids=list(model_endpoint_objects_by_uid.keys())
+        )
+        for uid, mep in model_endpoint_objects_by_uid.items():
+            # Set the last request timestamp to the MEP object. If not found, keep the existing value from the
+            # DB (relevant for batch EP).
+            mep.status.last_request = last_request_dictionary.get(
+                uid, mep.status.last_request
+            )

mlrun/model_monitoring/writer.py

@@ -180,7 +180,7 @@ class ModelMonitoringWriter(StepToDict):
                 data, timestamp
             )
         logger.info(
-            "Updating the model endpoint statistics",
+            "Updated the model endpoint statistics",
             endpoint_id=endpoint_id,
             stats_kind=stat_kind,
         )

mlrun/projects/project.py

@@ -2451,7 +2451,22 @@ class MlrunProject(ModelObj):
         :param image:                             The image of the model monitoring controller, writer, monitoring
                                                   stream & histogram data drift functions, which are real time nuclio
                                                   functions. By default, the image is mlrun/mlrun.
-        :param deploy_histogram_data_drift_app:   If true, deploy the default histogram-based data drift application.
+        :param deploy_histogram_data_drift_app:   If true, deploy the default histogram-based data drift application:
+            :py:class:`~mlrun.model_monitoring.applications.histogram_data_drift.HistogramDataDriftApplication`.
+            If false, and you want to deploy the histogram data drift application
+            afterwards, you may use the
+            :py:func:`~set_model_monitoring_function` method::
+
+                import mlrun.model_monitoring.applications.histogram_data_drift as histogram_data_drift
+
+                hist_app = project.set_model_monitoring_function(
+                    name=histogram_data_drift.HistogramDataDriftApplicationConstants.NAME,  # keep the default name
+                    func=histogram_data_drift.__file__,
+                    application_class=histogram_data_drift.HistogramDataDriftApplication.__name__,
+                )
+
+                project.deploy_function(hist_app)
+
         :param wait_for_deployment:               If true, return only after the deployment is done on the backend.
                                                   Otherwise, deploy the model monitoring infrastructure on the
                                                   background, including the histogram data drift app if selected.
@@ -2488,30 +2503,6 @@ class MlrunProject(ModelObj):
                 )
             self._wait_for_functions_deployment(deployment_functions)
 
-    def deploy_histogram_data_drift_app(
-        self,
-        *,
-        image: str = "mlrun/mlrun",
-        db: Optional[mlrun.db.RunDBInterface] = None,
-        wait_for_deployment: bool = False,
-    ) -> None:
-        """
-        Deploy the histogram data drift application.
-
-        :param image:               The image on which the application will run.
-        :param db:                  An optional DB object.
-        :param wait_for_deployment: If true, return only after the deployment is done on the backend.
-                                    Otherwise, deploy the application on the background.
-        """
-        if db is None:
-            db = mlrun.db.get_run_db(secrets=self._secrets)
-        db.deploy_histogram_data_drift_app(project=self.name, image=image)
-
-        if wait_for_deployment:
-            self._wait_for_functions_deployment(
-                [mm_constants.HistogramDataDriftApplicationConstants.NAME]
-            )
-
     def update_model_monitoring_controller(
         self,
         base_period: int = 10,
@@ -5034,14 +5025,20 @@ class MlrunProject(ModelObj):
         db = mlrun.db.get_run_db(secrets=self._secrets)
         return db.get_alert_config(alert_name, self.metadata.name)
 
-    def list_alerts_configs(self) -> list[AlertConfig]:
+    def list_alerts_configs(
+        self, limit: Optional[int] = None, offset: Optional[int] = None
+    ) -> list[AlertConfig]:
         """
         Retrieve list of alerts of a project.
 
+        :param limit: The maximum number of alerts to return.
+            Defaults to `mlconf.alerts.default_list_alert_configs_limit` if not provided.
+        :param offset: The number of alerts to skip before starting to collect alerts.
+
         :return: All the alerts objects of the project.
         """
         db = mlrun.db.get_run_db(secrets=self._secrets)
-        return db.list_alerts_configs(self.metadata.name)
+        return db.list_alerts_configs(self.metadata.name, limit=limit, offset=offset)
 
     def delete_alert_config(
         self, alert_data: AlertConfig = None, alert_name: Optional[str] = None

mlrun/runtimes/nuclio/application/reverse_proxy.go

@@ -4,7 +4,7 @@
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
-//   http://www.apache.org/licenses/LICENSE-2.0
+//	http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ -14,82 +14,84 @@
 package main
 
 import (
-    "bytes"
-    "fmt"
-    "net/http"
-    "net/http/httptest"
-    "net/http/httputil"
-    "net/url"
-    "os"
-    "strings"
+	"bytes"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"net/http/httputil"
+	"net/url"
+	"os"
+	"strings"
 
-    nuclio "github.com/nuclio/nuclio-sdk-go"
+	nuclio "github.com/nuclio/nuclio-sdk-go"
 )
 
 func Handler(context *nuclio.Context, event nuclio.Event) (interface{}, error) {
-    reverseProxy := context.UserData.(map[string]interface{})["reverseProxy"].(*httputil.ReverseProxy)
-    sidecarUrl := context.UserData.(map[string]interface{})["server"].(string)
+	reverseProxy := context.UserData.(map[string]interface{})["reverseProxy"].(*httputil.ReverseProxy)
+	sidecarUrl := context.UserData.(map[string]interface{})["server"].(string)
 
-    // populate reverse proxy http request
-    httpRequest, err := http.NewRequest(event.GetMethod(), event.GetPath(), bytes.NewReader(event.GetBody()))
-    if err != nil {
-        context.Logger.ErrorWith("Failed to create a reverse proxy request")
-        return nil, err
-    }
-    for k, v := range event.GetHeaders() {
-        httpRequest.Header[k] = []string{v.(string)}
-    }
+	// populate reverse proxy http request
+	httpRequest, err := http.NewRequest(event.GetMethod(), event.GetPath(), bytes.NewReader(event.GetBody()))
+	if err != nil {
+		context.Logger.ErrorWith("Failed to create a reverse proxy request")
+		return nil, err
+	}
+	for k, v := range event.GetHeaders() {
+		httpRequest.Header[k] = []string{v.(string)}
+	}
 
-    // populate query params
-    query := httpRequest.URL.Query()
-    for k, v := range event.GetFields() {
-        query.Set(k, v.(string))
-    }
-    httpRequest.URL.RawQuery = query.Encode()
+	// populate query params
+	query := httpRequest.URL.Query()
+	for k, v := range event.GetFields() {
+		query.Set(k, v.(string))
+	}
+	httpRequest.URL.RawQuery = query.Encode()
 
-    recorder := httptest.NewRecorder()
-    reverseProxy.ServeHTTP(recorder, httpRequest)
+	recorder := httptest.NewRecorder()
+	reverseProxy.ServeHTTP(recorder, httpRequest)
 
-    // send request to sidecar
-    context.Logger.DebugWith("Forwarding request to sidecar", "sidecarUrl", sidecarUrl, "query", httpRequest.URL.Query())
-    response := recorder.Result()
+	// send request to sidecar
+	context.Logger.DebugWith("Forwarding request to sidecar",
+		"sidecarUrl", sidecarUrl,
+		"method", event.GetMethod())
+	response := recorder.Result()
 
-    headers := make(map[string]interface{})
-    for key, value := range response.Header {
-        headers[key] = value[0]
-    }
+	headers := make(map[string]interface{})
+	for key, value := range response.Header {
+		headers[key] = value[0]
+	}
 
-    // let the processor calculate the content length
-    delete(headers, "Content-Length")
-    return nuclio.Response{
-        StatusCode:  response.StatusCode,
-        Body:        recorder.Body.Bytes(),
-        ContentType: response.Header.Get("Content-Type"),
-        Headers:     headers,
-    }, nil
+	// let the processor calculate the content length
+	delete(headers, "Content-Length")
+	return nuclio.Response{
+		StatusCode:  response.StatusCode,
+		Body:        recorder.Body.Bytes(),
+		ContentType: response.Header.Get("Content-Type"),
+		Headers:     headers,
+	}, nil
 }
 
 func InitContext(context *nuclio.Context) error {
-    sidecarHost := os.Getenv("SIDECAR_HOST")
-    sidecarPort := os.Getenv("SIDECAR_PORT")
-    if sidecarHost == "" {
-        sidecarHost = "http://localhost"
-    } else if !strings.Contains(sidecarHost, "://") {
-        sidecarHost = fmt.Sprintf("http://%s", sidecarHost)
-    }
+	sidecarHost := os.Getenv("SIDECAR_HOST")
+	sidecarPort := os.Getenv("SIDECAR_PORT")
+	if sidecarHost == "" {
+		sidecarHost = "http://localhost"
+	} else if !strings.Contains(sidecarHost, "://") {
+		sidecarHost = fmt.Sprintf("http://%s", sidecarHost)
+	}
 
-    // url for request forwarding
-    sidecarUrl := fmt.Sprintf("%s:%s", sidecarHost, sidecarPort)
-    parsedURL, err := url.Parse(sidecarUrl)
-    if err != nil {
-        context.Logger.ErrorWith("Failed to parse sidecar url", "sidecarUrl", sidecarUrl)
-        return err
-    }
-    reverseProxy := httputil.NewSingleHostReverseProxy(parsedURL)
+	// url for request forwarding
+	sidecarUrl := fmt.Sprintf("%s:%s", sidecarHost, sidecarPort)
+	parsedURL, err := url.Parse(sidecarUrl)
+	if err != nil {
+		context.Logger.ErrorWith("Failed to parse sidecar url", "sidecarUrl", sidecarUrl)
+		return err
+	}
+	reverseProxy := httputil.NewSingleHostReverseProxy(parsedURL)
 
-    context.UserData = map[string]interface{}{
-        "server":       sidecarUrl,
-        "reverseProxy": reverseProxy,
-    }
-    return nil
+	context.UserData = map[string]interface{}{
+		"server":       sidecarUrl,
+		"reverseProxy": reverseProxy,
+	}
+	return nil
 }

mlrun/serving/states.py

@@ -959,7 +959,7 @@ class ModelRunner(storey.ParallelExecution):
         return self.model_selector.select(event, models)
 
 
-class ModelRunnerStep(TaskStep):
+class ModelRunnerStep(TaskStep, StepToDict):
     """
     Runs multiple Models on each event.
 
@@ -981,29 +981,41 @@ class ModelRunnerStep(TaskStep):
         model_selector: Optional[Union[str, ModelSelector]] = None,
         **kwargs,
     ):
-        self._models = []
         super().__init__(
             *args,
             class_name="mlrun.serving.ModelRunner",
-            class_args=dict(runnables=self._models, model_selector=model_selector),
+            class_args=dict(model_selector=model_selector),
             **kwargs,
         )
 
-    def add_model(self, model: Model) -> None:
-        """Add a Model to this ModelRunner."""
-        self._models.append(model)
+    def add_model(self, model: Union[str, Model], **model_parameters) -> None:
+        """
+        Add a Model to this ModelRunner.
+
+        :param model: Model class name or object
+        :param model_parameters: Parameters for model instantiation
+        """
+        models = self.class_args.get("models", [])
+        models.append((model, model_parameters))
+        self.class_args["models"] = models
 
     def init_object(self, context, namespace, mode="sync", reset=False, **extra_kwargs):
         model_selector = self.class_args.get("model_selector")
+        models = self.class_args.get("models")
         if isinstance(model_selector, str):
             model_selector = get_class(model_selector, namespace)()
+        model_objects = []
+        for model, model_params in models:
+            if not isinstance(model, Model):
+                model = get_class(model, namespace)(**model_params)
+            model_objects.append(model)
         self._async_object = ModelRunner(
-            self.class_args.get("runnables"),
             model_selector=model_selector,
+            runnables=model_objects,
         )
 
 
-class QueueStep(BaseStep):
+class QueueStep(BaseStep, StepToDict):
     """queue step, implement an async queue or represent a stream"""
 
     kind = "queue"
@@ -1799,21 +1811,13 @@ def params_to_step(
 
     class_args = class_args or {}
 
-    if class_name and hasattr(class_name, "to_dict"):
-        struct = class_name.to_dict()
-        kind = struct.get("kind", StepKinds.task)
-        name = name or struct.get("name", struct.get("class_name"))
-        cls = classes_map.get(kind, RootFlowStep)
-        step = cls.from_dict(struct)
-        step.function = function
-        step.full_event = full_event or step.full_event
-        step.input_path = input_path or step.input_path
-        step.result_path = result_path or step.result_path
-        if kind == StepKinds.task:
-            step.model_endpoint_creation_strategy = model_endpoint_creation_strategy
-            step.endpoint_type = endpoint_type
+    if isinstance(class_name, QueueStep):
+        if not name or class_name.name:
+            raise MLRunInvalidArgumentError("queue name must be specified")
+
+        step = class_name
 
-    elif class_name and class_name in queue_class_names:
+    elif class_name in queue_class_names:
         if "path" not in class_args:
             raise MLRunInvalidArgumentError(
                 "path=<stream path or None> must be specified for queues"
@@ -1826,6 +1830,20 @@ def params_to_step(
             class_args["full_event"] = full_event
         step = QueueStep(name, **class_args)
 
+    elif class_name and hasattr(class_name, "to_dict"):
+        struct = class_name.to_dict()
+        kind = struct.get("kind", StepKinds.task)
+        name = name or struct.get("name", struct.get("class_name"))
+        cls = classes_map.get(kind, RootFlowStep)
+        step = cls.from_dict(struct)
+        step.function = function
+        step.full_event = full_event or step.full_event
+        step.input_path = input_path or step.input_path
+        step.result_path = result_path or step.result_path
+        if kind == StepKinds.task:
+            step.model_endpoint_creation_strategy = model_endpoint_creation_strategy
+            step.endpoint_type = endpoint_type
+
     elif class_name and class_name.startswith("*"):
         routes = class_args.get("routes", None)
         class_name = class_name[1:]

mlrun/utils/version/version.json

@@ -1,4 +1,4 @@
 {
-  "git_commit": "4ffe55c0a4818e4a58b7a80b4a05a1932e4ff99b",
-  "version": "1.8.0-rc43"
+  "git_commit": "b434e35c26bb66407a60bedddb7a9af71141902b",
+  "version": "1.8.0-rc45"
 }

{mlrun-1.8.0rc43.dist-info → mlrun-1.8.0rc45.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: mlrun
-Version: 1.8.0rc43
+Version: 1.8.0rc45
 Summary: Tracking and config of machine learning runs
 Home-page: https://github.com/mlrun/mlrun
 Author: Yaron Haviv
@@ -240,6 +240,7 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
+Dynamic: license-file
 Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: requires-python