mlrun 1.8.0rc15__py3-none-any.whl → 1.8.0rc17__py3-none-any.whl

mlrun/artifacts/document.py

@@ -47,6 +47,7 @@ class DocumentLoaderSpec(ModelObj):
         self,
         loader_class_name: str = "langchain_community.document_loaders.TextLoader",
         src_name: str = "file_path",
+        download_object: bool = False,
         kwargs: Optional[dict] = None,
     ):
         """
@@ -56,7 +57,9 @@ class DocumentLoaderSpec(ModelObj):
             loader_class_name (str): The name of the loader class to use.
             src_name (str): The source name for the document.
             kwargs (Optional[dict]): Additional keyword arguments to pass to the loader class.
-
+            download_object (bool, optional): If True, the file will be downloaded before launching
+                the loader. If False, the loader accepts a link that should not be downloaded.
+                Defaults to False.
         Example:
             >>> # Create a loader specification for PDF documents
             >>> loader_spec = DocumentLoaderSpec(
@@ -72,6 +75,7 @@ class DocumentLoaderSpec(ModelObj):
         """
         self.loader_class_name = loader_class_name
         self.src_name = src_name
+        self.download_object = download_object
         self.kwargs = kwargs
 
     def make_loader(self, src_path):
@@ -251,6 +255,9 @@ class DocumentArtifact(Artifact):
             "collections",
             "original_source",
         ]
+        _exclude_fields_from_uid_hash = ArtifactSpec._exclude_fields_from_uid_hash + [
+            "collections",
+        ]
 
         def __init__(
             self,
@@ -270,7 +277,6 @@ class DocumentArtifact(Artifact):
     METADATA_SOURCE_KEY = "source"
     METADATA_ORIGINAL_SOURCE_KEY = "original_source"
     METADATA_CHUNK_KEY = "mlrun_chunk"
-    METADATA_ARTIFACT_URI_KEY = "mlrun_object_uri"
     METADATA_ARTIFACT_TARGET_PATH_KEY = "mlrun_target_path"
     METADATA_ARTIFACT_TAG = "mlrun_tag"
     METADATA_ARTIFACT_KEY = "mlrun_key"
@@ -321,7 +327,7 @@ class DocumentArtifact(Artifact):
         """
 
         loader_spec = DocumentLoaderSpec.from_dict(self.spec.document_loader)
-        if self.get_target_path():
+        if loader_spec.download_object and self.get_target_path():
             with tempfile.NamedTemporaryFile() as tmp_file:
                 mlrun.datastore.store_manager.object(
                     url=self.get_target_path()
@@ -348,7 +354,6 @@ class DocumentArtifact(Artifact):
 
             metadata[self.METADATA_ORIGINAL_SOURCE_KEY] = self.spec.original_source
             metadata[self.METADATA_SOURCE_KEY] = self.get_source()
-            metadata[self.METADATA_ARTIFACT_URI_KEY] = self.uri
             metadata[self.METADATA_ARTIFACT_TAG] = self.tag or "latest"
             metadata[self.METADATA_ARTIFACT_KEY] = self.key
             metadata[self.METADATA_ARTIFACT_PROJECT] = self.metadata.project

mlrun/common/model_monitoring/helpers.py

@@ -38,12 +38,10 @@ def parse_model_endpoint_store_prefix(store_prefix: str):
 
 def parse_monitoring_stream_path(
     stream_uri: str, project: str, function_name: typing.Optional[str] = None
-):
+) -> str:
     if stream_uri.startswith("kafka://"):
         if "?topic" in stream_uri:
-            raise mlrun.errors.MLRunInvalidArgumentError(
-                "Custom kafka topic is not allowed"
-            )
+            raise mlrun.errors.MLRunValueError("Custom kafka topic is not allowed")
         # Add topic to stream kafka uri
         if (
             function_name is None
@@ -53,22 +51,6 @@ def parse_monitoring_stream_path(
         else:
             stream_uri += f"?topic=monitoring_stream_{project}_{function_name}"
 
-    elif stream_uri.startswith("v3io://") and mlrun.mlconf.is_ce_mode():
-        # V3IO is not supported in CE mode, generating a default http stream path
-        if function_name is None:
-            stream_uri = (
-                mlrun.mlconf.model_endpoint_monitoring.default_http_sink.format(
-                    project=project, namespace=mlrun.mlconf.namespace
-                )
-            )
-        else:
-            stream_uri = (
-                mlrun.mlconf.model_endpoint_monitoring.default_http_sink_app.format(
-                    project=project,
-                    application_name=function_name,
-                    namespace=mlrun.mlconf.namespace,
-                )
-            )
     return stream_uri
 
 

mlrun/common/schemas/client_spec.py

@@ -66,3 +66,4 @@ class ClientSpec(pydantic.v1.BaseModel):
     packagers: typing.Optional[dict]
     external_platform_tracking: typing.Optional[dict]
     alerts_mode: typing.Optional[str]
+    system_id: typing.Optional[str]

mlrun/common/schemas/model_monitoring/constants.py

@@ -75,6 +75,7 @@ class ModelEndpointCreationStrategy(MonitoringStrEnum):
     INPLACE = "inplace"
     ARCHIVE = "archive"
     OVERWRITE = "overwrite"
+    SKIP = "skip"
 
 
 class EventFieldType:
@@ -236,6 +237,8 @@ class ProjectSecretKeys:
     ACCESS_KEY = "MODEL_MONITORING_ACCESS_KEY"
     STREAM_PATH = "STREAM_PATH"
     TSDB_CONNECTION = "TSDB_CONNECTION"
+    TSDB_PROFILE_NAME = "TSDB_PROFILE_NAME"
+    STREAM_PROFILE_NAME = "STREAM_PROFILE_NAME"
 
     @classmethod
     def mandatory_secrets(cls):

mlrun/config.py

@@ -603,10 +603,6 @@ default_config = {
         # Offline storage path can be either relative or a full path. This path is used for general offline data
         # storage such as the parquet file which is generated from the monitoring stream function for the drift analysis
         "offline_storage_path": "model-endpoints/{kind}",
-        # Default http path that points to the monitoring stream nuclio function. Will be used as a stream path
-        # when the user is working in CE environment and has not provided any stream path.
-        "default_http_sink": "http://nuclio-{project}-model-monitoring-stream.{namespace}.svc.cluster.local:8080",
-        "default_http_sink_app": "http://nuclio-{project}-{application_name}.{namespace}.svc.cluster.local:8080",
         "parquet_batching_max_events": 10_000,
         "parquet_batching_timeout_secs": timedelta(minutes=1).total_seconds(),
         # See mlrun.model_monitoring.db.tsdb.ObjectTSDBFactory for available options

mlrun/datastore/datastore_profile.py

@@ -11,7 +11,7 @@
 # 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 ast
 import base64
 import json
@@ -549,6 +549,35 @@ class DatastoreProfile2Json(pydantic.v1.BaseModel):
 
 
 def datastore_profile_read(url, project_name="", secrets: typing.Optional[dict] = None):
+    """
+    Read and retrieve a datastore profile from a given URL.
+
+    This function retrieves a datastore profile either from temporary client storage,
+    or from the MLRun database. It handles both client-side and server-side profile formats
+    and performs necessary conversions.
+
+    Args:
+        url (str): A URL with 'ds' scheme pointing to the datastore profile
+            (e.g., 'ds://profile-name').
+        project_name (str, optional): The project name where the profile is stored.
+            Defaults to MLRun's default project.
+        secrets (dict, optional): Dictionary containing secrets needed for profile retrieval.
+
+    Returns:
+        DatastoreProfile: The retrieved datastore profile object.
+
+    Raises:
+        MLRunInvalidArgumentError: In the following cases:
+            - If the URL scheme is not 'ds'
+            - If the profile cannot be retrieved from either server or local environment
+
+    Note:
+       When running from a client environment (outside MLRun pods), private profile information
+       is not accessible. In this case, use register_temporary_client_datastore_profile() to
+       register the profile with credentials for your local session. When running inside MLRun
+       pods, the private information is automatically available and no temporary registration is needed.
+    """
+
     parsed_url = urlparse(url)
     if parsed_url.scheme.lower() != "ds":
         raise mlrun.errors.MLRunInvalidArgumentError(
@@ -580,7 +609,7 @@ def datastore_profile_read(url, project_name="", secrets: typing.Optional[dict]
     )
     private_body = get_secret_or_env(project_ds_name_private, secret_provider=secrets)
     if not public_profile or not private_body:
-        raise mlrun.errors.MLRunInvalidArgumentError(
+        raise mlrun.errors.MLRunNotFoundError(
             f"Unable to retrieve the datastore profile '{url}' from either the server or local environment. "
             "Make sure the profile is registered correctly, or if running in a local environment, "
             "use register_temporary_client_datastore_profile() to provide credentials locally."

mlrun/db/base.py

@@ -1079,7 +1079,7 @@ class RunDBInterface(ABC):
     def set_model_monitoring_credentials(
         self,
         project: str,
-        credentials: dict[str, str],
+        credentials: dict[str, Optional[str]],
         replace_creds: bool,
     ) -> None:
         pass

mlrun/db/httpdb.py

@@ -580,6 +580,7 @@ class HTTPRunDB(RunDBInterface):
                 or config.feature_store.default_targets
             )
             config.alerts.mode = server_cfg.get("alerts_mode") or config.alerts.mode
+            config.system_id = server_cfg.get("system_id") or config.system_id
 
         except Exception as exc:
             logger.warning(
@@ -773,7 +774,7 @@ class HTTPRunDB(RunDBInterface):
 
         response = self.api_call(
             "POST",
-            path=f"projects/{project}/runs/{uid}/push_notifications",
+            path=f"projects/{project}/runs/{uid}/push-notifications",
             error="Failed push notifications",
             timeout=timeout,
         )
@@ -4017,7 +4018,7 @@ class HTTPRunDB(RunDBInterface):
     def set_model_monitoring_credentials(
         self,
         project: str,
-        credentials: dict[str, str],
+        credentials: dict[str, Optional[str]],
         replace_creds: bool,
     ) -> None:
         """

mlrun/db/nopdb.py

@@ -872,7 +872,7 @@ class NopDB(RunDBInterface):
     def set_model_monitoring_credentials(
         self,
         project: str,
-        credentials: dict[str, str],
+        credentials: dict[str, Optional[str]],
         replace_creds: bool,
     ) -> None:
         pass

mlrun/execution.py

@@ -884,6 +884,7 @@ class MLClientCtx:
         upload: Optional[bool] = False,
         labels: Optional[dict[str, str]] = None,
         target_path: Optional[str] = None,
+        db_key: Optional[str] = None,
         **kwargs,
     ) -> DocumentArtifact:
         """
@@ -914,6 +915,8 @@ class MLClientCtx:
         :param upload: Whether to upload the artifact
         :param labels: Key-value labels
         :param target_path: Path to the local file
+        :param db_key: The key to use in the artifact DB table, by default its run name + '_' + key
+                       db_key=False will not register it in the artifacts table
         :param kwargs: Additional keyword arguments
         :return: DocumentArtifact object
 
@@ -943,6 +946,9 @@ class MLClientCtx:
             tag=tag,
             upload=upload,
             labels=labels,
+            local_path=local_path,
+            target_path=target_path,
+            db_key=db_key,
         )
         self._update_run()
         return item

mlrun/model_monitoring/__init__.py

@@ -12,8 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# for backwards compatibility
-
 from mlrun.common.schemas import ModelEndpoint, ModelEndpointList
 
 from .db import get_tsdb_connector

mlrun/model_monitoring/applications/base.py

@@ -93,7 +93,7 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
         context: "mlrun.MLClientCtx",
         sample_data: Optional[pd.DataFrame] = None,
         reference_data: Optional[pd.DataFrame] = None,
-        endpoint_names: Optional[list[str]] = None,
+        endpoints: Optional[list[tuple[str, str]]] = None,
         start: Optional[datetime] = None,
         end: Optional[datetime] = None,
     ):
@@ -121,12 +121,13 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
             )
             return self.do_tracking(monitoring_context)
 
-        if endpoint_names is not None:
+        if endpoints is not None:
             start, end = self._validate_times(start, end)
-            for endpoint_name in endpoint_names:
+            for endpoint_name, endpoint_id in endpoints:
                 result = call_do_tracking(
                     event={
                         mm_constants.ApplicationEvent.ENDPOINT_NAME: endpoint_name,
+                        mm_constants.ApplicationEvent.ENDPOINT_ID: endpoint_id,
                         mm_constants.ApplicationEvent.START_INFER_TIME: start,
                         mm_constants.ApplicationEvent.END_INFER_TIME: end,
                     }
@@ -199,7 +200,7 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
         with_repo: Optional[bool] = False,
         requirements: Optional[Union[str, list[str]]] = None,
         requirements_file: str = "",
-        endpoint_names: Optional[list[str]] = None,
+        endpoints: Optional[list[tuple[str, str]]] = None,
         start: Optional[datetime] = None,
         end: Optional[datetime] = None,
     ) -> "mlrun.RunObject":
@@ -208,20 +209,23 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
         :py:meth:`~mlrun.model_monitoring.applications.ModelMonitoringApplicationBase.do_tracking`
         model monitoring logic as a :py:class:`~mlrun.runtimes.KubejobRuntime`, which is an MLRun function.
 
-        :param func_path: The path to the function. If not passed, the current notebook is used.
-        :param func_name: The name of the function. If not passed, the class name is used.
-        :param tag:       An optional tag for the function.
-        :param run_local: Whether to run the function locally or remotely.
-        :param sample_data:       Optional - pandas data-frame as the current dataset.
+        This method has default values for all of its arguments. You should be change them when you want to pass
+        data to the application.
+
+        :param func_path:         The path to the function. If ``None``, the current notebook is used.
+        :param func_name:         The name of the function. If not ``None``, the class name is used.
+        :param tag:               Tag for the function.
+        :param run_local:         Whether to run the function locally or remotely.
+        :param sample_data:       Pandas data-frame as the current dataset.
                                   When set, it replaces the data read from the model endpoint's offline source.
-        :param reference_data:    Optional - pandas data-frame of the reference dataset.
+        :param reference_data:    Pandas data-frame of the reference dataset.
                                   When set, its statistics override the model endpoint's feature statistics.
         :param image:             Docker image to run the job on.
         :param with_repo:         Whether to clone the current repo to the build source.
         :param requirements:      List of Python requirements to be installed in the image.
         :param requirements_file: Path to a Python requirements file to be installed in the image.
-        :param endpoint_names:    The model endpoint names to get the data from. When the names are passed,
-                                  you have to provide also the start and end times of the data to analyze.
+        :param endpoints:         A list of tuples of the model endpoint (name, uid) to get the data from.
+                                  If provided, you have to provide also the start and end times of the data to analyze.
         :param start:             The start time of the sample data.
         :param end:               The end time of the sample data.
 
@@ -249,12 +253,16 @@ class ModelMonitoringApplicationBase(MonitoringApplicationToDict, ABC):
             ),
         )
 
-        params: dict[str, Union[list[str], datetime]] = {}
-        if endpoint_names:
+        params: dict[str, Union[list[tuple[str, str]], datetime]] = {}
+        if endpoints:
             start, end = cls._validate_times(start, end)
-            params["endpoint_names"] = endpoint_names
+            params["endpoints"] = endpoints
             params["start"] = start
             params["end"] = end
+        elif start or end:
+            raise mlrun.errors.MLRunValueError(
+                "Custom start or end times are supported only with endpoints data"
+            )
 
         inputs: dict[str, str] = {}
         for data, identifier in [

mlrun/model_monitoring/applications/context.py

@@ -190,18 +190,13 @@ class MonitoringApplicationContext:
         )
 
     def _get_default_labels(self) -> dict[str, str]:
-        labels = {
+        return {
             mlrun_constants.MLRunInternalLabels.runner_pod: socket.gethostname(),
             mlrun_constants.MLRunInternalLabels.producer_type: "model-monitoring-app",
             mlrun_constants.MLRunInternalLabels.app_name: self.application_name,
+            mlrun_constants.MLRunInternalLabels.endpoint_id: self.endpoint_id,
+            mlrun_constants.MLRunInternalLabels.endpoint_name: self.endpoint_name,
         }
-        for key, value in [
-            (mlrun_constants.MLRunInternalLabels.endpoint_id, self.endpoint_id),
-            (mlrun_constants.MLRunInternalLabels.endpoint_name, self.endpoint_name),
-        ]:
-            if value:
-                labels[key] = value
-        return labels
 
     def _add_default_labels(self, labels: Optional[dict[str, str]]) -> dict[str, str]:
         """Add the default labels to logged artifacts labels"""

mlrun/model_monitoring/db/tsdb/__init__.py

@@ -16,7 +16,9 @@ import enum
 import typing
 
 import mlrun.common.schemas.secret
+import mlrun.datastore.datastore_profile
 import mlrun.errors
+import mlrun.model_monitoring.helpers
 
 from .base import TSDBConnector
 
@@ -80,6 +82,13 @@ def get_tsdb_connector(
             or the provided TSDB connection is invalid.
     """
 
+    try:
+        profile = mlrun.model_monitoring.helpers._get_tsdb_profile(
+            project=project, secret_provider=secret_provider
+        )
+    except mlrun.errors.MLRunNotFoundError:
+        profile = None
+
     tsdb_connection_string = (
         tsdb_connection_string
         or mlrun.model_monitoring.helpers.get_tsdb_connection_string(
@@ -92,6 +101,9 @@ def get_tsdb_connector(
         kwargs["connection_string"] = tsdb_connection_string
     elif tsdb_connection_string and tsdb_connection_string == "v3io":
         tsdb_connector_type = mlrun.common.schemas.model_monitoring.TSDBTarget.V3IO_TSDB
+    elif isinstance(profile, mlrun.datastore.datastore_profile.DatastoreProfileV3io):
+        tsdb_connector_type = mlrun.common.schemas.model_monitoring.TSDBTarget.V3IO_TSDB
+        kwargs["v3io_access_key"] = profile.v3io_access_key
     else:
         raise mlrun.errors.MLRunInvalidMMStoreTypeError(
             "You must provide a valid tsdb store connection by using "

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

@@ -58,6 +58,7 @@ class V3IOTSDBConnector(TSDBConnector):
         project: str,
         container: str = _CONTAINER,
         v3io_framesd: Optional[str] = None,
+        v3io_access_key: str = "",
         create_table: bool = False,
     ) -> None:
         super().__init__(project=project)
@@ -65,6 +66,7 @@ class V3IOTSDBConnector(TSDBConnector):
         self.container = container
 
         self.v3io_framesd = v3io_framesd or mlrun.mlconf.v3io_framesd
+        self._v3io_access_key = v3io_access_key
         self._frames_client: Optional[v3io_frames.client.ClientBase] = None
         self._init_tables_path()
         self._create_table = create_table
@@ -72,7 +74,9 @@ class V3IOTSDBConnector(TSDBConnector):
     @property
     def frames_client(self) -> v3io_frames.client.ClientBase:
         if not self._frames_client:
-            self._frames_client = self._get_v3io_frames_client(self.container)
+            self._frames_client = self._get_v3io_frames_client(
+                self.container, v3io_access_key=self._v3io_access_key
+            )
             if self._create_table:
                 self.create_tables()
         return self._frames_client
@@ -564,10 +568,13 @@ class V3IOTSDBConnector(TSDBConnector):
         return source_directory
 
     @staticmethod
-    def _get_v3io_frames_client(v3io_container: str) -> v3io_frames.client.ClientBase:
+    def _get_v3io_frames_client(
+        v3io_container: str, v3io_access_key: str = ""
+    ) -> v3io_frames.client.ClientBase:
         return mlrun.utils.v3io_clients.get_frames_client(
             address=mlrun.mlconf.v3io_framesd,
             container=v3io_container,
+            token=v3io_access_key,
         )
 
     def read_metrics_data(

mlrun/model_monitoring/helpers.py

@@ -13,25 +13,20 @@
 # limitations under the License.
 
 import datetime
+import functools
 import os
-import typing
+from fnmatch import fnmatchcase
+from typing import TYPE_CHECKING, Callable, Optional, TypedDict, cast
 
 import numpy as np
 import pandas as pd
 
-if typing.TYPE_CHECKING:
-    from mlrun.datastore import DataItem
-    from mlrun.db.base import RunDBInterface
-    from mlrun.projects import MlrunProject
-
-from fnmatch import fnmatchcase
-from typing import Optional
-
 import mlrun
 import mlrun.artifacts
 import mlrun.common.model_monitoring.helpers
 import mlrun.common.schemas.model_monitoring.constants as mm_constants
 import mlrun.data_types.infer
+import mlrun.datastore.datastore_profile
 import mlrun.model_monitoring
 import mlrun.utils.helpers
 from mlrun.common.schemas import ModelEndpoint
@@ -41,8 +36,13 @@ from mlrun.common.schemas.model_monitoring.model_endpoints import (
 )
 from mlrun.utils import logger
 
+if TYPE_CHECKING:
+    from mlrun.datastore import DataItem
+    from mlrun.db.base import RunDBInterface
+    from mlrun.projects import MlrunProject
+
 
-class _BatchDict(typing.TypedDict):
+class _BatchDict(TypedDict):
     minutes: int
     hours: int
     days: int
@@ -115,20 +115,30 @@ def filter_results_by_regex(
 def get_stream_path(
     project: str,
     function_name: str = mm_constants.MonitoringFunctionNames.STREAM,
-    stream_uri: typing.Optional[str] = None,
+    stream_uri: Optional[str] = None,
+    secret_provider: Optional[Callable[[str], str]] = None,
 ) -> str:
     """
     Get stream path from the project secret. If wasn't set, take it from the system configurations
 
     :param project:             Project name.
     :param function_name:       Application name. Default is model_monitoring_stream.
-    :param stream_uri:          Stream URI. If provided, it will be used instead of the one from the project secret.
-
+    :param stream_uri:          Stream URI. If provided, it will be used instead of the one from the project's secret.
+    :param secret_provider:     Optional secret provider to get the connection string secret.
+                                If not set, the env vars are used.
     :return:                    Monitoring stream path to the relevant application.
     """
 
+    try:
+        profile = _get_stream_profile(project=project, secret_provider=secret_provider)
+    except mlrun.errors.MLRunNotFoundError:
+        profile = None
+
+    if isinstance(profile, mlrun.datastore.datastore_profile.DatastoreProfileV3io):
+        stream_uri = "v3io"
+
     stream_uri = stream_uri or mlrun.get_secret_or_env(
-        mm_constants.ProjectSecretKeys.STREAM_PATH
+        key=mm_constants.ProjectSecretKeys.STREAM_PATH, secret_provider=secret_provider
     )
 
     if not stream_uri or stream_uri == "v3io":
@@ -230,7 +240,7 @@ def get_monitoring_drift_measures_data(project: str, endpoint_id: str) -> "DataI
 
 
 def get_tsdb_connection_string(
-    secret_provider: typing.Optional[typing.Callable[[str], str]] = None,
+    secret_provider: Optional[Callable[[str], str]] = None,
 ) -> str:
     """Get TSDB connection string from the project secret. If wasn't set, take it from the system
     configurations.
@@ -244,6 +254,40 @@ def get_tsdb_connection_string(
     )
 
 
+def _get_profile(
+    project: str,
+    secret_provider: Optional[Callable[[str], str]],
+    profile_name_key: str,
+) -> mlrun.datastore.datastore_profile.DatastoreProfile:
+    """
+    Get the datastore profile from the project name and secret provider, where the profile's name
+    is saved as a secret named `profile_name_key`.
+
+    :param project:          The project name.
+    :param secret_provider:  Secret provider to get the secrets from, or `None` for env vars.
+    :param profile_name_key: The profile name key in the secret store.
+    :return:                 Datastore profile.
+    """
+    profile_name = mlrun.get_secret_or_env(
+        key=profile_name_key, secret_provider=secret_provider
+    )
+    if not profile_name:
+        raise mlrun.errors.MLRunNotFoundError(
+            f"Not found `{profile_name_key}` profile name"
+        )
+    return mlrun.datastore.datastore_profile.datastore_profile_read(
+        url=f"ds://{profile_name}", project_name=project, secrets=secret_provider
+    )
+
+
+_get_tsdb_profile = functools.partial(
+    _get_profile, profile_name_key=mm_constants.ProjectSecretKeys.TSDB_PROFILE_NAME
+)
+_get_stream_profile = functools.partial(
+    _get_profile, profile_name_key=mm_constants.ProjectSecretKeys.STREAM_PROFILE_NAME
+)
+
+
 def batch_dict2timedelta(batch_dict: _BatchDict) -> datetime.timedelta:
     """
     Convert a batch dictionary to timedelta.
@@ -431,7 +475,7 @@ def get_invocations_metric(project: str) -> ModelEndpointMonitoringMetric:
 
 
 def _get_monitoring_schedules_folder_path(project: str) -> str:
-    return typing.cast(
+    return cast(
         str,
         mlrun.mlconf.get_model_monitoring_file_target_path(
             project=project, kind=mm_constants.FileTargetKind.MONITORING_SCHEDULES