mlrun 1.8.0rc35__py3-none-any.whl → 1.8.0rc37__py3-none-any.whl

mlrun/api/schemas/__init__.py

@@ -208,9 +208,6 @@ ModelEndpointList = DeprecationHelper(mlrun.common.schemas.ModelEndpointList)
 ModelEndpointMetadata = DeprecationHelper(mlrun.common.schemas.ModelEndpointMetadata)
 ModelEndpointSpec = DeprecationHelper(mlrun.common.schemas.ModelEndpointSpec)
 ModelEndpointStatus = DeprecationHelper(mlrun.common.schemas.ModelEndpointStatus)
-ModelMonitoringStoreKinds = DeprecationHelper(
-    mlrun.common.schemas.ModelMonitoringStoreKinds
-)
 NotificationSeverity = DeprecationHelper(mlrun.common.schemas.NotificationSeverity)
 NotificationStatus = DeprecationHelper(mlrun.common.schemas.NotificationStatus)
 ObjectKind = DeprecationHelper(mlrun.common.schemas.ObjectKind)

mlrun/artifacts/model.py

@@ -279,7 +279,11 @@ class ModelArtifact(Artifact):
         )
         if label_columns:
             inferer.infer_schema(
-                df[label_columns], self.spec.outputs, {}, options=InferOptions.Features
+                df[label_columns],
+                self.spec.outputs,
+                {},
+                options=InferOptions.Features,
+                push_at_start=True,
             )
         if with_stats:
             self.spec.feature_stats = inferer.get_stats(

mlrun/common/schemas/__init__.py

@@ -139,6 +139,7 @@ from .model_monitoring import (
     Features,
     FeatureSetFeatures,
     FeatureValues,
+    FileTargetKind,
     GrafanaColumn,
     GrafanaNumberColumn,
     GrafanaStringColumn,
@@ -151,7 +152,6 @@ from .model_monitoring import (
     ModelEndpointSpec,
     ModelEndpointStatus,
     ModelMonitoringMode,
-    ModelMonitoringStoreKinds,
     MonitoringFunctionNames,
     TSDBTarget,
     V3IOTSDBTables,

mlrun/common/schemas/artifact.py

@@ -57,6 +57,15 @@ class ArtifactCategories(mlrun.common.types.StrEnum):
             return cls(kind)
         return cls.other
 
+    @staticmethod
+    def all():
+        """Return all applicable artifact categories"""
+        return [
+            ArtifactCategories.model,
+            ArtifactCategories.dataset,
+            ArtifactCategories.document,
+        ]
+
 
 class ArtifactIdentifier(pydantic.v1.BaseModel):
     # artifact kind

mlrun/common/schemas/model_monitoring/__init__.py

@@ -14,9 +14,7 @@
 
 from .constants import (
     INTERSECT_DICT_KEYS,
-    V3IO_MODEL_MONITORING_DB,
     ApplicationEvent,
-    ControllerPolicy,
     DriftStatus,
     EndpointType,
     EndpointUID,
@@ -30,10 +28,7 @@ from .constants import (
     ModelEndpointCreationStrategy,
     ModelEndpointMonitoringMetricType,
     ModelEndpointSchema,
-    ModelEndpointTarget,
-    ModelEndpointTargetSchemas,
     ModelMonitoringMode,
-    ModelMonitoringStoreKinds,
     MonitoringFunctionNames,
     PredictionsQueryConstants,
     ProjectSecretKeys,

mlrun/common/schemas/model_monitoring/constants.py

@@ -240,11 +240,6 @@ class EventKeyMetrics:
     REAL_TIME = "real_time"
 
 
-class ModelEndpointTarget(MonitoringStrEnum):
-    V3IO_NOSQL = "v3io-nosql"
-    SQL = "sql"
-
-
 class TSDBTarget(MonitoringStrEnum):
     V3IO_TSDB = "v3io-tsdb"
     TDEngine = "tdengine"
@@ -269,17 +264,6 @@ class GetEventsFormat(MonitoringStrEnum):
     INTERSECTION = "intersection"
 
 
-class ModelEndpointTargetSchemas(MonitoringStrEnum):
-    V3IO = "v3io"
-    MYSQL = "mysql"
-    SQLITE = "sqlite"
-
-
-class ModelMonitoringStoreKinds:
-    ENDPOINTS = "endpoints"
-    EVENTS = "events"
-
-
 class FileTargetKind:
     ENDPOINTS = "endpoints"
     EVENTS = "events"
@@ -429,10 +413,6 @@ class ModelMonitoringAppLabel:
         return f"{self.KEY}={self.VAL}"
 
 
-class ControllerPolicy:
-    BASE_PERIOD = "base_period"
-
-
 class HistogramDataDriftApplicationConstants:
     NAME = "histogram-data-drift"
     GENERAL_RESULT_NAME = "general_drift"
@@ -449,8 +429,6 @@ class SpecialApps:
 
 _RESERVED_FUNCTION_NAMES = MonitoringFunctionNames.list() + [SpecialApps.MLRUN_INFRA]
 
-V3IO_MODEL_MONITORING_DB = "v3io"
-
 
 class ModelEndpointMonitoringMetricType(StrEnum):
     RESULT = "result"

mlrun/common/schemas/model_monitoring/model_endpoints.py

@@ -36,12 +36,6 @@ from .constants import (
 Model = TypeVar("Model", bound=BaseModel)
 
 
-class ModelMonitoringStoreKinds:
-    # TODO: do changes in examples & demos In 1.5.0 remove
-    ENDPOINTS = "endpoints"
-    EVENTS = "events"
-
-
 class Histogram(BaseModel):
     buckets: list[float]
     counts: list[int]

mlrun/data_types/infer.py

@@ -20,6 +20,8 @@ import pandas as pd
 import pyarrow
 from pandas.io.json._table_schema import convert_pandas_type_to_json_field
 
+import mlrun.features
+from mlrun.model import ObjectList
 from mlrun.utils import logger
 
 from .data_types import InferOptions, pa_type_to_value_type, pd_schema_to_value_type
@@ -29,17 +31,19 @@ default_num_bins = 20
 
 def infer_schema_from_df(
     df: pd.DataFrame,
-    features,
+    features: ObjectList,
     entities,
     timestamp_key: Optional[str] = None,
     entity_columns=None,
     options: InferOptions = InferOptions.Null,
+    push_at_start: Optional[bool] = False,
 ):
     """infer feature set schema from dataframe"""
     timestamp_fields = []
     current_entities = list(entities.keys())
     entity_columns = entity_columns or []
     index_columns = dict()
+    temp_features = ObjectList(mlrun.features.Feature)
 
     def upsert_entity(name, value_type):
         if name in current_entities:
@@ -74,10 +78,14 @@ def infer_schema_from_df(
             if column in features.keys():
                 features[column].value_type = value_type
             else:
-                features[column] = {"name": column, "value_type": value_type}
+                temp_features[column] = {"name": column, "value_type": value_type}
         if value_type == "datetime" and not is_entity:
             timestamp_fields.append(column)
 
+    features.update_list(
+        object_list=temp_features, push_at_start=push_at_start
+    )  # Push to start of the Object list
+
     index_type = None
     if InferOptions.get_common_options(options, InferOptions.Index):
         # infer types of index fields

mlrun/datastore/sources.py

@@ -18,7 +18,7 @@ import warnings
 from base64 import b64encode
 from copy import copy
 from datetime import datetime
-from typing import Optional, Union
+from typing import Any, Optional, Union
 
 import pandas as pd
 import semver
@@ -34,6 +34,7 @@ from mlrun.datastore.utils import transform_list_filters_to_tuple
 from mlrun.secrets import SecretsStore
 from mlrun.utils import logger
 
+from ..common.schemas.function import Function
 from ..model import DataSource
 from ..platforms.iguazio import parse_path
 from ..utils import get_class, is_explicit_ack_supported
@@ -966,6 +967,26 @@ class OnlineSource(BaseSourceDriver):
             "This source type is not supported with ingestion service yet"
         )
 
+    @staticmethod
+    def set_explicit_ack_mode(function: Function, **extra_arguments) -> dict[str, Any]:
+        extra_arguments = extra_arguments or {}
+        engine = "sync"
+        if (
+            function.spec
+            and hasattr(function.spec, "graph")
+            and function.spec.graph
+            and function.spec.graph.engine
+        ):
+            engine = function.spec.graph.engine
+        if mlrun.mlconf.is_explicit_ack_enabled() and engine == "async":
+            extra_arguments["explicit_ack_mode"] = extra_arguments.get(
+                "explicit_ack_mode", "explicitOnly"
+            )
+            extra_arguments["worker_allocation_mode"] = extra_arguments.get(
+                "worker_allocation_mode", "static"
+            )
+        return extra_arguments
+
 
 class HttpSource(OnlineSource):
     kind = "http"
@@ -1028,15 +1049,7 @@ class StreamSource(OnlineSource):
             raise_for_status=v3io.dataplane.RaiseForStatus.never,
         )
         res.raise_for_status([409, 204])
-
-        kwargs = {}
-        engine = "async"
-        if hasattr(function.spec, "graph") and function.spec.graph.engine:
-            engine = function.spec.graph.engine
-
-        if mlrun.mlconf.is_explicit_ack_enabled() and engine == "async":
-            kwargs["explicit_ack_mode"] = "explicitOnly"
-            kwargs["worker_allocation_mode"] = "static"
+        kwargs = self.set_explicit_ack_mode(function=function)
 
         function.add_v3io_stream_trigger(
             url,
@@ -1118,20 +1131,12 @@ class KafkaSource(OnlineSource):
         else:
             extra_attributes = copy(self.attributes)
         partitions = extra_attributes.pop("partitions", None)
-        explicit_ack_mode = None
-        engine = "async"
-        if hasattr(function.spec, "graph") and function.spec.graph.engine:
-            engine = function.spec.graph.engine
 
-        if mlrun.mlconf.is_explicit_ack_enabled() and engine == "async":
-            explicit_ack_mode = "explicitOnly"
-            extra_attributes["workerAllocationMode"] = extra_attributes.get(
-                "worker_allocation_mode", "static"
-            )
-        else:
-            extra_attributes["workerAllocationMode"] = extra_attributes.get(
-                "worker_allocation_mode", "pool"
-            )
+        extra_attributes = self.set_explicit_ack_mode(function, **extra_attributes)
+        explicit_ack_mode = extra_attributes.get("explicit_ack_mode")
+        extra_attributes["workerAllocationMode"] = extra_attributes.get(
+            "worker_allocation_mode", "pool"
+        )
 
         trigger_kwargs = {}
 

mlrun/db/base.py

@@ -102,7 +102,6 @@ class RunDBInterface(ABC):
         ] = None,  # Backward compatibility
         states: Optional[list[mlrun.common.runtimes.constants.RunStates]] = None,
         sort: bool = True,
-        last: int = 0,
         iter: bool = False,
         start_time_from: Optional[datetime.datetime] = None,
         start_time_to: Optional[datetime.datetime] = None,

mlrun/db/httpdb.py

@@ -350,17 +350,10 @@ class HTTPRunDB(RunDBInterface):
                 version=version,
             )
 
-        page_params = deepcopy(params) or {}
-
-        if page_params.get("page-token") is None and page_params.get("page") is None:
-            page_params["page"] = 1
-
-        if page_params.get("page-size") is None:
-            page_params["page-size"] = config.httpdb.pagination.default_page_size
-
+        page_params = self._resolve_page_params(params)
         response = _api_call(page_params)
 
-        # Yield only a single page of results
+        # yields a single page of results
         yield response
 
         if return_all:
@@ -1279,7 +1272,7 @@ class HTTPRunDB(RunDBInterface):
         :param rows_per_partition: How many top rows (per sorting defined by `partition_sort_by` and `partition_order`)
             to return per group. Default value is 1.
         :param partition_sort_by: What field to sort the results by, within each partition defined by `partition_by`.
-            Currently the only allowed values are `created` and `updated`.
+            Currently, the only allowed values are `created` and `updated`.
         :param partition_order: Order of sorting within partitions - `asc` or `desc`. Default is `desc`.
         """
 
@@ -1302,7 +1295,7 @@ class HTTPRunDB(RunDBInterface):
             rows_per_partition=rows_per_partition,
             partition_sort_by=partition_sort_by,
             partition_order=partition_order,
-            return_all=True,
+            return_all=not limit,
         )
         return artifacts
 
@@ -5353,6 +5346,33 @@ class HTTPRunDB(RunDBInterface):
             )
         return None
 
+    def _resolve_page_params(self, params: typing.Optional[dict]) -> dict:
+        """
+        Resolve the page parameters, setting defaults where necessary.
+        """
+        page_params = deepcopy(params) or {}
+        if page_params.get("page-token") is None and page_params.get("page") is None:
+            page_params["page"] = 1
+        if page_params.get("page-size") is None:
+            page_size = config.httpdb.pagination.default_page_size
+
+            if page_params.get("limit") is not None:
+                page_size = page_params["limit"]
+
+                # limit and page/page size are conflicting
+                page_params.pop("limit")
+            page_params["page-size"] = page_size
+
+        # this may happen only when page-size was explicitly set along with limit
+        # this is to ensure we will not get stopped by API on similar below validation
+        # but rather simply fallback to use page-size.
+        if page_params.get("page-size") and page_params.get("limit"):
+            logger.warning(
+                "Both 'limit' and 'page-size' are provided, using 'page-size'."
+            )
+            page_params.pop("limit")
+        return page_params
+
 
 def _as_json(obj):
     fn = getattr(obj, "to_json", None)

mlrun/db/nopdb.py

@@ -132,7 +132,6 @@ class NopDB(RunDBInterface):
         ] = None,  # Backward compatibility
         states: Optional[list[mlrun.common.runtimes.constants.RunStates]] = None,
         sort: bool = True,
-        last: int = 0,
         iter: bool = False,
         start_time_from: Optional[datetime.datetime] = None,
         start_time_to: Optional[datetime.datetime] = None,

mlrun/feature_store/__init__.py

@@ -13,11 +13,6 @@
 # limitations under the License.
 
 __all__ = [
-    "get_offline_features",
-    "get_online_feature_service",
-    "ingest",
-    "preview",
-    "deploy_ingestion_service_v2",
     "delete_feature_set",
     "delete_feature_vector",
     "get_feature_set",
@@ -38,13 +33,8 @@ from ..features import Entity, Feature
 from .api import (
     delete_feature_set,
     delete_feature_vector,
-    deploy_ingestion_service_v2,
     get_feature_set,
     get_feature_vector,
-    get_offline_features,
-    get_online_feature_service,
-    ingest,
-    preview,
 )
 from .common import RunConfig
 from .feature_set import FeatureSet

mlrun/feature_store/api.py

@@ -20,7 +20,6 @@ from datetime import datetime
 from typing import Any, Optional, Union
 
 import pandas as pd
-from deprecated import deprecated
 
 import mlrun
 import mlrun.errors
@@ -91,122 +90,6 @@ def _features_to_vector_and_check_permissions(features, update_stats):
     return vector
 
 
-@deprecated(
-    version="1.6.0",
-    reason="get_offline_features() will be removed in 1.8.0, please instead use "
-    "get_feature_vector('store://feature_vector_name').get_offline_features()",
-    category=FutureWarning,
-)
-def get_offline_features(
-    feature_vector: Union[str, FeatureVector],
-    entity_rows=None,
-    entity_timestamp_column: Optional[str] = None,
-    target: DataTargetBase = None,
-    run_config: RunConfig = None,
-    drop_columns: Optional[list[str]] = None,
-    start_time: Optional[Union[str, datetime]] = None,
-    end_time: Optional[Union[str, datetime]] = None,
-    with_indexes: bool = False,
-    update_stats: bool = False,
-    engine: Optional[str] = None,
-    engine_args: Optional[dict] = None,
-    query: Optional[str] = None,
-    order_by: Optional[Union[str, list[str]]] = None,
-    spark_service: Optional[str] = None,
-    timestamp_for_filtering: Optional[Union[str, dict[str, str]]] = None,
-    additional_filters: Optional[list] = None,
-):
-    """retrieve offline feature vector results
-
-    specify a feature vector object/uri and retrieve the desired features, their metadata
-    and statistics. returns :py:class:`~mlrun.feature_store.OfflineVectorResponse`,
-    results can be returned as a dataframe or written to a target
-
-    The start_time and end_time attributes allow filtering the data to a given time range, they accept
-    string values or pandas `Timestamp` objects, string values can also be relative, for example:
-    "now", "now - 1d2h", "now+5m", where a valid pandas Timedelta string follows the verb "now",
-    for time alignment you can use the verb "floor" e.g. "now -1d floor 1H" will align the time to the last hour
-    (the floor string is passed to pandas.Timestamp.floor(), can use D, H, T, S for day, hour, min, sec alignment).
-    Another option to filter the data is by the `query` argument - can be seen in the example.
-    example::
-
-        features = [
-            "stock-quotes.bid",
-            "stock-quotes.asks_sum_5h",
-            "stock-quotes.ask as mycol",
-            "stocks.*",
-        ]
-        vector = FeatureVector(features=features)
-        resp = get_offline_features(
-            vector,
-            entity_rows=trades,
-            entity_timestamp_column="time",
-            query="ticker in ['GOOG'] and bid>100",
-        )
-        print(resp.to_dataframe())
-        print(vector.get_stats_table())
-        resp.to_parquet("./out.parquet")
-
-    :param feature_vector:          feature vector uri or FeatureVector object. passing feature vector obj requires
-                                    update permissions
-    :param entity_rows:             dataframe with entity rows to join with
-    :param target:                  where to write the results to
-    :param drop_columns:            list of columns to drop from the final result
-    :param entity_timestamp_column: timestamp column name in the entity rows dataframe. can be specified
-                                    only if param entity_rows was specified.
-    :param run_config:              function and/or run configuration
-                                    see :py:class:`~mlrun.feature_store.RunConfig`
-    :param start_time:              datetime, low limit of time needed to be filtered. Optional.
-    :param end_time:                datetime, high limit of time needed to be filtered. Optional.
-    :param with_indexes:            Return vector with/without the entities and the timestamp_key of the feature sets
-                                    and with/without entity_timestamp_column and timestamp_for_filtering columns.
-                                    This property can be specified also in the feature vector spec
-                                    (feature_vector.spec.with_indexes)
-                                    (default False)
-    :param update_stats:            update features statistics from the requested feature sets on the vector.
-                                    (default False).
-    :param engine:                  processing engine kind ("local", "dask", or "spark")
-    :param engine_args:             kwargs for the processing engine
-    :param query:                   The query string used to filter rows on the output
-    :param spark_service:           Name of the spark service to be used (when using a remote-spark runtime)
-    :param order_by:                Name or list of names to order by. The name or the names in the list can be the
-                                    feature name or the alias of the feature you pass in the feature list.
-    :param timestamp_for_filtering: name of the column to filter by, can be str for all the feature sets or a
-                                    dictionary ({<feature set name>: <timestamp column name>, ...})
-                                    that indicates the timestamp column name for each feature set. Optional.
-                                    By default, the filter executes on the timestamp_key of each feature set.
-                                    Note: the time filtering is performed on each feature set before the
-                                    merge process using start_time and end_time params.
-    :param additional_filters: List of additional_filter conditions as tuples.
-                                Each tuple should be in the format (column_name, operator, value).
-                                Supported operators: "=", ">=", "<=", ">", "<".
-                                Example: [("Product", "=", "Computer")]
-                                For all supported filters, please see:
-                                https://arrow.apache.org/docs/python/generated/pyarrow.parquet.ParquetDataset.html
-
-
-    """
-    return _get_offline_features(
-        feature_vector,
-        entity_rows,
-        entity_timestamp_column,
-        target,
-        run_config,
-        drop_columns,
-        start_time,
-        end_time,
-        with_indexes,
-        update_stats,
-        engine,
-        engine_args,
-        query,
-        order_by,
-        spark_service,
-        timestamp_for_filtering,
-        additional_filters,
-    )
-
-
 def _get_offline_features(
     feature_vector: Union[str, FeatureVector],
     entity_rows=None,
@@ -288,93 +171,6 @@ def _get_offline_features(
     )
 
 
-@deprecated(
-    version="1.6.0",
-    reason="get_online_feature_service() will be removed in 1.8.0, please instead use "
-    "get_feature_vector('store://feature_vector_name').get_online_feature_service()",
-    category=FutureWarning,
-)
-def get_online_feature_service(
-    feature_vector: Union[str, FeatureVector],
-    run_config: RunConfig = None,
-    fixed_window_type: FixedWindowType = FixedWindowType.LastClosedWindow,
-    impute_policy: Optional[dict] = None,
-    update_stats: bool = False,
-    entity_keys: Optional[list[str]] = None,
-):
-    """initialize and return online feature vector service api,
-    returns :py:class:`~mlrun.feature_store.OnlineVectorService`
-
-    :**usage**:
-        There are two ways to use the function:
-
-        1. As context manager
-
-            Example::
-
-                with get_online_feature_service(vector_uri) as svc:
-                    resp = svc.get([{"ticker": "GOOG"}, {"ticker": "MSFT"}])
-                    print(resp)
-                    resp = svc.get([{"ticker": "AAPL"}], as_list=True)
-                    print(resp)
-
-            Example with imputing::
-
-                with get_online_feature_service(vector_uri, entity_keys=['id'],
-                                                impute_policy={"*": "$mean", "amount": 0)) as svc:
-                    resp = svc.get([{"id": "C123487"}])
-
-        2. as simple function, note that in that option you need to close the session.
-
-            Example::
-
-                svc = get_online_feature_service(vector_uri, entity_keys=["ticker"])
-                try:
-                    resp = svc.get([{"ticker": "GOOG"}, {"ticker": "MSFT"}])
-                    print(resp)
-                    resp = svc.get([{"ticker": "AAPL"}], as_list=True)
-                    print(resp)
-
-                finally:
-                    svc.close()
-
-            Example with imputing::
-
-                svc = get_online_feature_service(vector_uri, entity_keys=['id'],
-                                                 impute_policy={"*": "$mean", "amount": 0))
-                try:
-                    resp = svc.get([{"id": "C123487"}])
-                except Exception as e:
-                    handling exception...
-                finally:
-                    svc.close()
-
-    :param feature_vector:      feature vector uri or FeatureVector object. passing feature vector obj requires update
-                                permissions.
-    :param run_config:          function and/or run configuration for remote jobs/services
-    :param impute_policy:       a dict with `impute_policy` per feature, the dict key is the feature name and the dict
-                                value indicate which value will be used in case the feature is NaN/empty, the replaced
-                                value can be fixed number for constants or $mean, $max, $min, $std, $count
-                                for statistical
-                                values. "*" is used to specify the default for all features, example: `{"*": "$mean"}`
-    :param fixed_window_type:   determines how to query the fixed window values which were previously inserted by ingest
-    :param update_stats:        update features statistics from the requested feature sets on the vector.
-                                Default: False.
-    :param entity_keys:         Entity list of the first feature_set in the vector.
-                                The indexes that are used to query the online service.
-    :return:                    Initialize the `OnlineVectorService`.
-                                Will be used in subclasses where `support_online=True`.
-    """
-    return _get_online_feature_service(
-        feature_vector,
-        run_config,
-        fixed_window_type,
-        impute_policy,
-        update_stats,
-        entity_keys,
-    )
-
-
 def _get_online_feature_service(
     feature_vector: Union[str, FeatureVector],
     run_config: RunConfig = None,
@@ -448,86 +244,6 @@ def _get_namespace(run_config: RunConfig) -> dict[str, Any]:
         return get_caller_globals()
 
 
-def ingest(
-    featureset: Union[FeatureSet, str] = None,
-    source=None,
-    targets: Optional[list[DataTargetBase]] = None,
-    namespace=None,
-    return_df: bool = True,
-    infer_options: InferOptions = InferOptions.default(),
-    run_config: RunConfig = None,
-    mlrun_context=None,
-    spark_context=None,
-    overwrite=None,
-) -> Optional[pd.DataFrame]:
-    """Read local DataFrame, file, URL, or source into the feature store
-    Ingest reads from the source, run the graph transformations, infers  metadata and stats
-    and writes the results to the default of specified targets
-
-    when targets are not specified data is stored in the configured default targets
-    (will usually be NoSQL for real-time and Parquet for offline).
-
-    the `run_config` parameter allow specifying the function and job configuration,
-    see: :py:class:`~mlrun.feature_store.RunConfig`
-
-    example::
-
-        stocks_set = FeatureSet("stocks", entities=[Entity("ticker")])
-        stocks = pd.read_csv("stocks.csv")
-        df = ingest(stocks_set, stocks, infer_options=fstore.InferOptions.default())
-
-        # for running as remote job
-        config = RunConfig(image="mlrun/mlrun")
-        df = ingest(stocks_set, stocks, run_config=config)
-
-        # specify source and targets
-        source = CSVSource("mycsv", path="measurements.csv")
-        targets = [CSVTarget("mycsv", path="./mycsv.csv")]
-        ingest(measurements, source, targets)
-
-    :param featureset:    feature set object or featureset.uri. (uri must be of a feature set that is in the DB,
-                          call `.save()` if it's not)
-    :param source:        source dataframe or other sources (e.g. parquet source see:
-                          :py:class:`~mlrun.datastore.ParquetSource` and other classes in mlrun.datastore with suffix
-                          Source)
-    :param targets:       optional list of data target objects
-    :param namespace:     namespace or module containing graph classes
-    :param return_df:     indicate if to return a dataframe with the graph results
-    :param infer_options: schema (for discovery of entities, features in featureset), index, stats,
-                          histogram and preview infer options (:py:class:`~mlrun.feature_store.InferOptions`)
-    :param run_config:    function and/or run configuration for remote jobs,
-                          see :py:class:`~mlrun.feature_store.RunConfig`
-    :param mlrun_context: mlrun context (when running as a job), for internal use !
-    :param spark_context: local spark session for spark ingestion, example for creating the spark context:
-                          `spark = SparkSession.builder.appName("Spark function").getOrCreate()`
-                          For remote spark ingestion, this should contain the remote spark service name
-    :param overwrite:     delete the targets' data prior to ingestion
-                          (default: True for non scheduled ingest - deletes the targets that are about to be ingested.
-                          False for scheduled ingest - does not delete the target)
-    :return:              if return_df is True, a dataframe will be returned based on the graph
-    """
-    if mlrun_context is None:
-        deprecated(
-            version="1.6.0",
-            reason="Calling 'ingest' with mlrun_context=None is deprecated and will be removed in 1.8.0,\
-            use 'FeatureSet.ingest()' instead",
-            category=FutureWarning,
-        )
-
-    return _ingest(
-        featureset,
-        source,
-        targets,
-        namespace,
-        return_df,
-        infer_options,
-        run_config,
-        mlrun_context,
-        spark_context,
-        overwrite,
-    )
-
-
 def _ingest(
     featureset: Union[FeatureSet, str] = None,
     source=None,
@@ -776,53 +492,6 @@ def _ingest(
         return df
 
 
-@deprecated(
-    version="1.6.0",
-    reason="'preview' will be removed in 1.8.0, use 'FeatureSet.preview()' instead",
-    category=FutureWarning,
-)
-def preview(
-    featureset: FeatureSet,
-    source,
-    entity_columns: Optional[list] = None,
-    namespace=None,
-    options: InferOptions = None,
-    verbose: bool = False,
-    sample_size: Optional[int] = None,
-) -> pd.DataFrame:
-    """run the ingestion pipeline with local DataFrame/file data and infer features schema and stats
-
-    example::
-
-        quotes_set = FeatureSet("stock-quotes", entities=[Entity("ticker")])
-        quotes_set.add_aggregation("ask", ["sum", "max"], ["1h", "5h"], "10m")
-        quotes_set.add_aggregation("bid", ["min", "max"], ["1h"], "10m")
-        df = preview(
-            quotes_set,
-            quotes_df,
-            entity_columns=["ticker"],
-        )
-
-    :param featureset:     feature set object or uri
-    :param source:         source dataframe or csv/parquet file path
-    :param entity_columns: list of entity (index) column names
-    :param namespace:      namespace or module containing graph classes
-    :param options:        schema (for discovery of entities, features in featureset), index, stats,
-                           histogram and preview infer options (:py:class:`~mlrun.feature_store.InferOptions`)
-    :param verbose:        verbose log
-    :param sample_size:    num of rows to sample from the dataset (for large datasets)
-    """
-    return _preview(
-        featureset,
-        source,
-        entity_columns,
-        namespace,
-        options,
-        verbose,
-        sample_size,
-    )
-
-
 def _preview(
     featureset: FeatureSet,
     source,
@@ -912,55 +581,6 @@ def _run_ingestion_job(
     return run_ingestion_job(name, featureset, run_config, source.schedule)
 
 
-@deprecated(
-    version="1.6.0",
-    reason="'deploy_ingestion_service_v2' will be removed in 1.8.0, "
-    "use 'FeatureSet.deploy_ingestion_service()' instead",
-    category=FutureWarning,
-)
-def deploy_ingestion_service_v2(
-    featureset: Union[FeatureSet, str],
-    source: DataSource = None,
-    targets: Optional[list[DataTargetBase]] = None,
-    name: Optional[str] = None,
-    run_config: RunConfig = None,
-    verbose=False,
-) -> tuple[str, BaseRuntime]:
-    """Start real-time ingestion service using nuclio function
-
-    Deploy a real-time function implementing feature ingestion pipeline
-    the source maps to Nuclio event triggers (http, kafka, v3io stream, etc.)
-
-    the `run_config` parameter allow specifying the function and job configuration,
-    see: :py:class:`~mlrun.feature_store.RunConfig`
-
-    example::
-
-        source = HTTPSource()
-        func = mlrun.code_to_function("ingest", kind="serving").apply(mount_v3io())
-        config = RunConfig(function=func)
-        deploy_ingestion_service_v2(my_set, source, run_config=config)
-
-    :param featureset:    feature set object or uri
-    :param source:        data source object describing the online or offline source
-    :param targets:       list of data target objects
-    :param name:          name for the job/function
-    :param run_config:    service runtime configuration (function object/uri, resources, etc..)
-    :param verbose:       verbose log
-
-    :return: URL to access the deployed ingestion service, and the function that was deployed (which will
-             differ from the function passed in via the run_config parameter).
-    """
-    return _deploy_ingestion_service_v2(
-        featureset,
-        source,
-        targets,
-        name,
-        run_config,
-        verbose,
-    )
-
-
 def _deploy_ingestion_service_v2(
     featureset: Union[FeatureSet, str],
     source: DataSource = None,

mlrun/model.py

@@ -430,6 +430,19 @@ class ObjectList:
         self._children[child_obj.name] = child_obj
         return child_obj
 
+    def move_to_end(self, child, last=True):
+        self._children.move_to_end(child, last)
+
+    def update_list(self, object_list: "ObjectList", push_at_start: bool = False):
+        if push_at_start:
+            self._children = OrderedDict(
+                list(object_list._children.items()) + list(self._children.items())
+            )
+        else:
+            self._children = OrderedDict(
+                list(self._children.items()) + list(object_list._children.items())
+            )
+
 
 class Credentials(ModelObj):
     generate_access_key = "$generate"

mlrun/model_monitoring/applications/histogram_data_drift.py

@@ -102,10 +102,10 @@ class HistogramDataDriftApplication(ModelMonitoringApplicationBase):
     Each metric is calculated over all the features individually and the mean is taken as the metric value.
     The average of Hellinger and total variance distance is taken as the result.
 
-    The application logs two artifacts:
+    The application can log two artifacts:
 
-    * A JSON with the general drift per feature.
-    * A plotly table different metrics per feature.
+    * JSON with the general drift value per feature, produced by default.
+    * Plotly table with the various metrics and histograms per feature (disabled by default due to performance issues).
 
     This application is deployed by default when calling:
 
@@ -114,12 +114,18 @@ class HistogramDataDriftApplication(ModelMonitoringApplicationBase):
         project.enable_model_monitoring()
 
     To avoid it, pass :code:`deploy_histogram_data_drift_app=False`.
+
+    If you want to change the application defaults, such as the classifier or which artifacts to produce, you
+    need to inherit from this class and deploy it as any other model monitoring application.
     """
 
     NAME: Final[str] = HistogramDataDriftApplicationConstants.NAME
 
     _REQUIRED_METRICS = {HellingerDistance, TotalVarianceDistance}
-    _STATS_TYPES: tuple[StatsKind] = (StatsKind.CURRENT_STATS, StatsKind.DRIFT_MEASURES)
+    _STATS_TYPES: tuple[StatsKind, StatsKind] = (
+        StatsKind.CURRENT_STATS,
+        StatsKind.DRIFT_MEASURES,
+    )
 
     metrics: list[type[HistogramDistanceMetric]] = [
         HellingerDistance,
@@ -127,7 +133,12 @@ class HistogramDataDriftApplication(ModelMonitoringApplicationBase):
         TotalVarianceDistance,
     ]
 
-    def __init__(self, value_classifier: Optional[ValueClassifier] = None) -> None:
+    def __init__(
+        self,
+        value_classifier: Optional[ValueClassifier] = None,
+        produce_json_artifact: bool = True,
+        produce_plotly_artifact: bool = False,
+    ) -> None:
         """
         :param value_classifier: Classifier object that adheres to the `ValueClassifier` protocol.
                                  If not provided, the default `DataDriftClassifier()` is used.
@@ -137,6 +148,9 @@ class HistogramDataDriftApplication(ModelMonitoringApplicationBase):
             self.metrics
         ), "TVD and Hellinger distance are required for the general data drift result"
 
+        self._produce_json_artifact = produce_json_artifact
+        self._produce_plotly_artifact = produce_plotly_artifact
+
     def _compute_metrics_per_feature(
         self, monitoring_context: mm_context.MonitoringApplicationContext
     ) -> DataFrame:
@@ -295,40 +309,43 @@ class HistogramDataDriftApplication(ModelMonitoringApplicationBase):
             cast(str, key): (self._value_classifier.value_to_status(value), value)
             for key, value in drift_per_feature_values.items()
         }
-        monitoring_context.logger.debug("Logging plotly artifact")
-        monitoring_context.log_artifact(
-            mm_drift_table.FeaturesDriftTablePlot().produce(
-                sample_set_statistics=sample_set_statistics,
-                inputs_statistics=inputs_statistics,
-                metrics=metrics_per_feature.T.to_dict(),  # pyright: ignore[reportArgumentType]
-                drift_results=drift_results,
-            )
+        monitoring_context.logger.debug("Producing plotly artifact")
+        artifact = mm_drift_table.FeaturesDriftTablePlot().produce(
+            sample_set_statistics=sample_set_statistics,
+            inputs_statistics=inputs_statistics,
+            metrics=metrics_per_feature.T.to_dict(),  # pyright: ignore[reportArgumentType]
+            drift_results=drift_results,
         )
+        monitoring_context.logger.debug("Logging plotly artifact")
+        monitoring_context.log_artifact(artifact)
         monitoring_context.logger.debug("Logged plotly artifact successfully")
 
     def _log_drift_artifacts(
         self,
         monitoring_context: mm_context.MonitoringApplicationContext,
         metrics_per_feature: DataFrame,
-        log_json_artifact: bool = True,
     ) -> None:
         """Log JSON and Plotly drift data per feature artifacts"""
+        if not self._produce_json_artifact and not self._produce_plotly_artifact:
+            return
+
         drift_per_feature_values = metrics_per_feature[
             [HellingerDistance.NAME, TotalVarianceDistance.NAME]
         ].mean(axis=1)
 
-        if log_json_artifact:
+        if self._produce_json_artifact:
             self._log_json_artifact(drift_per_feature_values, monitoring_context)
 
-        self._log_plotly_table_artifact(
-            sample_set_statistics=self._get_shared_features_sample_stats(
-                monitoring_context
-            ),
-            inputs_statistics=monitoring_context.feature_stats,
-            metrics_per_feature=metrics_per_feature,
-            drift_per_feature_values=drift_per_feature_values,
-            monitoring_context=monitoring_context,
-        )
+        if self._produce_plotly_artifact:
+            self._log_plotly_table_artifact(
+                sample_set_statistics=self._get_shared_features_sample_stats(
+                    monitoring_context
+                ),
+                inputs_statistics=monitoring_context.feature_stats,
+                metrics_per_feature=metrics_per_feature,
+                drift_per_feature_values=drift_per_feature_values,
+                monitoring_context=monitoring_context,
+            )
 
     def do_tracking(
         self, monitoring_context: mm_context.MonitoringApplicationContext

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

@@ -187,6 +187,12 @@ class TDEngineConnector(TSDBConnector):
                 "Invalid 'endpoint_id' filter: must be a string or a list."
             )
 
+    def _drop_database_query(self) -> str:
+        return f"DROP DATABASE IF EXISTS {self.database};"
+
+    def _get_table_name_query(self) -> str:
+        return f"SELECT table_name FROM information_schema.ins_tables where db_name='{self.database}' LIMIT 1;"
+
     def apply_monitoring_stream_steps(self, graph, **kwarg):
         """
         Apply TSDB steps on the provided monitoring graph. Throughout these steps, the graph stores live data of
@@ -297,6 +303,54 @@ class TDEngineConnector(TSDBConnector):
             project=self.project,
         )
 
+        # Check if database is empty and if so, drop it
+        self._drop_database_if_empty()
+
+    def _drop_database_if_empty(self):
+        query_random_table_name = self._get_table_name_query()
+        drop_database = False
+        try:
+            table_name = self.connection.run(
+                query=query_random_table_name,
+                timeout=self._timeout,
+                retries=self._retries,
+            )
+            if len(table_name.data) == 0:
+                # no tables were found under the database
+                drop_database = True
+
+        except Exception as e:
+            logger.warning(
+                "Failed to query tables in the database. You may need to drop the database manually if it is empty.",
+                project=self.project,
+                error=mlrun.errors.err_to_str(e),
+            )
+
+        if drop_database:
+            logger.debug(
+                "Going to drop the TDEngine database",
+                project=self.project,
+                database=self.database,
+            )
+            drop_database_query = self._drop_database_query()
+            try:
+                self.connection.run(
+                    statements=drop_database_query,
+                    timeout=self._timeout,
+                    retries=self._retries,
+                )
+                logger.debug(
+                    "The TDEngine database has been successfully dropped",
+                    project=self.project,
+                    database=self.database,
+                )
+            except Exception as e:
+                logger.warning(
+                    "Failed to drop the database. You may need to drop it manually if it is empty.",
+                    project=self.project,
+                    error=mlrun.errors.err_to_str(e),
+                )
+
     def get_model_endpoint_real_time_metrics(
         self,
         endpoint_id: str,

mlrun/projects/project.py

@@ -4678,7 +4678,6 @@ class MlrunProject(ModelObj):
         ] = None,  # Backward compatibility
         states: typing.Optional[list[mlrun.common.runtimes.constants.RunStates]] = None,
         sort: bool = True,
-        last: int = 0,
         iter: bool = False,
         start_time_from: Optional[datetime.datetime] = None,
         start_time_to: Optional[datetime.datetime] = None,
@@ -4751,7 +4750,6 @@ class MlrunProject(ModelObj):
                 else states or None
             ),
             sort=sort,
-            last=last,
             iter=iter,
             start_time_from=start_time_from,
             start_time_to=start_time_to,

mlrun/runtimes/nuclio/function.py

@@ -527,6 +527,17 @@ class RemoteRuntime(KubeResource):
         access_key = kwargs.pop("access_key", None)
         if not access_key:
             access_key = self._resolve_v3io_access_key()
+        engine = "sync"
+        explicit_ack_mode = kwargs.pop("explicit_ack_mode", None)
+        if (
+            self.spec
+            and hasattr(self.spec, "graph")
+            and self.spec.graph
+            and self.spec.graph.engine
+        ):
+            engine = self.spec.graph.engine
+        if mlrun.mlconf.is_explicit_ack_enabled() and engine == "async":
+            explicit_ack_mode = explicit_ack_mode or "explicitOnly"
 
         self.add_trigger(
             name,
@@ -540,6 +551,7 @@ class RemoteRuntime(KubeResource):
                 extra_attributes=extra_attributes,
                 read_batch_size=256,
                 access_key=access_key,
+                explicit_ack_mode=explicit_ack_mode,
                 **kwargs,
             ),
         )

mlrun/runtimes/nuclio/serving.py

@@ -376,6 +376,7 @@ class ServingRuntime(RemoteRuntime):
         creation_strategy: Optional[
             schemas.ModelEndpointCreationStrategy
         ] = schemas.ModelEndpointCreationStrategy.INPLACE,
+        outputs: Optional[list[str]] = None,
         **class_args,
     ):
         """add ml model and/or route to the function.
@@ -408,6 +409,9 @@ class ServingRuntime(RemoteRuntime):
             * **archive**:
             1. If model endpoints with the same name exist, preserve them.
             2. Create a new model endpoint with the same name and set it to `latest`.
+        :param outputs: list of the model outputs (e.g. labels) ,if provided will override the outputs that been
+                        configured in the model artifact, please note that those outputs need to be equal to the
+                        model serving function outputs (length, and order)
         :param class_args:  extra kwargs to pass to the model serving class __init__
                             (can be read in the model using .get_param(key) method)
         """
@@ -443,6 +447,8 @@ class ServingRuntime(RemoteRuntime):
         if class_name and hasattr(class_name, "to_dict"):
             if model_path:
                 class_name.model_path = model_path
+            if outputs:
+                class_name.outputs = outputs
             key, state = params_to_step(
                 class_name,
                 key,
@@ -470,6 +476,7 @@ class ServingRuntime(RemoteRuntime):
             else:
                 class_args = deepcopy(class_args)
                 class_args["model_path"] = model_path
+                class_args["outputs"] = outputs
                 state = TaskStep(
                     class_name,
                     class_args,

mlrun/utils/version/version.json

@@ -1,4 +1,4 @@
 {
-  "git_commit": "5f9d8acdee2fae27344dc81aca121f09962d54d4",
-  "version": "1.8.0-rc35"
+  "git_commit": "47544e1aeb02b81f6d3dfe7e56c3d10831956016",
+  "version": "1.8.0-rc37"
 }

{mlrun-1.8.0rc35.dist-info → mlrun-1.8.0rc37.dist-info}/METADATA

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

{mlrun-1.8.0rc35.dist-info → mlrun-1.8.0rc37.dist-info}/RECORD

@@ -6,19 +6,19 @@ mlrun/execution.py,sha256=FUktsD3puSFjc3LZJU35b-OmFBrBPBNntViCLQVuwnk,50008
 mlrun/features.py,sha256=ReBaNGsBYXqcbgI012n-SO_j6oHIbk_Vpv0CGPXbUmo,15842
 mlrun/k8s_utils.py,sha256=-RmKAlSBo_qVeJa1bIiwi6TUyuEpb4AhF7wIQ_H5ZJ0,8909
 mlrun/lists.py,sha256=-nbmqScRia0v2IdSHt6Pd0fLRLSEtdB9bSxyD92BWvs,8562
-mlrun/model.py,sha256=Fh8aoMVDiWY7CiMsuLGaA2zCv17DklmW2dbTp3ZpG7M,85368
+mlrun/model.py,sha256=5YedJfY9La867fhW8sZJdWb4FwyXPR1r1C5SqYyB4_w,85864
 mlrun/render.py,sha256=940H9fBBFeghH4dlifbURvtjlvw4GlWdAXezN6ky4rI,13275
 mlrun/run.py,sha256=NScg8Acp62329jryOK5nldu2LYVkIZgSiEEg8IJrQwo,45124
 mlrun/secrets.py,sha256=dZPdkc_zzfscVQepOHUwmzFqnBavDCBXV9DQoH_eIYM,7800
 mlrun/alerts/__init__.py,sha256=0gtG1BG0DXxFrXegIkjbM1XEN4sP9ODo0ucXrNld1hU,601
 mlrun/alerts/alert.py,sha256=9kGTtV385Ax-aTm-450HzPwEek9e0c3O3Qln-jXjhFg,15948
-mlrun/api/schemas/__init__.py,sha256=UHUqUkMpmGtWuLN9YEwOcRB-J7IB1e59A9gy45rX7uk,14021
+mlrun/api/schemas/__init__.py,sha256=tVAnpexDkfI0JWMJNlPSnVOzoV4xqIjWGSln9UkPS4I,13921
 mlrun/artifacts/__init__.py,sha256=ofC2extBCOC1wg1YtdTzWzH3eeG_f-sFBUkHjYtZJpk,1175
 mlrun/artifacts/base.py,sha256=nz2ZqC74JGfWN0M6_hOXXQj3bXSTxNp4eUgvWHVcdvY,29979
 mlrun/artifacts/dataset.py,sha256=QTot5vCgLHatlIWwNnKbWdZ8HHTxaZ7wk4gWQDoqQ2k,16655
 mlrun/artifacts/document.py,sha256=3X1i27NYSd-cOcX-lEvaNTUvwS2UKWXW2EnlfWokrVk,17374
 mlrun/artifacts/manager.py,sha256=MgUF_JYgQ_i7su3fqvK2CZ_uMxXyCB6M1jDr_k6tAYw,16191
-mlrun/artifacts/model.py,sha256=pfhbEIfTpXZ0xubc_PVP2OtQDUj-EThs6HlZnzPQQJU,22144
+mlrun/artifacts/model.py,sha256=cad5pvEz3jmA7xgqfRUT5ojc3co0ikSD7UzO99NypQ0,22229
 mlrun/artifacts/plots.py,sha256=dS0mHGt1b20tN2JyEH9H5o5I0oMKZkzn3Uz_3Hf4WjU,4813
 mlrun/common/__init__.py,sha256=xY3wHC4TEJgez7qtnn1pQvHosi8-5UJOCtyGBS7FcGE,571
 mlrun/common/constants.py,sha256=14xMUX9C5BB-LxsTlMTJQf_Xz2DyRjaK9yeR5dadcDU,3426
@@ -39,10 +39,10 @@ mlrun/common/formatters/run.py,sha256=Gcf9lVDqxPMNfWcPX0RJasjTC_N_U0yTBkQ02jOPJ7
 mlrun/common/model_monitoring/__init__.py,sha256=kXGBqhLN0rlAx0kTXhozGzFsIdSqW0uTSKMmsLgq_is,569
 mlrun/common/model_monitoring/helpers.py,sha256=A2svqjCsZV8FmlimnY9QI_kKIEUJINu6YI7uJfO-Kn0,3173
 mlrun/common/runtimes/constants.py,sha256=PBpCtPixbKjP9aTo6Qqtui6FjWcXbFxhbSzduV4ttc4,12324
-mlrun/common/schemas/__init__.py,sha256=QuMQClP_LvEcUCKp0v2nmA_xUizm644SWvlIdZaP59Q,5335
+mlrun/common/schemas/__init__.py,sha256=tNeYsylPAgG-3YI_Foka80alqm0JoCpXtuS_nDZzuaU,5324
 mlrun/common/schemas/alert.py,sha256=tRsjHEQTjCb-83GS0mprsu5junvqL4aQjWN2Rt_yAaM,10183
 mlrun/common/schemas/api_gateway.py,sha256=3a0QxECLmoDkD5IiOKtXJL-uiWB26Hg55WMA3nULYuI,7127
-mlrun/common/schemas/artifact.py,sha256=f0NPsoZmA-WD9RtN-dcKFW6KuV0PPQB25A2psF7LbP8,4013
+mlrun/common/schemas/artifact.py,sha256=T-CdBIqgDUH-i8hx1Dp-Msr8v6UGwwp3d9j8rUzb9ZM,4249
 mlrun/common/schemas/auth.py,sha256=qYOCDbK-k7GTjwLseqGoxwcR-rdIbG2k7ct29M0sPUI,6880
 mlrun/common/schemas/background_task.py,sha256=ofWRAQGGEkXEu79Dbw7tT_5GPolR09Lc3Ebg2r0fT24,1728
 mlrun/common/schemas/client_spec.py,sha256=1RV2vx3PhXfk456b0qcU9R7dz4cisHsRD-HgjKeBdg0,2797
@@ -72,13 +72,13 @@ mlrun/common/schemas/secret.py,sha256=CCxFYiPwJtDxwg2VVJH9nUG9cAZ2a34IjeuaWv-BYl
 mlrun/common/schemas/serving.py,sha256=81ZxlDHP1fm9VPmXZGkjZj2n6cVRmqEN478hsmvv5QA,744
 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=0mgmCpEAyqytI2Hjpqvp6Q83HvqIl2lUBYN5fO4Eo7c,1849
-mlrun/common/schemas/model_monitoring/constants.py,sha256=CuaHnTsMaqWfJgfUKpoLsb75JmSGss7USsYlv_C9nOI,12594
+mlrun/common/schemas/model_monitoring/__init__.py,sha256=SxHG-GIdcTEuFxpKzkUdT9zKaU5Xqz9qF1uCwXvZ2z8,1709
+mlrun/common/schemas/model_monitoring/constants.py,sha256=dqCAZQM9dw_6WIlf61XYMHY7TFi_ujSkWt1r_8YlXmg,12207
 mlrun/common/schemas/model_monitoring/grafana.py,sha256=THQlLfPBevBksta8p5OaIsBaJtsNSXexLvHrDxOaVns,2095
-mlrun/common/schemas/model_monitoring/model_endpoints.py,sha256=0gBH-KnDDbGLOkiqHtk0_iNIdW-NPVy0TKJnZ1fDcEQ,11807
+mlrun/common/schemas/model_monitoring/model_endpoints.py,sha256=LIRtQ_gD7n17pQbacynp7Os8HyFwqobTKIPH0lwqoUA,11663
 mlrun/data_types/__init__.py,sha256=unRo9GGwCmj0hBKBRsXJ2P4BzpQaddlQTvIrVQaKluI,984
 mlrun/data_types/data_types.py,sha256=0_oKLC6-sXL2_nnaDMP_HSXB3fD1nJAG4J2Jq6sGNNw,4998
-mlrun/data_types/infer.py,sha256=KdaRgWcqvLkuLjXrMuDr3ik6WY7JP5wJO0Yii_Vl5kw,6173
+mlrun/data_types/infer.py,sha256=Ogp3rsENVkjU0GDaGa9J1vjGrvMxgzwbSEuG51nt61E,6477
 mlrun/data_types/spark.py,sha256=4fPpqjFCYeFgK_yHhUNM4rT-1Gw9YiXazyjTK7TtbTI,9626
 mlrun/data_types/to_pandas.py,sha256=KOy0FLXPJirsgH6szcC5BI6t70yVDCjuo6LmuYHNTuI,11429
 mlrun/datastore/__init__.py,sha256=ca-9rcmxMimZKq3EHetpptZQ5udkf4O0sm37D7NWaXE,4128
@@ -95,7 +95,7 @@ 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/snowflake_utils.py,sha256=Wohvnlmq8j1d98RCaknll-iWdZZpSlCrKhUOEy0_-CA,1483
-mlrun/datastore/sources.py,sha256=LnFeiYxcotw_H_vIwCORE8fFaJB21XGBG77iJKaYHmI,49240
+mlrun/datastore/sources.py,sha256=2kgQZ_I_rOpyEb3FSivXNqR5jUO7qcgqjBEVO3u7ccU,49472
 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
@@ -108,12 +108,12 @@ mlrun/datastore/wasbfs/__init__.py,sha256=s5Ul-0kAhYqFjKDR2X0O2vDGDbLQQduElb32Ev
 mlrun/datastore/wasbfs/fs.py,sha256=ge8NK__5vTcFT-krI155_8RDUywQw4SIRX6BWATXy9Q,6299
 mlrun/db/__init__.py,sha256=WqJ4x8lqJ7ZoKbhEyFqkYADd9P6E3citckx9e9ZLcIU,1163
 mlrun/db/auth_utils.py,sha256=hpg8D2r82oN0BWabuWN04BTNZ7jYMAF242YSUpK7LFM,5211
-mlrun/db/base.py,sha256=ax9d2J3mLMZKGomiPHQKfIEB25ZkZXjwtmUfPxUMpz4,30736
+mlrun/db/base.py,sha256=AZ7qf1SbQ3jN6Pay-ZcFYxVYJr1UxL9aXpMPmrGog1E,30713
 mlrun/db/factory.py,sha256=yP2vVmveUE7LYTCHbS6lQIxP9rW--zdISWuPd_I3d_4,2111
-mlrun/db/httpdb.py,sha256=mY9IxwFsUPnzzbSBiIm2USGHJ-TKWvoMySy94weYH3k,229743
-mlrun/db/nopdb.py,sha256=LUz6psaNY-X8isKWsnxUbnTq9vOz2REOUF8BbRl2PTQ,27171
-mlrun/feature_store/__init__.py,sha256=AVnY2AFUNc2dKxLLUMx2K3Wo1eGviv0brDcYlDnmtf4,1506
-mlrun/feature_store/api.py,sha256=qkojZpzqGAn3r9ww0ynBRKOs8ji8URaK4DSYD4SE-CE,50395
+mlrun/db/httpdb.py,sha256=Yja0gp4D7RNDaj3aIYVaUo2lO_BVFtH2nVWvf7VLsXo,230688
+mlrun/db/nopdb.py,sha256=QHiGM2KWnuZL-L0GZ0T9oon6ETSS2oIW0I6Eq5yfFIg,27148
+mlrun/feature_store/__init__.py,sha256=MP8OZzOaRsFd_sLvlnxDhoJMW-H8AEGGprmhVCVssfY,1264
+mlrun/feature_store/api.py,sha256=I52lZg1sm9c4mL7hCx2ij6XKO6ybmyHdOOuwe5OPUqk,33309
 mlrun/feature_store/common.py,sha256=Z7USI-d1fo0iwBMsqMBtJflJfyuiV3BLoDXQPSAoBAs,12826
 mlrun/feature_store/feature_set.py,sha256=lakkuKYAvYDJKDTE0xJa5n1nEipMPwpLki-J3CMk0mQ,56221
 mlrun/feature_store/feature_vector.py,sha256=9EJXdnPklwKdkYDKV0hxByIjd59K6R2S-DnP7jZlwoY,44602
@@ -228,7 +228,7 @@ mlrun/model_monitoring/applications/__init__.py,sha256=xDBxkBjl-whHSG_4t1mLkxiyp
 mlrun/model_monitoring/applications/_application_steps.py,sha256=97taCEkfGx-QO-gD9uKnRF1PDIxQhY7sjPg85GxgIpA,6628
 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/histogram_data_drift.py,sha256=G26_4gQfcwDZe3S6SIZ4Uc_qyrHAJ6lDTFOQGkbfQR8,14455
+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
 mlrun/model_monitoring/applications/evidently/base.py,sha256=C8402vQJH7jmY-i49DnYjy6p6dETWex4Tdi8ylFLecA,5097
@@ -241,7 +241,7 @@ mlrun/model_monitoring/db/tsdb/helpers.py,sha256=0oUXc4aUkYtP2SGP6jTb3uPPKImIUsV
 mlrun/model_monitoring/db/tsdb/tdengine/__init__.py,sha256=vgBdsKaXUURKqIf3M0y4sRatmSVA4CQiJs7J5dcVBkQ,620
 mlrun/model_monitoring/db/tsdb/tdengine/schemas.py,sha256=qfKDUZhgteL0mp2A1aP1iMmcthgUMKmZqMUidZjQktQ,12649
 mlrun/model_monitoring/db/tsdb/tdengine/stream_graph_steps.py,sha256=Uadj0UvAmln2MxDWod-kAzau1uNlqZh981rPhbUH_5M,2857
-mlrun/model_monitoring/db/tsdb/tdengine/tdengine_connector.py,sha256=OgIA-S-DZ3DM455zOk24rUsmM2EdrKbliuKs1Lzcpuw,32793
+mlrun/model_monitoring/db/tsdb/tdengine/tdengine_connector.py,sha256=2uSpIUpUGoFRCgrSv0RLGWoR7oc69GWW_bLbmjtfYEk,34860
 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=foxYWx7OjOfat2SHmzYrG8bIfaQ5NDnBtpDZua_NVGE,41141
@@ -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=VXUlMrouFTls-I-bMhdN5pPfQ34TR7bFQ-NUSWNvl84,20029
 mlrun/projects/pipelines.py,sha256=QH2nEhaJxhafJdT0AXPzpDhTniyHtc0Cg74Spdz6Oeg,48255
-mlrun/projects/project.py,sha256=ox7ey4sIyEDJl1-vfaFBzZ8DQq2b2tpeEiIhAWyOwTc,234966
+mlrun/projects/project.py,sha256=bNUlWONGLxL8vCsKgwOiYGPXFEgvLaVjTSAoJGROZLY,234920
 mlrun/runtimes/__init__.py,sha256=J9Sy2HiyMlztNv6VUurMzF5H2XzttNil8nRsWDsqLyg,8923
 mlrun/runtimes/base.py,sha256=K5-zfFrE_HR6AaHWs2figaOTr7eosw3-4bELkYzpRk4,37789
 mlrun/runtimes/daskjob.py,sha256=JwuGvOiPsxEDHHMMUS4Oie4hLlYYIZwihAl6DjroTY0,19521
@@ -291,9 +291,9 @@ mlrun/runtimes/mpijob/abstract.py,sha256=JGMjcJ4dvpJbctF6psU9UvYyNCutMxTMgBQeTlz
 mlrun/runtimes/mpijob/v1.py,sha256=1XQZC7AIMGX_AQCbApcwpH8I7y39-v0v2O35MvxjXoo,3213
 mlrun/runtimes/nuclio/__init__.py,sha256=gx1kizzKv8pGT5TNloN1js1hdbxqDw3rM90sLVYVffY,794
 mlrun/runtimes/nuclio/api_gateway.py,sha256=vH9ClKVP4Mb24rvA67xPuAvAhX-gAv6vVtjVxyplhdc,26969
-mlrun/runtimes/nuclio/function.py,sha256=QCHlcC6ESw7fb0I0nZGv__XVHvGxBGQmtzby9EXhbG8,54097
+mlrun/runtimes/nuclio/function.py,sha256=EkcDj5UgNzqfNblbpgAND30qbosp4inAx4BwhYa2Jg8,54586
 mlrun/runtimes/nuclio/nuclio.py,sha256=sLK8KdGO1LbftlL3HqPZlFOFTAAuxJACZCVl1c0Ha6E,2942
-mlrun/runtimes/nuclio/serving.py,sha256=SfvRcujt4EYYWwpNSJgozGhbn85OOSmpIrQNSOJYPCs,32222
+mlrun/runtimes/nuclio/serving.py,sha256=rkNR-sJ1WKS5wEOsYNQ34pRzIENWz81QmZnXr9AuLg4,32685
 mlrun/runtimes/nuclio/application/__init__.py,sha256=rRs5vasy_G9IyoTpYIjYDafGoL6ifFBKgBtsXn31Atw,614
 mlrun/runtimes/nuclio/application/application.py,sha256=HlEq4A6hbFqr3Ba3TL4m7nbmfMYI06Zb_NAKGjzkEFU,29242
 mlrun/runtimes/nuclio/application/reverse_proxy.go,sha256=JIIYae6bXzCLf3jXuu49KWPQYoXr_FDQ2Rbo1OWKAd0,3150
@@ -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=fTXvMCOFPnwWkvjbkdV-GKnWlgjwVYT4B-biO9D6dRs,89
+mlrun/utils/version/version.json,sha256=FFiu4Ob8EieKg4vHzsKJT0xi8JMKnsB2ZSCwLJgdFno,89
 mlrun/utils/version/version.py,sha256=eEW0tqIAkU9Xifxv8Z9_qsYnNhn3YH7NRAfM-pPLt1g,1878
-mlrun-1.8.0rc35.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-mlrun-1.8.0rc35.dist-info/METADATA,sha256=dfxit0GGLGyW9aKew_CiVd7HFbrwkyaHXPruw833wjQ,25986
-mlrun-1.8.0rc35.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mlrun-1.8.0rc35.dist-info/entry_points.txt,sha256=1Owd16eAclD5pfRCoJpYC2ZJSyGNTtUr0nCELMioMmU,46
-mlrun-1.8.0rc35.dist-info/top_level.txt,sha256=NObLzw3maSF9wVrgSeYBv-fgnHkAJ1kEkh12DLdd5KM,6
-mlrun-1.8.0rc35.dist-info/RECORD,,
+mlrun-1.8.0rc37.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+mlrun-1.8.0rc37.dist-info/METADATA,sha256=8KzKclwmXJVyUzlVJAmAhOsxjBZHIkYVtnBqY3LC8bE,25986
+mlrun-1.8.0rc37.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mlrun-1.8.0rc37.dist-info/entry_points.txt,sha256=1Owd16eAclD5pfRCoJpYC2ZJSyGNTtUr0nCELMioMmU,46
+mlrun-1.8.0rc37.dist-info/top_level.txt,sha256=NObLzw3maSF9wVrgSeYBv-fgnHkAJ1kEkh12DLdd5KM,6
+mlrun-1.8.0rc37.dist-info/RECORD,,