mlrun 1.8.0rc41__py3-none-any.whl → 1.8.0rc42__py3-none-any.whl

mlrun/common/schemas/model_monitoring/constants.py

@@ -161,6 +161,7 @@ class ApplicationEvent:
     END_INFER_TIME = "end_infer_time"
     ENDPOINT_ID = "endpoint_id"
     ENDPOINT_NAME = "endpoint_name"
+    ENDPOINT_UPDATED = "endpoint_updated"
 
 
 class WriterEvent(MonitoringStrEnum):
@@ -190,7 +191,13 @@ class ControllerEvent(MonitoringStrEnum):
     ENDPOINT_TYPE = "endpoint_type"
     ENDPOINT_POLICY = "endpoint_policy"
     # Note: currently under endpoint policy we will have a dictionary including the keys: "application_names"
-    # and "base_period"
+    # "base_period", and "updated_endpoint" stand for when the MEP was updated
+
+
+class ControllerEventEndpointPolicy(MonitoringStrEnum):
+    BASE_PERIOD = "base_period"
+    MONITORING_APPLICATIONS = "monitoring_applications"
+    ENDPOINT_UPDATED = "endpoint_updated"
 
 
 class ControllerEventKind(MonitoringStrEnum):

mlrun/datastore/base.py

@@ -14,6 +14,7 @@
 import tempfile
 import urllib.parse
 from base64 import b64encode
+from copy import copy
 from os import path, remove
 from typing import Optional, Union
 from urllib.parse import urlparse
@@ -703,7 +704,11 @@ class HttpStore(DataStore):
         raise ValueError("unimplemented")
 
     def get(self, key, size=None, offset=0):
-        data = self._http_get(self.url + self._join(key), self._headers, self.auth)
+        headers = self._headers
+        if urlparse(self.url).hostname == "api.github.com":
+            headers = copy(self._headers)
+            headers["Accept"] = headers.get("Accept", "application/vnd.github.raw")
+        data = self._http_get(self.url + self._join(key), headers, self.auth)
         if offset:
             data = data[offset:]
         if size:
@@ -714,7 +719,7 @@ class HttpStore(DataStore):
         token = self._get_secret_or_env("HTTPS_AUTH_TOKEN")
         if token:
             self._https_auth_token = token
-            self._headers.setdefault("Authorization", f"token {token}")
+            self._headers.setdefault("Authorization", f"Bearer {token}")
 
     def _validate_https_token(self):
         if self._https_auth_token and self._schema in ["http"]:

mlrun/datastore/datastore_profile.py

@@ -477,7 +477,7 @@ class DatastoreProfileHdfs(DatastoreProfile):
         return f"webhdfs://{self.host}:{self.http_port}{subpath}"
 
 
-class TDEngineDatastoreProfile(DatastoreProfile):
+class DatastoreProfileTDEngine(DatastoreProfile):
     """
     A profile that holds the required parameters for a TDEngine database, with the websocket scheme.
     https://docs.tdengine.com/developer-guide/connecting-to-tdengine/#websocket-connection
@@ -496,7 +496,7 @@ class TDEngineDatastoreProfile(DatastoreProfile):
         return f"{self.type}://{self.user}:{self.password}@{self.host}:{self.port}"
 
     @classmethod
-    def from_dsn(cls, dsn: str, profile_name: str) -> "TDEngineDatastoreProfile":
+    def from_dsn(cls, dsn: str, profile_name: str) -> "DatastoreProfileTDEngine":
         """
         Construct a TDEngine profile from DSN (connection string) and a name for the profile.
 
@@ -525,7 +525,7 @@ _DATASTORE_TYPE_TO_PROFILE_CLASS: dict[str, type[DatastoreProfile]] = {
     "gcs": DatastoreProfileGCS,
     "az": DatastoreProfileAzureBlob,
     "hdfs": DatastoreProfileHdfs,
-    "taosws": TDEngineDatastoreProfile,
+    "taosws": DatastoreProfileTDEngine,
     "config": ConfigProfile,
 }
 

mlrun/datastore/s3.py

@@ -165,6 +165,7 @@ class S3Store(DataStore):
             key=access_key_id,
             secret=secret,
             token=token,
+            use_listings_cache=False,
         )
 
         if endpoint_url:

mlrun/datastore/storeytargets.py

@@ -23,7 +23,7 @@ from mlrun.datastore.base import DataStore
 from mlrun.datastore.datastore_profile import (
     DatastoreProfileKafkaSource,
     DatastoreProfileKafkaTarget,
-    TDEngineDatastoreProfile,
+    DatastoreProfileTDEngine,
     datastore_profile_read,
 )
 
@@ -53,10 +53,10 @@ class TDEngineStoreyTarget(storey.TDEngineTarget):
     def __init__(self, *args, url: str, **kwargs):
         if url.startswith("ds://"):
             datastore_profile = datastore_profile_read(url)
-            if not isinstance(datastore_profile, TDEngineDatastoreProfile):
+            if not isinstance(datastore_profile, DatastoreProfileTDEngine):
                 raise ValueError(
                     f"Unexpected datastore profile type:{datastore_profile.type}."
-                    "Only TDEngineDatastoreProfile is supported"
+                    "Only DatastoreProfileTDEngine is supported"
                 )
             url = datastore_profile.dsn()
         super().__init__(*args, url=url, **kwargs)

mlrun/datastore/targets.py

@@ -1708,6 +1708,11 @@ class KafkaTarget(BaseStoreTarget):
         if not path:
             raise mlrun.errors.MLRunInvalidArgumentError("KafkaTarget requires a path")
 
+        # Filter attributes to keep only Kafka-related parameters
+        # This removes any non-Kafka parameters inherited from BaseStoreTarget
+        attributes = mlrun.datastore.utils.KafkaParameters().valid_entries_only(
+            self.attributes
+        )
         graph.add_step(
             name=self.name or "KafkaTarget",
             after=after,
@@ -1715,7 +1720,7 @@ class KafkaTarget(BaseStoreTarget):
             class_name="mlrun.datastore.storeytargets.KafkaStoreyTarget",
             columns=column_list,
             path=path,
-            attributes=self.attributes,
+            attributes=attributes,
         )
 
     def purge(self):

mlrun/datastore/utils.py

@@ -225,9 +225,11 @@ def validate_additional_filters(additional_filters):
 
 
 class KafkaParameters:
-    def __init__(self, kwargs: dict):
+    def __init__(self, kwargs: typing.Optional[dict] = None):
         import kafka
 
+        if kwargs is None:
+            kwargs = {}
         self._kafka = kafka
         self._kwargs = kwargs
         self._client_configs = {
@@ -245,17 +247,18 @@ class KafkaParameters:
             "sasl": "",
             "worker_allocation_mode": "",
         }
-        self._validate_keys()
-
-    def _validate_keys(self) -> None:
-        reference_dicts = (
+        self._reference_dicts = (
             self._custom_attributes,
             self._kafka.KafkaAdminClient.DEFAULT_CONFIG,
             self._kafka.KafkaProducer.DEFAULT_CONFIG,
             self._kafka.KafkaConsumer.DEFAULT_CONFIG,
         )
+
+        self._validate_keys()
+
+    def _validate_keys(self) -> None:
         for key in self._kwargs:
-            if all(key not in d for d in reference_dicts):
+            if all(key not in d for d in self._reference_dicts):
                 raise ValueError(
                     f"Key '{key}' not found in any of the Kafka reference dictionaries"
                 )
@@ -295,3 +298,10 @@ class KafkaParameters:
             res["password"] = pwd
             res["mechanism"] = self._kwargs.get("sasl_mechanism", "PLAIN")
         return res
+
+    def valid_entries_only(self, input_dict: dict) -> dict:
+        valid_keys = set()
+        for ref_dict in self._reference_dicts:
+            valid_keys.update(ref_dict.keys())
+        # Return a new dictionary with only valid keys
+        return {k: v for k, v in input_dict.items() if k in valid_keys}

mlrun/model_monitoring/applications/_application_steps.py

@@ -12,8 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import collections
 import json
 import traceback
+from collections import OrderedDict
+from datetime import datetime
 from typing import Any, Optional, Union
 
 import mlrun.common.schemas
@@ -105,6 +108,8 @@ class _PushToMonitoringWriter(StepToDict):
 
 
 class _PrepareMonitoringEvent(StepToDict):
+    MAX_MODEL_ENDPOINTS: int = 1500
+
     def __init__(self, context: GraphContext, application_name: str) -> None:
         """
         Class for preparing the application event for the application step.
@@ -114,7 +119,10 @@ class _PrepareMonitoringEvent(StepToDict):
         self.graph_context = context
         _ = self.graph_context.project_obj  # Ensure project exists
         self.application_name = application_name
-        self.model_endpoints: dict[str, mlrun.common.schemas.ModelEndpoint] = {}
+        self.model_endpoints: OrderedDict[str, mlrun.common.schemas.ModelEndpoint] = (
+            collections.OrderedDict()
+        )
+        self.feature_sets: dict[str, mlrun.common.schemas.FeatureSet] = {}
 
     def do(self, event: dict[str, Any]) -> MonitoringApplicationContext:
         """
@@ -123,16 +131,48 @@ class _PrepareMonitoringEvent(StepToDict):
         :param event: Application event.
         :return: Application context.
         """
+        endpoint_id = event.get(mm_constants.ApplicationEvent.ENDPOINT_ID)
+        endpoint_updated = datetime.fromisoformat(
+            event.get(mm_constants.ApplicationEvent.ENDPOINT_UPDATED)
+        )
+        if (
+            endpoint_id in self.model_endpoints
+            and endpoint_updated != self.model_endpoints[endpoint_id].metadata.updated
+        ):
+            logger.debug(
+                "Updated endpoint removing endpoint from cash",
+                new_updated=endpoint_updated.isoformat(),
+                old_updated=self.model_endpoints[
+                    endpoint_id
+                ].metadata.updated.isoformat(),
+            )
+            self.model_endpoints.pop(endpoint_id)
+
         application_context = MonitoringApplicationContext._from_graph_ctx(
             application_name=self.application_name,
             event=event,
             model_endpoint_dict=self.model_endpoints,
             graph_context=self.graph_context,
+            feature_sets_dict=self.feature_sets,
         )
 
         self.model_endpoints.setdefault(
             application_context.endpoint_id, application_context.model_endpoint
         )
+        self.feature_sets.setdefault(
+            application_context.endpoint_id, application_context.feature_set
+        )
+        # every used endpoint goes to first location allowing to pop last used:
+        self.model_endpoints.move_to_end(application_context.endpoint_id, last=False)
+        if len(self.model_endpoints) > self.MAX_MODEL_ENDPOINTS:
+            removed_endpoint_id, _ = self.model_endpoints.popitem(
+                last=True
+            )  # Removing the LRU endpoint
+            self.feature_sets.pop(removed_endpoint_id, None)
+            logger.debug(
+                "Exceeded maximum number of model endpoints removing the LRU from cash",
+                endpoint_id=removed_endpoint_id,
+            )
 
         return application_context
 

mlrun/model_monitoring/applications/context.py

@@ -28,7 +28,7 @@ import mlrun.serving
 import mlrun.utils
 from mlrun.artifacts import Artifact, DatasetArtifact, ModelArtifact, get_model
 from mlrun.common.model_monitoring.helpers import FeatureStats
-from mlrun.common.schemas import ModelEndpoint
+from mlrun.common.schemas import FeatureSet, ModelEndpoint
 from mlrun.model_monitoring.helpers import (
     calculate_inputs_statistics,
 )
@@ -59,6 +59,7 @@ class MonitoringApplicationContext:
         model_endpoint_dict: Optional[dict[str, ModelEndpoint]] = None,
         sample_df: Optional[pd.DataFrame] = None,
         feature_stats: Optional[FeatureStats] = None,
+        feature_sets_dict: Optional[dict[str, FeatureSet]] = None,
     ) -> None:
         """
         The :code:`MonitoringApplicationContext` object holds all the relevant information for the
@@ -77,6 +78,7 @@ class MonitoringApplicationContext:
         :param end_infer_time:          (pd.Timestamp) End time of the monitoring schedule.
         :param latest_request:          (pd.Timestamp) Timestamp of the latest request on this endpoint_id.
         :param endpoint_id:             (str) ID of the monitored model endpoint
+        :param feature_set:              (FeatureSet) the model endpoint feature set
         :param endpoint_name:           (str) Name of the monitored model endpoint
         :param output_stream_uri:       (str) URI of the output stream for results
         :param model_endpoint:          (ModelEndpoint) The model endpoint object.
@@ -123,6 +125,9 @@ class MonitoringApplicationContext:
         self._model_endpoint: Optional[ModelEndpoint] = (
             model_endpoint_dict.get(self.endpoint_id) if model_endpoint_dict else None
         )
+        self._feature_set: Optional[FeatureSet] = (
+            feature_sets_dict.get(self.endpoint_id) if feature_sets_dict else None
+        )
 
     @classmethod
     def _from_ml_ctx(
@@ -165,6 +170,7 @@ class MonitoringApplicationContext:
         model_endpoint_dict: Optional[dict[str, ModelEndpoint]] = None,
         sample_df: Optional[pd.DataFrame] = None,
         feature_stats: Optional[FeatureStats] = None,
+        feature_sets_dict: Optional[dict[str, FeatureSet]] = None,
     ) -> "MonitoringApplicationContext":
         nuclio_logger = graph_context.logger
         artifacts_logger = graph_context.project_obj
@@ -183,6 +189,7 @@ class MonitoringApplicationContext:
             artifacts_logger=artifacts_logger,
             sample_df=sample_df,
             feature_stats=feature_stats,
+            feature_sets_dict=feature_sets_dict,
         )
 
     def _get_default_labels(self) -> dict[str, str]:
@@ -201,9 +208,7 @@ class MonitoringApplicationContext:
     @property
     def sample_df(self) -> pd.DataFrame:
         if self._sample_df is None:
-            feature_set = fstore.get_feature_set(
-                self.model_endpoint.spec.monitoring_feature_set_uri
-            )
+            feature_set = self.feature_set
             features = [f"{feature_set.metadata.name}.*"]
             vector = fstore.FeatureVector(
                 name=f"{self.endpoint_id}_vector",
@@ -224,6 +229,14 @@ class MonitoringApplicationContext:
     @property
     def model_endpoint(self) -> ModelEndpoint:
         if not self._model_endpoint:
+            if self.endpoint_name is None or self.endpoint_id is None:
+                raise mlrun.errors.MLRunValueError(
+                    "You have NOT provided the model endpoint's name and ID: "
+                    f"`endpoint_name`={self.endpoint_name} and `endpoint_id`={self.endpoint_id}, "
+                    "but you have tried to access `monitoring_context.model_endpoint` "
+                    "directly or indirectly in your application. You can either provide them, "
+                    "or adapt the application's logic to not access the model endpoint."
+                )
             self._model_endpoint = mlrun.db.get_run_db().get_model_endpoint(
                 name=self.endpoint_name,
                 project=self.project_name,
@@ -232,6 +245,14 @@ class MonitoringApplicationContext:
             )
         return self._model_endpoint
 
+    @property
+    def feature_set(self) -> FeatureSet:
+        if not self._feature_set and self.model_endpoint:
+            self._feature_set = fstore.get_feature_set(
+                self.model_endpoint.spec.monitoring_feature_set_uri
+            )
+        return self._feature_set
+
     @property
     def feature_stats(self) -> FeatureStats:
         if not self._feature_stats:

mlrun/model_monitoring/controller.py

@@ -32,6 +32,7 @@ import mlrun.model_monitoring.helpers
 from mlrun.common.schemas import EndpointType
 from mlrun.common.schemas.model_monitoring.constants import (
     ControllerEvent,
+    ControllerEventEndpointPolicy,
     ControllerEventKind,
 )
 from mlrun.errors import err_to_str
@@ -40,6 +41,7 @@ from mlrun.model_monitoring.helpers import batch_dict2timedelta
 from mlrun.utils import datetime_now, logger
 
 _SECONDS_IN_DAY = int(datetime.timedelta(days=1).total_seconds())
+_SECONDS_IN_MINUTE = 60
 
 
 class _Interval(NamedTuple):
@@ -241,6 +243,8 @@ class MonitoringApplicationController:
     Note that the MonitoringApplicationController object requires access keys along with valid project configurations.
     """
 
+    _MAX_OPEN_WINDOWS_ALLOWED = 5
+
     def __init__(self) -> None:
         """Initialize Monitoring Application Controller"""
         self.project = cast(str, mlrun.mlconf.default_project)
@@ -264,10 +268,24 @@ class MonitoringApplicationController:
             access_key = mlrun.mlconf.get_v3io_access_key()
         return access_key
 
-    @staticmethod
     def _should_monitor_endpoint(
-        endpoint: mlrun.common.schemas.ModelEndpoint, application_names: set
+        self,
+        endpoint: mlrun.common.schemas.ModelEndpoint,
+        application_names: set,
+        base_period_minutes: int,
     ) -> bool:
+        """
+        checks if there is a need to monitor the given endpoint, we should monitor endpoint if it stands in the
+        next conditions:
+            1.  monitoring_mode is enabled
+            2.  first request exists
+            3.  last request exists
+            4.  endpoint_type is not ROUTER
+        if the four above conditions apply we require one of the three conditions to monitor:
+            1.  never monitored the one of the endpoint applications meaning min_last_analyzed is None
+            2.  last request has a higher timestamp than the min_last_analyzed timestamp
+            3.  We didn't analyze one of the application for over than _MAX_OPEN_WINDOWS_ALLOWED windows
+        """
         if (
             # Is the model endpoint monitored?
             endpoint.status.monitoring_mode == mm_constants.ModelMonitoringMode.enabled
@@ -282,12 +300,16 @@ class MonitoringApplicationController:
                 project=endpoint.metadata.project,
                 endpoint_id=endpoint.metadata.uid,
             ) as batch_window_generator:
+                base_period_seconds = base_period_minutes * _SECONDS_IN_MINUTE
                 if application_names != batch_window_generator.get_application_list():
                     return True
                 elif (
                     not batch_window_generator.get_min_last_analyzed()
                     or batch_window_generator.get_min_last_analyzed()
                     <= int(endpoint.status.last_request.timestamp())
+                    or mlrun.utils.datetime_now().timestamp()
+                    - batch_window_generator.get_min_last_analyzed()
+                    >= self._MAX_OPEN_WINDOWS_ALLOWED * base_period_seconds
                 ):
                     return True
                 else:
@@ -351,7 +373,7 @@ class MonitoringApplicationController:
             endpoint_id = event[ControllerEvent.ENDPOINT_ID]
             endpoint_name = event[ControllerEvent.ENDPOINT_NAME]
             applications_names = event[ControllerEvent.ENDPOINT_POLICY][
-                "monitoring_applications"
+                ControllerEventEndpointPolicy.MONITORING_APPLICATIONS
             ]
 
             not_batch_endpoint = (
@@ -410,8 +432,13 @@ class MonitoringApplicationController:
                                 project=project_name,
                                 applications_names=[application],
                                 model_monitoring_access_key=self.model_monitoring_access_key,
+                                endpoint_updated=event[ControllerEvent.ENDPOINT_POLICY][
+                                    ControllerEventEndpointPolicy.ENDPOINT_UPDATED
+                                ],
                             )
-                base_period = event[ControllerEvent.ENDPOINT_POLICY]["base_period"]
+                base_period = event[ControllerEvent.ENDPOINT_POLICY][
+                    ControllerEventEndpointPolicy.BASE_PERIOD
+                ]
                 current_time = mlrun.utils.datetime_now()
                 if (
                     current_time.timestamp()
@@ -463,6 +490,7 @@ class MonitoringApplicationController:
         project: str,
         applications_names: list[str],
         model_monitoring_access_key: str,
+        endpoint_updated: str,
     ):
         """
         Pushes data to multiple stream applications.
@@ -473,7 +501,7 @@ class MonitoringApplicationController:
         :param project: mlrun               Project name.
         :param applications_names:          List of application names to which data will be pushed.
         :param model_monitoring_access_key: Access key to apply the model monitoring process.
-
+        :param endpoint_updated:            str isoformet for the timestamp the model endpoint was updated
         """
         data = {
             mm_constants.ApplicationEvent.START_INFER_TIME: start_infer_time.isoformat(
@@ -484,6 +512,7 @@ class MonitoringApplicationController:
             ),
             mm_constants.ApplicationEvent.ENDPOINT_ID: endpoint_id,
             mm_constants.ApplicationEvent.ENDPOINT_NAME: endpoint_name,
+            mm_constants.ApplicationEvent.ENDPOINT_UPDATED: endpoint_updated,
         }
         for app_name in applications_names:
             data.update({mm_constants.ApplicationEvent.APPLICATION_NAME: app_name})
@@ -536,8 +565,8 @@ class MonitoringApplicationController:
             logger.info("No monitoring functions found", project=self.project)
             return
         policy = {
-            "monitoring_applications": applications_names,
-            "base_period": int(
+            ControllerEventEndpointPolicy.MONITORING_APPLICATIONS: applications_names,
+            ControllerEventEndpointPolicy.BASE_PERIOD: int(
                 batch_dict2timedelta(
                     json.loads(
                         cast(
@@ -546,7 +575,7 @@ class MonitoringApplicationController:
                         )
                     )
                 ).total_seconds()
-                // 60
+                // _SECONDS_IN_MINUTE
             ),
         }
         with concurrent.futures.ThreadPoolExecutor(
@@ -585,7 +614,9 @@ class MonitoringApplicationController:
         v3io_access_key: str,
     ) -> None:
         if MonitoringApplicationController._should_monitor_endpoint(
-            endpoint, set(applications_names)
+            endpoint,
+            set(applications_names),
+            policy.get(ControllerEventEndpointPolicy.BASE_PERIOD, 10),
         ):
             logger.info(
                 "Regular event is being pushed to controller stream for model endpoint",
@@ -601,6 +632,9 @@ class MonitoringApplicationController:
                 feature_set_uri=endpoint.spec.monitoring_feature_set_uri,
                 endpoint_policy=json.dumps(policy),
             )
+            policy[ControllerEventEndpointPolicy.ENDPOINT_UPDATED] = (
+                endpoint.metadata.updated.isoformat()
+            )
             MonitoringApplicationController.push_to_controller_stream(
                 kind=mm_constants.ControllerEventKind.REGULAR_EVENT,
                 project=endpoint.metadata.project,

mlrun/model_monitoring/db/tsdb/__init__.py

@@ -92,7 +92,7 @@ def get_tsdb_connector(
     if isinstance(profile, mlrun.datastore.datastore_profile.DatastoreProfileV3io):
         tsdb_connector_type = mlrun.common.schemas.model_monitoring.TSDBTarget.V3IO_TSDB
     elif isinstance(
-        profile, mlrun.datastore.datastore_profile.TDEngineDatastoreProfile
+        profile, mlrun.datastore.datastore_profile.DatastoreProfileTDEngine
     ):
         tsdb_connector_type = mlrun.common.schemas.model_monitoring.TSDBTarget.TDEngine
     else:

mlrun/model_monitoring/db/tsdb/v3io/v3io_connector.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 asyncio
 import math
 from datetime import datetime, timedelta, timezone
 from io import StringIO
@@ -150,24 +149,32 @@ class V3IOTSDBConnector(TSDBConnector):
 
     def create_tables(self) -> None:
         """
-        Create the tables using the TSDB connector. The tables are being created in the V3IO TSDB and include:
+        Create the tables using the TSDB connector. These are the tables that are stored in the V3IO TSDB:
         - app_results: a detailed result that includes status, kind, extra data, etc.
         - metrics: a basic key value that represents a single numeric metric.
-        Note that the predictions table is automatically created by the model monitoring stream pod.
+        - events: A statistics table that includes pre-aggregated metrics (such as average latency over the
+        last 5 minutes) and data samples
+        - predictions: a detailed prediction that includes latency, request timestamp, etc. This table also
+        includes pre-aggregated operations such as count and average on 1 minute granularity.
+        - errors: a detailed error that includes error desc, error type, etc.
+
         """
-        application_tables = [
-            mm_schemas.V3IOTSDBTables.APP_RESULTS,
-            mm_schemas.V3IOTSDBTables.METRICS,
-        ]
-        for table_name in application_tables:
+
+        default_configurations = {
+            "backend": _TSDB_BE,
+            "if_exists": v3io_frames.IGNORE,
+            "rate": _TSDB_RATE,
+        }
+
+        for table_name in self.tables:
+            default_configurations["table"] = self.tables[table_name]
+            if table_name == mm_schemas.V3IOTSDBTables.PREDICTIONS:
+                default_configurations["aggregates"] = "count,avg"
+                default_configurations["aggregation_granularity"] = "1m"
+            elif table_name == mm_schemas.V3IOTSDBTables.EVENTS:
+                default_configurations["rate"] = "10/m"
             logger.info("Creating table in V3IO TSDB", table_name=table_name)
-            table = self.tables[table_name]
-            self.frames_client.create(
-                backend=_TSDB_BE,
-                table=table,
-                if_exists=v3io_frames.IGNORE,
-                rate=_TSDB_RATE,
-            )
+            self.frames_client.create(**default_configurations)
 
     def apply_monitoring_stream_steps(
         self,
@@ -228,7 +235,6 @@ class V3IOTSDBConnector(TSDBConnector):
             name="tsdb_predictions",
             after="FilterNOP",
             path=f"{self.container}/{self.tables[mm_schemas.V3IOTSDBTables.PREDICTIONS]}",
-            rate="1/s",
             time_col=mm_schemas.EventFieldType.TIMESTAMP,
             container=self.container,
             v3io_frames=self.v3io_framesd,
@@ -241,8 +247,6 @@ class V3IOTSDBConnector(TSDBConnector):
             index_cols=[
                 mm_schemas.EventFieldType.ENDPOINT_ID,
             ],
-            aggr="count,avg",
-            aggr_granularity="1m",
             max_events=tsdb_batching_max_events,
             flush_after_seconds=tsdb_batching_timeout_secs,
             key=mm_schemas.EventFieldType.ENDPOINT_ID,
@@ -281,7 +285,6 @@ class V3IOTSDBConnector(TSDBConnector):
                 name=name,
                 after=after,
                 path=f"{self.container}/{self.tables[mm_schemas.V3IOTSDBTables.EVENTS]}",
-                rate="10/m",
                 time_col=mm_schemas.EventFieldType.TIMESTAMP,
                 container=self.container,
                 v3io_frames=self.v3io_framesd,
@@ -345,7 +348,6 @@ class V3IOTSDBConnector(TSDBConnector):
             name="tsdb_error",
             after="error_extractor",
             path=f"{self.container}/{self.tables[mm_schemas.FileTargetKind.ERRORS]}",
-            rate="1/s",
             time_col=mm_schemas.EventFieldType.TIMESTAMP,
             container=self.container,
             v3io_frames=self.v3io_framesd,
@@ -772,6 +774,9 @@ class V3IOTSDBConnector(TSDBConnector):
         end: Union[datetime, str],
         aggregation_window: Optional[str] = None,
         agg_funcs: Optional[list[str]] = None,
+        limit: Optional[
+            int
+        ] = None,  # no effect, just for compatibility with the abstract method
     ) -> Union[
         mm_schemas.ModelEndpointMonitoringMetricNoData,
         mm_schemas.ModelEndpointMonitoringMetricValues,
@@ -825,6 +830,7 @@ class V3IOTSDBConnector(TSDBConnector):
     ) -> 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,
@@ -1018,7 +1024,7 @@ class V3IOTSDBConnector(TSDBConnector):
         :param model_endpoint_objects: A list of `ModelEndpoint` objects that will
                                         be filled with the relevant basic metrics.
         :param project:                The name of the project.
-        :param run_in_threadpool:      A function that runs another function in a thread pool.
+        :param run_in_threadpool:      Has no effect.
 
         :return: A list of `ModelEndpointMonitoringMetric` objects.
         """
@@ -1030,35 +1036,10 @@ class V3IOTSDBConnector(TSDBConnector):
             uids.append(uid)
             model_endpoint_objects_by_uid[uid] = model_endpoint_object
 
-        coroutines = [
-            run_in_threadpool(
-                self.get_error_count,
-                endpoint_ids=uids,
-                get_raw=True,
-            ),
-            run_in_threadpool(
-                self.get_last_request,
-                endpoint_ids=uids,
-                get_raw=True,
-            ),
-            run_in_threadpool(
-                self.get_avg_latency,
-                endpoint_ids=uids,
-                get_raw=True,
-            ),
-            run_in_threadpool(
-                self.get_drift_status,
-                endpoint_ids=uids,
-                get_raw=True,
-            ),
-        ]
-
-        (
-            error_count_res,
-            last_request_res,
-            avg_latency_res,
-            drift_status_res,
-        ) = await asyncio.gather(*coroutines)
+        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)
 
         def add_metric(
             metric: str,

mlrun/projects/project.py

@@ -3484,7 +3484,7 @@ class MlrunProject(ModelObj):
                 "Remote repo is not defined, use .create_remote() + push()"
             )
 
-        if engine not in ["remote"] and not schedule:
+        if (engine is None or not engine.startswith("remote")) and not schedule:
             # For remote/scheduled runs there is no need to sync functions as they can be loaded dynamically during run
             self.sync_functions(always=sync, silent=True)
             if not self.spec._function_objects:
@@ -3692,13 +3692,13 @@ class MlrunProject(ModelObj):
             import mlrun
             from mlrun.datastore.datastore_profile import (
                 DatastoreProfileKafkaSource,
-                TDEngineDatastoreProfile,
+                DatastoreProfileTDEngine,
             )
 
             project = mlrun.get_or_create_project("mm-infra-setup")
 
             # Create and register TSDB profile
-            tsdb_profile = TDEngineDatastoreProfile(
+            tsdb_profile = DatastoreProfileTDEngine(
                 name="my-tdengine",
                 host="<tdengine-server-ip-address>",
                 port=6041,
@@ -3750,7 +3750,7 @@ class MlrunProject(ModelObj):
                                           monitoring. The supported profiles are:
 
                                           * :py:class:`~mlrun.datastore.datastore_profile.DatastoreProfileV3io`
-                                          * :py:class:`~mlrun.datastore.datastore_profile.TDEngineDatastoreProfile`
+                                          * :py:class:`~mlrun.datastore.datastore_profile.DatastoreProfileTDEngine`
 
                                           You need to register one of them, and pass the profile's name.
         :param stream_profile_name:       The datastore profile name of the stream to be used in model monitoring.

mlrun/utils/helpers.py

@@ -1371,6 +1371,18 @@ def has_timezone(timestamp):
         return False
 
 
+def format_datetime(dt: datetime) -> str:
+    # If the datetime is naive
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+
+    # TODO: Once Python 3.12 is the minimal version, use %:z to format the timezone offset with a colon
+    formatted_time = dt.strftime("%Y-%m-%d %H:%M:%S.%f%z")
+
+    # For versions earlier than Python 3.12, we manually insert the colon in the timezone offset
+    return formatted_time[:-2] + ":" + formatted_time[-2:]
+
+
 def as_list(element: Any) -> list[Any]:
     return element if isinstance(element, list) else [element]
 

mlrun/utils/version/version.json

@@ -1,4 +1,4 @@
 {
-  "git_commit": "18a4adfd7aa39a10127ad6a505bce173beab12a4",
-  "version": "1.8.0-rc41"
+  "git_commit": "3a6636b3c157e7b97066aafb130368828f360190",
+  "version": "1.8.0-rc42"
 }

{mlrun-1.8.0rc41.dist-info → mlrun-1.8.0rc42.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mlrun
-Version: 1.8.0rc41
+Version: 1.8.0rc42
 Summary: Tracking and config of machine learning runs
 Home-page: https://github.com/mlrun/mlrun
 Author: Yaron Haviv

{mlrun-1.8.0rc41.dist-info → mlrun-1.8.0rc42.dist-info}/RECORD

@@ -73,7 +73,7 @@ mlrun/common/schemas/serving.py,sha256=81ZxlDHP1fm9VPmXZGkjZj2n6cVRmqEN478hsmvv5
 mlrun/common/schemas/tag.py,sha256=HRZi5QZ4vVGaCr2AMk9eJgcNiAIXmH4YDc8a4fvF770,893
 mlrun/common/schemas/workflow.py,sha256=6u9niXfXpV-_c2rZL97gFIdAnOfM5WK-OCbrM5Kk34s,2108
 mlrun/common/schemas/model_monitoring/__init__.py,sha256=SxHG-GIdcTEuFxpKzkUdT9zKaU5Xqz9qF1uCwXvZ2z8,1709
-mlrun/common/schemas/model_monitoring/constants.py,sha256=yXSftuCZVSdaVkKFL3PTpSkjiFs1H2QCRN0NWCk8JLs,12143
+mlrun/common/schemas/model_monitoring/constants.py,sha256=YhbybKq2y8wKG9XZGz9sO1SrhDRIF9bF2m5-mbzc6AI,12428
 mlrun/common/schemas/model_monitoring/grafana.py,sha256=THQlLfPBevBksta8p5OaIsBaJtsNSXexLvHrDxOaVns,2095
 mlrun/common/schemas/model_monitoring/model_endpoints.py,sha256=O0i-pvzcXJVgf9E_tNcudDTa1xLaJchzPGfZZ8MNdD4,11482
 mlrun/data_types/__init__.py,sha256=unRo9GGwCmj0hBKBRsXJ2P4BzpQaddlQTvIrVQaKluI,984
@@ -84,24 +84,24 @@ mlrun/data_types/to_pandas.py,sha256=KOy0FLXPJirsgH6szcC5BI6t70yVDCjuo6LmuYHNTuI
 mlrun/datastore/__init__.py,sha256=81ulmQnRk1ENvwYOdetxqsLnr2gYVtW-KsvF-tY1Jxk,5783
 mlrun/datastore/alibaba_oss.py,sha256=k-OHVe08HjMewlkpsT657CbOiVFAfSq9_EqhCE-k86s,4940
 mlrun/datastore/azure_blob.py,sha256=SzAcHYSXkm8Zpopz2Ea-rWVClH0URocUazcNK04S9W0,12776
-mlrun/datastore/base.py,sha256=9G1euAK6Bn3nRzjEQkUl8iEa7dukGdAcS1o6pb8OHUg,25996
+mlrun/datastore/base.py,sha256=9R3lwB_L4hv5WW2q24WS62_KTh-wO4UG6pwzISZU6bM,26231
 mlrun/datastore/datastore.py,sha256=frUYYP4i8ZmnY8GNXSgN_3x_exRgRPfxrCtAGEUifEU,9478
-mlrun/datastore/datastore_profile.py,sha256=Ybh_75jnkwuyAXOIFc_Wm-3XxOpEovlQNZ2R0OfniBg,23860
+mlrun/datastore/datastore_profile.py,sha256=RRpb5TfTDBOnZQGSr6Zlmi1QSPHRDssBlWGLIpNBHM0,23860
 mlrun/datastore/dbfs_store.py,sha256=QkDRzwFnvm7CgEg4NuGxes6tBgKDyhX0CiBUvK8c9pk,6568
 mlrun/datastore/filestore.py,sha256=OcykjzhbUAZ6_Cb9bGAXRL2ngsOpxXSb4rR0lyogZtM,3773
 mlrun/datastore/google_cloud_storage.py,sha256=MnToY6irdhBZ8Wcapqnr1Yq2724LAh2uPO7MAtdWfUY,8716
 mlrun/datastore/hdfs.py,sha256=NhxvPojQQDEm0xzB6RcvnD4uLZOxfHHKYWV4gwzG7D4,1928
 mlrun/datastore/inmem.py,sha256=IsM83nn-3CqmGdLzim7i9ZmJwG6ZGhBZGN6_hszWZnE,2951
 mlrun/datastore/redis.py,sha256=QeNMkSz3zQXiXZhFUZcEtViqqbUysGJditbqe5M-J48,5682
-mlrun/datastore/s3.py,sha256=GjJnQLrigCqU9_ukRWv1pKhxfUtrMGFBUp6fmpPXUCY,9224
+mlrun/datastore/s3.py,sha256=lD4Fs69rwMeISovZzOxRdz_z9FuffysTdjJA9ybdnLA,9262
 mlrun/datastore/snowflake_utils.py,sha256=Wohvnlmq8j1d98RCaknll-iWdZZpSlCrKhUOEy0_-CA,1483
 mlrun/datastore/sources.py,sha256=KQp1nNN7TcaewFm3It03H1R28uzlWGZDDHJyqiT--vw,49062
 mlrun/datastore/spark_udf.py,sha256=NnnB3DZxZb-rqpRy7b-NC7QWXuuqFn3XkBDc86tU4mQ,1498
 mlrun/datastore/spark_utils.py,sha256=_AsVoU5Ix_-W7Gyq8io8V-2GTk0m8THJNDP3WGGaWJY,2865
 mlrun/datastore/store_resources.py,sha256=PFOMrZ6KH6hBOb0PiO-cHx_kv0UpHu5P2t8_mrR-lS4,6842
-mlrun/datastore/storeytargets.py,sha256=PnlEMc4iD_0zhZZYZtEISPoGIgbsEtZNUvZ7a7ALlXo,6459
-mlrun/datastore/targets.py,sha256=QiEK-mHmUt2qnS2yaBSSKgk8CKqsGU-JoQ9kHoW1bvE,80759
-mlrun/datastore/utils.py,sha256=L51jAKsIqnl5_Q_x4sI37TbGK2JCqWE9NiS5nWF3bts,10207
+mlrun/datastore/storeytargets.py,sha256=g5zAdizdFkcESoVGxbKWC11ZiXFgM77UL4642G32JaU,6459
+mlrun/datastore/targets.py,sha256=eBp2ECV1Wk6D1X7kYhaneiVfsGW_TyKkaKdBXYgvWVM,81018
+mlrun/datastore/utils.py,sha256=CbKbDI6CdFRCqyAXe-jykVvN_GH6R0JkxIQFAogR2GA,10604
 mlrun/datastore/v3io.py,sha256=QSYBORRLcJTeM9mt0EaWzyLcdmzrPkqrF7k5uLTam5U,8209
 mlrun/datastore/vectorstore.py,sha256=k-yom5gfw20hnVG0Rg7aBEehuXwvAloZwn0cx0VGals,11708
 mlrun/datastore/wasbfs/__init__.py,sha256=s5Ul-0kAhYqFjKDR2X0O2vDGDbLQQduElb32Ev56Te4,1343
@@ -218,16 +218,16 @@ mlrun/launcher/local.py,sha256=775HY-8S9LFUX5ubGXrLO0N1lVh8bn-DHFmNYuNqQPA,11451
 mlrun/launcher/remote.py,sha256=rLJW4UAnUT5iUb4BsGBOAV3K4R29a0X4lFtRkVKlyYU,7709
 mlrun/model_monitoring/__init__.py,sha256=ELy7njEtZnz09Dc6PGZSFFEGtnwI15bJNWM3Pj4_YIs,753
 mlrun/model_monitoring/api.py,sha256=nkNlBq_X12tGgs4rbVutzq-ce9P49zAyg_hvffwmz7I,27544
-mlrun/model_monitoring/controller.py,sha256=Kml08GtbNhln_r9urJxxJxTtefcgXwdRQLu4v5-L3Bg,29814
+mlrun/model_monitoring/controller.py,sha256=ulrIjjx5Gf8Uwtk9hmxSnkP5fIXkQgFG7PsVkncaUpE,31756
 mlrun/model_monitoring/features_drift_table.py,sha256=c6GpKtpOJbuT1u5uMWDL_S-6N4YPOmlktWMqPme3KFY,25308
 mlrun/model_monitoring/helpers.py,sha256=Q4vcc7x41lCJdFQIE8UFPY0WIQ8a-4tSGhziMA4ib4w,22003
 mlrun/model_monitoring/stream_processing.py,sha256=4M0H4txMlsC2Q5iKTPp992KWoNPAJjPHj9rqWhXbl8w,33321
 mlrun/model_monitoring/tracking_policy.py,sha256=PBIGrUYWrwcE5gwXupBIVzOb0QRRwPJsgQm_yLGQxB4,5595
 mlrun/model_monitoring/writer.py,sha256=vbL7bqTyNu8q4bNcebX72sUMybVDAoTWg-CXq4fov3Y,8429
 mlrun/model_monitoring/applications/__init__.py,sha256=xDBxkBjl-whHSG_4t1mLkxiypLH-fzn8TmAW9Mjo2uI,759
-mlrun/model_monitoring/applications/_application_steps.py,sha256=97taCEkfGx-QO-gD9uKnRF1PDIxQhY7sjPg85GxgIpA,6628
+mlrun/model_monitoring/applications/_application_steps.py,sha256=PxULZznKW66Oq-fKaraOAbsTuGnV0zgXh6_91wX3KUo,8367
 mlrun/model_monitoring/applications/base.py,sha256=7XL12idItWkoE3CJ_48F6cwVx5pJH3bgfG92hb8LcN8,24872
-mlrun/model_monitoring/applications/context.py,sha256=xqbKS61iXE6jBekyW8zjo_E3lxe2D8VepuXG_BA5y2k,14931
+mlrun/model_monitoring/applications/context.py,sha256=Wou9lviSETjEqyMoIAi0Ko58luRkx0uy3ZDUVyRheNA,16144
 mlrun/model_monitoring/applications/histogram_data_drift.py,sha256=RnrSRkNM5WYOjhiEIdkmYmUDGNnuRL8xtV-CpJ83r1U,15233
 mlrun/model_monitoring/applications/results.py,sha256=_qmj6TWT0SR2bi7gUyRKBU418eGgGoLW2_hTJ7S-ock,5782
 mlrun/model_monitoring/applications/evidently/__init__.py,sha256=-DqdPnBSrjZhFvKOu_Ie3MiFvlur9sPTZpZ1u0_1AE8,690
@@ -235,7 +235,7 @@ mlrun/model_monitoring/applications/evidently/base.py,sha256=C8402vQJH7jmY-i49Dn
 mlrun/model_monitoring/db/__init__.py,sha256=r47xPGZpIfMuv8J3PQCZTSqVPMhUta4sSJCZFKcS7FM,644
 mlrun/model_monitoring/db/_schedules.py,sha256=AKyCJBAt0opNE3K3pg2TjCoD_afk1LKw5TY88rLQ2VA,6097
 mlrun/model_monitoring/db/_stats.py,sha256=VVMWLMqG3Us3ozBkLaokJF22Ewv8WKmVE1-OvS_g9vA,6943
-mlrun/model_monitoring/db/tsdb/__init__.py,sha256=GRaQ9b4zNnbJIugRUwR2t5B1nNTtvPPf9RdNLTHRLKA,4645
+mlrun/model_monitoring/db/tsdb/__init__.py,sha256=4S86V_Ot_skE16SLkw0WwsaAUB0ECH6SoJdp-TIu6s8,4645
 mlrun/model_monitoring/db/tsdb/base.py,sha256=ayWMWmpm35mDVTEP9AvU-P5_5rBAkBO1hULajkgt0Vw,26995
 mlrun/model_monitoring/db/tsdb/helpers.py,sha256=0oUXc4aUkYtP2SGP6jTb3uPPKImIUsVsrb9otX9a7O4,1189
 mlrun/model_monitoring/db/tsdb/tdengine/__init__.py,sha256=vgBdsKaXUURKqIf3M0y4sRatmSVA4CQiJs7J5dcVBkQ,620
@@ -244,7 +244,7 @@ mlrun/model_monitoring/db/tsdb/tdengine/stream_graph_steps.py,sha256=Uadj0UvAmln
 mlrun/model_monitoring/db/tsdb/tdengine/tdengine_connector.py,sha256=wjoxlNUFoHgMiG7yAMNsk1_1scca9EmMlM2Jp4Qv00c,37796
 mlrun/model_monitoring/db/tsdb/v3io/__init__.py,sha256=aL3bfmQsUQ-sbvKGdNihFj8gLCK3mSys0qDcXtYOwgc,616
 mlrun/model_monitoring/db/tsdb/v3io/stream_graph_steps.py,sha256=_-zo9relCDtjGgievxAcAP9gVN9nDWs8BzGtFwTjb9M,6284
-mlrun/model_monitoring/db/tsdb/v3io/v3io_connector.py,sha256=8gzw69Y9mKFOAW1-_o1gr0SXgBbY9QhOhWdMUR2MdqM,42633
+mlrun/model_monitoring/db/tsdb/v3io/v3io_connector.py,sha256=oIGkdjp9PH-giOLzeRwzM3KIHCkSWOAgZN92DiWoWBQ,42635
 mlrun/model_monitoring/metrics/__init__.py,sha256=6CsTXAxeLbbf8yfCADTaxmiavqwrLEdYFJ-qc5kgDAY,569
 mlrun/model_monitoring/metrics/histogram_distance.py,sha256=E9_WIl2vd6qNvoHVHoFcnuQk3ekbFWOdi8aU7sHrfk4,4724
 mlrun/package/__init__.py,sha256=v7VDyK9kDOOuDvFo4oiGV2fx-vM1KL7fdN9pGLakhUQ,7008
@@ -269,7 +269,7 @@ mlrun/platforms/iguazio.py,sha256=6VBTq8eQ3mzT96tzjYhAtcMQ2VjF4x8LpIPW5DAcX2Q,13
 mlrun/projects/__init__.py,sha256=0Krf0WIKfnZa71WthYOg0SoaTodGg3sV_hK3f_OlTPI,1220
 mlrun/projects/operations.py,sha256=TzPbTYBgmYrjxTKP_wOtBJYFFFwDCQtaVvF1Snr0TfM,20029
 mlrun/projects/pipelines.py,sha256=wud7ezeEmhIJvfYE_wzQbA4ygEfGXHtbOtoOpan6poY,48556
-mlrun/projects/project.py,sha256=md2ieQ0gmsVaRj0urWax0aFld88cIF-9r0JIMgmXiC8,235111
+mlrun/projects/project.py,sha256=Xf1dHTJ5zkxxh9e8ZyuMRz0WtfQp06Ympc1r3Edv-tk,235138
 mlrun/runtimes/__init__.py,sha256=J9Sy2HiyMlztNv6VUurMzF5H2XzttNil8nRsWDsqLyg,8923
 mlrun/runtimes/base.py,sha256=EL14Kmc1vWEjnBPJwLj5hHC6CtRAQHJLmohCD3sFEHo,37855
 mlrun/runtimes/daskjob.py,sha256=JwuGvOiPsxEDHHMMUS4Oie4hLlYYIZwihAl6DjroTY0,19521
@@ -320,7 +320,7 @@ mlrun/utils/azure_vault.py,sha256=IEFizrDGDbAaoWwDr1WoA88S_EZ0T--vjYtY-i0cvYQ,34
 mlrun/utils/clones.py,sha256=yXOeuLtgIiKZdmjeKK0Z_vIrH19ds5JuoJaCeDjhwOo,7516
 mlrun/utils/condition_evaluator.py,sha256=-nGfRmZzivn01rHTroiGY4rqEv8T1irMyhzxEei-sKc,1897
 mlrun/utils/db.py,sha256=blQgkWMfFH9lcN4sgJQcPQgEETz2Dl_zwbVA0SslpFg,2186
-mlrun/utils/helpers.py,sha256=ws-4ekIh2PvwO6n3-3_jm9b9RDAfSGqxC3IIiqqhnlk,73926
+mlrun/utils/helpers.py,sha256=OCX51Gn7rrKPpvob_lUnyfs1lFhVHtlzSYKHXAqJJ0Q,74393
 mlrun/utils/http.py,sha256=t6FrXQstZm9xVVjxqIGiLzrwZNCR4CSienSOuVgNIcI,8706
 mlrun/utils/logger.py,sha256=RG0m1rx6gfkJ-2C1r_p41MMpPiaDYqaYM2lYHDlNZEU,14767
 mlrun/utils/regex.py,sha256=jbR7IiOp6OO0mg9Fl_cVZCpWb9fL9nTPONCUxCDNWXg,5201
@@ -339,11 +339,11 @@ mlrun/utils/notifications/notification/mail.py,sha256=ZyJ3eqd8simxffQmXzqd3bgbAq
 mlrun/utils/notifications/notification/slack.py,sha256=eQvmctTh6wIG5xVOesLLV9S1-UUCu5UEQ9JIJOor3ts,7183
 mlrun/utils/notifications/notification/webhook.py,sha256=NeyIMSBojjjTJaUHmPbxMByp34GxYkl1-16NqzU27fU,4943
 mlrun/utils/version/__init__.py,sha256=7kkrB7hEZ3cLXoWj1kPoDwo4MaswsI2JVOBpbKgPAgc,614
-mlrun/utils/version/version.json,sha256=ixZhSkY3aQXk61oqGZn9xgYm6Aj1zyZNZQOWMEPTPtI,89
+mlrun/utils/version/version.json,sha256=65OWSZpvM9Y3MGeASH_-mtvz_E1p9viDfjuw4z9-CS4,89
 mlrun/utils/version/version.py,sha256=eEW0tqIAkU9Xifxv8Z9_qsYnNhn3YH7NRAfM-pPLt1g,1878
-mlrun-1.8.0rc41.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-mlrun-1.8.0rc41.dist-info/METADATA,sha256=UVLiV1nBd9z2-TfLSnNVUgKVxFlFyrcA1rZiwyTNi8M,25986
-mlrun-1.8.0rc41.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-mlrun-1.8.0rc41.dist-info/entry_points.txt,sha256=1Owd16eAclD5pfRCoJpYC2ZJSyGNTtUr0nCELMioMmU,46
-mlrun-1.8.0rc41.dist-info/top_level.txt,sha256=NObLzw3maSF9wVrgSeYBv-fgnHkAJ1kEkh12DLdd5KM,6
-mlrun-1.8.0rc41.dist-info/RECORD,,
+mlrun-1.8.0rc42.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+mlrun-1.8.0rc42.dist-info/METADATA,sha256=J_7vhfXaVJiBb-XcTJ8hrSXsqqjizBM8HNBC5vNct2w,25986
+mlrun-1.8.0rc42.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+mlrun-1.8.0rc42.dist-info/entry_points.txt,sha256=1Owd16eAclD5pfRCoJpYC2ZJSyGNTtUr0nCELMioMmU,46
+mlrun-1.8.0rc42.dist-info/top_level.txt,sha256=NObLzw3maSF9wVrgSeYBv-fgnHkAJ1kEkh12DLdd5KM,6
+mlrun-1.8.0rc42.dist-info/RECORD,,

{mlrun-1.8.0rc41.dist-info → mlrun-1.8.0rc42.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any