mlrun 1.4.0rc25__py3-none-any.whl → 1.5.0rc2__py3-none-any.whl

mlrun/feature_store/retrieval/spark_merger.py

@@ -41,8 +41,9 @@ class SparkFeatureMerger(BaseMerger):
         self,
         entity_df,
         entity_timestamp_column: str,
-        featureset,
-        featureset_df,
+        featureset_name: str,
+        featureset_timstamp: str,
+        featureset_df: list,
         left_keys: list,
         right_keys: list,
     ):
@@ -54,13 +55,15 @@ class SparkFeatureMerger(BaseMerger):
                 the feature tables.
             entity_timestamp_column (str): Column name in entity_df which represents
                 event timestamp.
-            featureset_df (Dataframe): Spark dataframe representing the feature table.
+            featureset (Dataframe): Spark dataframe representing the feature table.
             featureset (FeatureSet): Feature set specification, which provides information on
                 how the join should be performed, such as the entity primary keys.
         Returns:
             DataFrame: Join result, which contains all the original columns from entity_df, as well
                 as all the features specified in featureset, where the feature columns will
                 be prefixed with featureset_df name.
+                :param featureset_name:
+                :param featureset_timstamp:
         """
 
         from pyspark.sql import Window
@@ -68,7 +71,7 @@ class SparkFeatureMerger(BaseMerger):
 
         entity_with_id = entity_df.withColumn("_row_nr", monotonically_increasing_id())
         rename_right_keys = {}
-        for key in right_keys + [featureset.spec.timestamp_key]:
+        for key in right_keys + [featureset_timstamp]:
             if key in entity_df.columns:
                 rename_right_keys[key] = f"ft__{key}"
         # get columns for projection
@@ -79,7 +82,7 @@ class SparkFeatureMerger(BaseMerger):
 
         aliased_featureset_df = featureset_df.select(projection)
         right_timestamp = rename_right_keys.get(
-            featureset.spec.timestamp_key, featureset.spec.timestamp_key
+            featureset_timstamp, featureset_timstamp
         )
 
         # set join conditions
@@ -106,7 +109,7 @@ class SparkFeatureMerger(BaseMerger):
             "_rank", row_number().over(window)
         ).filter(col("_rank") == 1)
 
-        for key in right_keys + [featureset.spec.timestamp_key]:
+        for key in right_keys + [featureset_timstamp]:
             if key in entity_df.columns + [entity_timestamp_column]:
                 filter_most_recent_feature_timestamp = (
                     filter_most_recent_feature_timestamp.drop(
@@ -121,7 +124,8 @@ class SparkFeatureMerger(BaseMerger):
         self,
         entity_df,
         entity_timestamp_column: str,
-        featureset,
+        featureset_name,
+        featureset_timestamp,
         featureset_df,
         left_keys: list,
         right_keys: list,
@@ -130,20 +134,18 @@ class SparkFeatureMerger(BaseMerger):
         """
         spark dataframes join
 
-        Args:
-        entity_df (DataFrame): Spark dataframe representing the entities, to be joined with
+        :param entity_df (DataFrame): Spark dataframe representing the entities, to be joined with
             the feature tables.
-        entity_timestamp_column (str): Column name in entity_df which represents
+        :param entity_timestamp_column (str): Column name in entity_df which represents
             event timestamp.
-        featureset_df (Dataframe): Spark dataframe representing the feature table.
-        featureset (FeatureSet): Feature set specification, which provide information on
-            how the join should be performed, such as the entity primary keys.
+        :param featureset_df (Dataframe): Spark dataframe representing the feature table.
+        :param featureset_name:
+        :param featureset_timestamp:
 
         Returns:
             DataFrame: Join result, which contains all the original columns from entity_df, as well
                 as all the features specified in featureset, where the feature columns will
                 be prefixed with featureset_df name.
-
         """
         if left_keys != right_keys:
             join_cond = [
@@ -270,3 +272,8 @@ class SparkFeatureMerger(BaseMerger):
         self._result_df = self._result_df.orderBy(
             *[col(col_name).asc_nulls_last() for col_name in order_by_active]
         )
+
+    def _convert_entity_rows_to_engine_df(self, entity_rows):
+        if entity_rows is not None and not hasattr(entity_rows, "rdd"):
+            return self.spark.createDataFrame(entity_rows)
+        return entity_rows

mlrun/feature_store/retrieval/storey_merger.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# Copyright 2023 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -41,45 +41,45 @@ class StoreyFeatureMerger(BaseMerger):
         )
         next = graph
 
-        fs_link_list = self._create_linked_relation_list(
+        join_graph = self._get_graph(
             feature_set_objects, feature_set_fields, entity_keys
         )
 
         all_columns = []
         save_column = []
         entity_keys = []
+        del_columns = []
         end_aliases = {}
-        for node in fs_link_list:
-            name = node.name
-            if name == self._entity_rows_node_name:
-                continue
-            featureset = feature_set_objects[name]
+        for step in join_graph.steps:
+            name = step.right_feature_set_name
+            feature_set = feature_set_objects[name]
             columns = feature_set_fields[name]
             column_names = [name for name, alias in columns]
             aliases = {name: alias for name, alias in columns if alias}
             all_columns += [aliases.get(name, name) for name in column_names]
-            for col in node.data["save_cols"]:
+            saved_columns_for_relation = list(
+                self.vector.get_feature_set_relations(feature_set).keys()
+            )
+
+            for col in saved_columns_for_relation:
                 if col not in column_names:
                     column_names.append(col)
+                    del_columns.append(col)
                 else:
                     save_column.append(col)
 
-            entity_list = node.data["right_keys"] or list(
-                featureset.spec.entities.keys()
-            )
+            entity_list = step.right_keys or list(feature_set.spec.entities.keys())
             if not entity_keys:
                 # if entity_keys not provided by the user we will set it to be the entity of the first feature set
                 entity_keys = entity_list
             end_aliases.update(
                 {
                     k: v
-                    for k, v in zip(entity_list, node.data["left_keys"])
+                    for k, v in zip(entity_list, step.left_keys)
                     if k != v and v in save_column
                 }
             )
-            mapping = {
-                k: v for k, v in zip(node.data["left_keys"], entity_list) if k != v
-            }
+            mapping = {k: v for k, v in zip(step.left_keys, entity_list) if k != v}
             if mapping:
                 next = next.to(
                     "storey.Rename",
@@ -91,7 +91,7 @@ class StoreyFeatureMerger(BaseMerger):
                 "storey.QueryByKey",
                 f"query-{name}",
                 features=column_names,
-                table=featureset.uri,
+                table=feature_set.uri,
                 key_field=entity_list,
                 aliases=aliases,
                 fixed_window_type=fixed_window_type.to_qbk_fixed_window_type(),
@@ -103,6 +103,12 @@ class StoreyFeatureMerger(BaseMerger):
                 "rename-entity-to-features",
                 mapping=end_aliases,
             )
+        if del_columns:
+            next = next.to(
+                "storey.flow.DropColumns",
+                "drop-unnecessary-columns",
+                columns=del_columns,
+            )
         for name in start_states:
             next.set_next(name)
 

mlrun/kfpops.py

@@ -26,7 +26,6 @@ import mlrun
 from mlrun.errors import err_to_str
 
 from .config import config
-from .db import get_or_set_dburl, get_run_db
 from .model import HyperParamOptions, RunSpec
 from .utils import (
     dict_to_yaml,
@@ -297,7 +296,7 @@ def mlrun_op(
     outputs = [] if outputs is None else outputs
     labels = {} if labels is None else labels
 
-    rundb = rundb or get_or_set_dburl()
+    rundb = rundb or mlrun.db.get_or_set_dburl()
     cmd = [
         "python",
         "-m",
@@ -732,7 +731,7 @@ def generate_kfp_dag_and_resolve_project(run, project=None):
     return dag, project, workflow["status"].get("message", "")
 
 
-def format_summary_from_kfp_run(kfp_run, project=None, session=None):
+def format_summary_from_kfp_run(kfp_run, project=None):
     override_project = project if project and project != "*" else None
     dag, project, message = generate_kfp_dag_and_resolve_project(
         kfp_run, override_project
@@ -740,12 +739,7 @@ def format_summary_from_kfp_run(kfp_run, project=None, session=None):
     run_id = get_in(kfp_run, "run.id")
 
     # enrich DAG with mlrun run info
-    if session:
-        runs = mlrun.api.utils.singletons.db.get_db().list_runs(
-            session, project=project, labels=f"workflow={run_id}"
-        )
-    else:
-        runs = get_run_db().list_runs(project=project, labels=f"workflow={run_id}")
+    runs = mlrun.db.get_run_db().list_runs(project=project, labels=f"workflow={run_id}")
 
     for run in runs:
         step = get_in(run, ["metadata", "labels", "mlrun/runner-pod"])

mlrun/launcher/base.py

@@ -25,6 +25,7 @@ import mlrun.kfpops
 import mlrun.lists
 import mlrun.model
 import mlrun.runtimes
+import mlrun.utils.regex
 from mlrun.utils import logger
 
 run_modes = ["pass"]
@@ -38,6 +39,56 @@ class BaseLauncher(abc.ABC):
     Each context will have its own implementation of the abstract methods while the common logic resides in this class
     """
 
+    def __init__(self, **kwargs):
+        pass
+
+    @abc.abstractmethod
+    def launch(
+        self,
+        runtime: "mlrun.runtimes.BaseRuntime",
+        task: Optional[
+            Union["mlrun.run.RunTemplate", "mlrun.run.RunObject", dict]
+        ] = None,
+        handler: Optional[Union[str, Callable]] = None,
+        name: Optional[str] = "",
+        project: Optional[str] = "",
+        params: Optional[dict] = None,
+        inputs: Optional[Dict[str, str]] = None,
+        out_path: Optional[str] = "",
+        workdir: Optional[str] = "",
+        artifact_path: Optional[str] = "",
+        watch: Optional[bool] = True,
+        schedule: Optional[
+            Union[str, mlrun.common.schemas.schedule.ScheduleCronTrigger]
+        ] = None,
+        hyperparams: Dict[str, list] = None,
+        hyper_param_options: Optional[mlrun.model.HyperParamOptions] = None,
+        verbose: Optional[bool] = None,
+        scrape_metrics: Optional[bool] = None,
+        local_code_path: Optional[str] = None,
+        auto_build: Optional[bool] = None,
+        param_file_secrets: Optional[Dict[str, str]] = None,
+        notifications: Optional[List[mlrun.model.Notification]] = None,
+        returns: Optional[List[Union[str, Dict[str, str]]]] = None,
+    ) -> "mlrun.run.RunObject":
+        """run the function from the server/client[local/remote]"""
+        pass
+
+    @abc.abstractmethod
+    def enrich_runtime(
+        self,
+        runtime: "mlrun.runtimes.base.BaseRuntime",
+        project_name: Optional[str] = "",
+    ):
+        pass
+
+    @staticmethod
+    @abc.abstractmethod
+    def _store_function(
+        runtime: "mlrun.runtimes.BaseRuntime", run: "mlrun.run.RunObject"
+    ):
+        pass
+
     def save_function(
         self,
         runtime: "mlrun.runtimes.BaseRuntime",
@@ -73,36 +124,9 @@ class BaseLauncher(abc.ABC):
         hash_key = hash_key if versioned else None
         return "db://" + runtime._function_uri(hash_key=hash_key, tag=tag)
 
-    @abc.abstractmethod
-    def launch(
-        self,
-        runtime: "mlrun.runtimes.BaseRuntime",
-        task: Optional[
-            Union["mlrun.run.RunTemplate", "mlrun.run.RunObject", dict]
-        ] = None,
-        handler: Optional[Union[str, Callable]] = None,
-        name: Optional[str] = "",
-        project: Optional[str] = "",
-        params: Optional[dict] = None,
-        inputs: Optional[Dict[str, str]] = None,
-        out_path: Optional[str] = "",
-        workdir: Optional[str] = "",
-        artifact_path: Optional[str] = "",
-        watch: Optional[bool] = True,
-        schedule: Optional[
-            Union[str, mlrun.common.schemas.schedule.ScheduleCronTrigger]
-        ] = None,
-        hyperparams: Dict[str, list] = None,
-        hyper_param_options: Optional[mlrun.model.HyperParamOptions] = None,
-        verbose: Optional[bool] = None,
-        scrape_metrics: Optional[bool] = None,
-        local_code_path: Optional[str] = None,
-        auto_build: Optional[bool] = None,
-        param_file_secrets: Optional[Dict[str, str]] = None,
-        notifications: Optional[List[mlrun.model.Notification]] = None,
-        returns: Optional[List[Union[str, Dict[str, str]]]] = None,
-    ) -> "mlrun.run.RunObject":
-        """run the function from the server/client[local/remote]"""
+    @staticmethod
+    def prepare_image_for_deploy(runtime: "mlrun.runtimes.BaseRuntime"):
+        """Check if the runtime requires to build the image and updates the spec accordingly"""
         pass
 
     def _validate_runtime(
@@ -190,8 +214,8 @@ class BaseLauncher(abc.ABC):
         # task is already a RunObject
         return task
 
+    @staticmethod
     def _enrich_run(
-        self,
         runtime,
         run,
         handler=None,
@@ -361,8 +385,8 @@ class BaseLauncher(abc.ABC):
                 name=run.metadata.name,
             )
             if run.status.state in [
-                mlrun.runtimes.base.RunStates.error,
-                mlrun.runtimes.base.RunStates.aborted,
+                mlrun.runtimes.constants.RunStates.error,
+                mlrun.runtimes.constants.RunStates.aborted,
             ]:
                 if runtime._is_remote and not runtime.is_child:
                     logger.error(
@@ -379,26 +403,6 @@ class BaseLauncher(abc.ABC):
     def _refresh_function_metadata(runtime: "mlrun.runtimes.BaseRuntime"):
         pass
 
-    @staticmethod
-    def prepare_image_for_deploy(runtime: "mlrun.runtimes.BaseRuntime"):
-        """Check if the runtime requires to build the image and updates the spec accordingly"""
-        pass
-
-    @staticmethod
-    @abc.abstractmethod
-    def enrich_runtime(
-        runtime: "mlrun.runtimes.base.BaseRuntime",
-        project_name: Optional[str] = "",
-    ):
-        pass
-
-    @staticmethod
-    @abc.abstractmethod
-    def _store_function(
-        runtime: "mlrun.runtimes.BaseRuntime", run: "mlrun.run.RunObject"
-    ):
-        pass
-
     @staticmethod
     def _log_track_results(
         runtime: "mlrun.runtimes.BaseRuntime", result: dict, run: "mlrun.run.RunObject"

mlrun/launcher/client.py

@@ -19,21 +19,22 @@ from typing import Optional
 import IPython
 
 import mlrun.errors
-import mlrun.launcher.base
+import mlrun.launcher.base as launcher
 import mlrun.lists
 import mlrun.model
 import mlrun.runtimes
 from mlrun.utils import logger
 
 
-class ClientBaseLauncher(mlrun.launcher.base.BaseLauncher, abc.ABC):
+class ClientBaseLauncher(launcher.BaseLauncher, abc.ABC):
     """
     Abstract class for common code between client launchers
     """
 
-    @staticmethod
     def enrich_runtime(
-        runtime: "mlrun.runtimes.base.BaseRuntime", project_name: Optional[str] = ""
+        self,
+        runtime: "mlrun.runtimes.base.BaseRuntime",
+        project_name: Optional[str] = "",
     ):
         runtime.try_auto_mount_based_on_config()
         runtime._fill_credentials()

mlrun/launcher/factory.py

@@ -11,17 +11,24 @@
 # 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.
+from dependency_injector import containers, providers
+
 import mlrun.config
 import mlrun.errors
 import mlrun.launcher.base
 import mlrun.launcher.local
 import mlrun.launcher.remote
+import mlrun.utils.singleton
+
 
+class LauncherFactory(
+    metaclass=mlrun.utils.singleton.AbstractSingleton,
+):
+    def __init__(self):
+        self._launcher_container = LauncherContainer()
 
-class LauncherFactory(object):
-    @staticmethod
     def create_launcher(
-        is_remote: bool, local: bool = False
+        self, is_remote: bool, **kwargs
     ) -> mlrun.launcher.base.BaseLauncher:
         """
         Creates the appropriate launcher for the specified run.
@@ -30,21 +37,25 @@ class LauncherFactory(object):
         ClientLocalLauncher - if the run is not remote or local was specified.
 
         :param is_remote:   Whether the runtime requires remote execution.
-        :param local:       Run the function locally vs on the Runtime/Cluster
 
         :return:            The appropriate launcher for the specified run.
         """
         if mlrun.config.is_running_as_api():
-            if local:
-                raise mlrun.errors.MLRunInternalServerError(
-                    "Launch of local run inside the server is not allowed"
-                )
+            return self._launcher_container.server_side_launcher(**kwargs)
 
-            from mlrun.api.launcher import ServerSideLauncher
+        local = kwargs.get("local", False)
+        if is_remote and not local:
+            return self._launcher_container.client_remote_launcher(**kwargs)
 
-            return ServerSideLauncher()
+        return self._launcher_container.client_local_launcher(**kwargs)
 
-        if is_remote and not local:
-            return mlrun.launcher.remote.ClientRemoteLauncher()
 
-        return mlrun.launcher.local.ClientLocalLauncher(local)
+class LauncherContainer(containers.DeclarativeContainer):
+    client_remote_launcher = providers.Factory(
+        mlrun.launcher.remote.ClientRemoteLauncher
+    )
+    client_local_launcher = providers.Factory(mlrun.launcher.local.ClientLocalLauncher)
+
+    # Provider for injection of a server side launcher.
+    # This allows us to override the launcher from external packages without having to import them.
+    server_side_launcher = providers.Factory(mlrun.launcher.base.BaseLauncher)

mlrun/launcher/local.py

@@ -17,7 +17,7 @@ from typing import Callable, Dict, List, Optional, Union
 
 import mlrun.common.schemas.schedule
 import mlrun.errors
-import mlrun.launcher.client
+import mlrun.launcher.client as launcher
 import mlrun.run
 import mlrun.runtimes.generators
 import mlrun.utils.clones
@@ -25,19 +25,19 @@ import mlrun.utils.notifications
 from mlrun.utils import logger
 
 
-class ClientLocalLauncher(mlrun.launcher.client.ClientBaseLauncher):
+class ClientLocalLauncher(launcher.ClientBaseLauncher):
     """
     ClientLocalLauncher is a launcher that runs the job locally.
     Either on the user's machine (_is_run_local is True) or on a remote machine (_is_run_local is False).
     """
 
-    def __init__(self, local: bool):
+    def __init__(self, local: bool = False, **kwargs):
         """
         Initialize a ClientLocalLauncher.
         :param local:   True if the job runs on the user's local machine,
                         False if it runs on a remote machine (e.g. a dedicated k8s pod).
         """
-        super().__init__()
+        super().__init__(**kwargs)
         self._is_run_local = local
 
     def launch(
@@ -119,14 +119,14 @@ class ClientLocalLauncher(mlrun.launcher.client.ClientBaseLauncher):
             notifications=notifications,
         )
         self._validate_runtime(runtime, run)
-        result = self.execute(
+        result = self._execute(
             runtime=runtime,
             run=run,
         )
 
         return result
 
-    def execute(
+    def _execute(
         self,
         runtime: "mlrun.runtimes.BaseRuntime",
         run: Optional[Union["mlrun.run.RunTemplate", "mlrun.run.RunObject"]] = None,

mlrun/launcher/remote.py

@@ -19,7 +19,7 @@ import requests
 import mlrun.common.schemas.schedule
 import mlrun.db
 import mlrun.errors
-import mlrun.launcher.client
+import mlrun.launcher.client as launcher
 import mlrun.run
 import mlrun.runtimes
 import mlrun.runtimes.generators
@@ -28,7 +28,7 @@ import mlrun.utils.notifications
 from mlrun.utils import logger
 
 
-class ClientRemoteLauncher(mlrun.launcher.client.ClientBaseLauncher):
+class ClientRemoteLauncher(launcher.ClientBaseLauncher):
     def launch(
         self,
         runtime: "mlrun.runtimes.KubejobRuntime",
@@ -106,9 +106,9 @@ class ClientRemoteLauncher(mlrun.launcher.client.ClientBaseLauncher):
         )
         self._store_function(runtime, run)
 
-        return self.submit_job(runtime, run, schedule, watch)
+        return self._submit_job(runtime, run, schedule, watch)
 
-    def submit_job(
+    def _submit_job(
         self,
         runtime: "mlrun.runtimes.KubejobRuntime",
         run: "mlrun.run.RunObject",

mlrun/lists.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 warnings
 from copy import copy
 from typing import List
 
@@ -220,16 +219,6 @@ class ArtifactList(list):
         """return as a list of artifact objects"""
         return [dict_to_artifact(artifact) for artifact in self]
 
-    def objects(self) -> List[Artifact]:
-        """return as a list of artifact objects"""
-        warnings.warn(
-            "'objects' is deprecated in 1.3.0 and will be removed in 1.5.0. "
-            "Use 'to_objects' instead.",
-            # TODO: remove in 1.5.0
-            FutureWarning,
-        )
-        return [dict_to_artifact(artifact) for artifact in self]
-
     def dataitems(self) -> List["mlrun.DataItem"]:
         """return as a list of DataItem objects"""
         dataitems = []

mlrun/model.py

@@ -137,6 +137,8 @@ class ModelObj:
 
 # model class for building ModelObj dictionaries
 class ObjectDict:
+    kind = "object_dict"
+
     def __init__(self, classes_map, default_kind=""):
         self._children = OrderedDict()
         self._default_kind = default_kind
@@ -903,7 +905,7 @@ class RunSpec(ModelObj):
 
     def extract_type_hints_from_inputs(self):
         """
-        This method extracts the type hints from the inputs keys in the input dictionary.
+        This method extracts the type hints from the input keys in the input dictionary.
 
         As a result, after the method ran the inputs dictionary - a dictionary of parameter names as keys and paths as
         values, will be cleared from type hints and the extracted type hints will be saved in the spec's inputs type
@@ -986,7 +988,7 @@ class RunSpec(ModelObj):
         # Validate correct pattern:
         if input_key.count(":") > 1:
             raise mlrun.errors.MLRunInvalidArgumentError(
-                f"Incorrect input pattern. Inputs keys can have only a single ':' in them to specify the desired type "
+                f"Incorrect input pattern. Input keys can have only a single ':' in them to specify the desired type "
                 f"the input will be parsed as. Given: {input_key}."
             )
 
@@ -1309,25 +1311,17 @@ class RunObject(RunTemplate):
         """return or watch on the run logs"""
         if not db:
             db = mlrun.get_run_db()
+
         if not db:
-            print("DB is not configured, cannot show logs")
+            logger.warning("DB is not configured, cannot show logs")
             return None
 
-        new_offset = 0
-        if db.kind == "http":
-            state, new_offset = db.watch_log(
-                self.metadata.uid, self.metadata.project, watch=watch, offset=offset
-            )
-        # not expected to reach this else, as FileDB is not supported any more and because we don't watch logs on API
-        else:
-            state, text = db.get_log(
-                self.metadata.uid, self.metadata.project, offset=offset
-            )
-            if text:
-                print(text.decode())
-
+        state, new_offset = db.watch_log(
+            self.metadata.uid, self.metadata.project, watch=watch, offset=offset
+        )
         if state:
-            print(f"final state: {state}")
+            logger.debug("Run reached terminal state", state=state)
+
         return state, new_offset
 
     def wait_for_completion(

mlrun/model_monitoring/__init__.py

@@ -15,27 +15,7 @@
 # flake8: noqa  - this is until we take care of the F401 violations with respect to __all__ & sphinx
 # for backwards compatibility
 
-__all__ = [
-    "ModelEndpoint",
-    "EventFieldType",
-    "EventLiveStats",
-    "EventKeyMetrics",
-    "TimeSeriesTarget",
-    "ModelEndpointTarget",
-    "FileTargetKind",
-    "ProjectSecretKeys",
-    "ModelMonitoringStoreKinds",
-]
-
-from mlrun.common.model_monitoring import (
-    EventFieldType,
-    EventKeyMetrics,
-    EventLiveStats,
-    FileTargetKind,
-    ModelEndpointTarget,
-    ModelMonitoringStoreKinds,
-    ProjectSecretKeys,
-    TimeSeriesTarget,
-)
 
+from .helpers import get_stream_path
 from .model_endpoint import ModelEndpoint
+from .stores import ModelEndpointStore, ModelEndpointStoreType, get_model_endpoint_store

mlrun/model_monitoring/features_drift_table.py

@@ -18,7 +18,7 @@ import numpy as np
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 
-from .model_monitoring_batch import DriftResultType, DriftStatus
+from mlrun.model_monitoring.model_monitoring_batch import DriftResultType, DriftStatus
 
 
 class FeaturesDriftTablePlot: