mlrun 1.7.1rc4__py3-none-any.whl → 1.8.0rc8__py3-none-any.whl

mlrun/projects/project.py

@@ -28,21 +28,20 @@ import warnings
 import zipfile
 from copy import deepcopy
 from os import environ, makedirs, path
-from typing import Callable, Optional, Union
+from typing import Callable, Optional, Union, cast
 
 import dotenv
 import git
 import git.exc
-import mlrun_pipelines.common.models
-import mlrun_pipelines.mounts
 import nuclio.utils
 import requests
 import yaml
-from mlrun_pipelines.models import PipelineNodeWrapper
 
+import mlrun.artifacts.model
 import mlrun.common.formatters
 import mlrun.common.helpers
 import mlrun.common.runtimes.constants
+import mlrun.common.schemas.alert
 import mlrun.common.schemas.artifact
 import mlrun.common.schemas.model_monitoring.constants as mm_constants
 import mlrun.db
@@ -51,18 +50,37 @@ import mlrun.k8s_utils
 import mlrun.lists
 import mlrun.model_monitoring.applications as mm_app
 import mlrun.runtimes
+import mlrun.runtimes.mounts
 import mlrun.runtimes.nuclio.api_gateway
 import mlrun.runtimes.pod
 import mlrun.runtimes.utils
 import mlrun.serving
 import mlrun.utils
 import mlrun.utils.regex
+import mlrun_pipelines.common.models
 from mlrun.alerts.alert import AlertConfig
-from mlrun.common.schemas.alert import AlertTemplate
-from mlrun.datastore.datastore_profile import DatastoreProfile, DatastoreProfile2Json
+from mlrun.common.schemas import alert as alert_constants
+from mlrun.datastore.datastore_profile import (
+    DatastoreProfile,
+    DatastoreProfile2Json,
+    datastore_profile_read,
+)
+from mlrun.datastore.vectorstore import VectorStoreCollection
+from mlrun.model_monitoring.helpers import (
+    filter_results_by_regex,
+    get_result_instance_fqn,
+)
 from mlrun.runtimes.nuclio.function import RemoteRuntime
+from mlrun_pipelines.models import PipelineNodeWrapper
 
-from ..artifacts import Artifact, ArtifactProducer, DatasetArtifact, ModelArtifact
+from ..artifacts import (
+    Artifact,
+    ArtifactProducer,
+    DatasetArtifact,
+    DocumentArtifact,
+    DocumentLoaderSpec,
+    ModelArtifact,
+)
 from ..artifacts.manager import ArtifactManager, dict_to_artifact, extend_artifact_path
 from ..datastore import store_manager
 from ..features import Feature
@@ -126,15 +144,15 @@ def new_project(
     context: str = "./",
     init_git: bool = False,
     user_project: bool = False,
-    remote: str = None,
-    from_template: str = None,
-    secrets: dict = None,
-    description: str = None,
-    subpath: str = None,
+    remote: Optional[str] = None,
+    from_template: Optional[str] = None,
+    secrets: Optional[dict] = None,
+    description: Optional[str] = None,
+    subpath: Optional[str] = None,
     save: bool = True,
     overwrite: bool = False,
-    parameters: dict = None,
-    default_function_node_selector: dict = None,
+    parameters: Optional[dict] = None,
+    default_function_node_selector: Optional[dict] = None,
 ) -> "MlrunProject":
     """Create a new MLRun project, optionally load it from a yaml/zip/git template
 
@@ -291,17 +309,17 @@ def new_project(
 
 def load_project(
     context: str = "./",
-    url: str = None,
-    name: str = None,
-    secrets: dict = None,
+    url: Optional[str] = None,
+    name: Optional[str] = None,
+    secrets: Optional[dict] = None,
     init_git: bool = False,
-    subpath: str = None,
+    subpath: Optional[str] = None,
     clone: bool = False,
     user_project: bool = False,
     save: bool = True,
     sync_functions: bool = False,
-    parameters: dict = None,
-    allow_cross_project: bool = None,
+    parameters: Optional[dict] = None,
+    allow_cross_project: Optional[bool] = None,
 ) -> "MlrunProject":
     """Load an MLRun project from git or tar or dir
 
@@ -437,16 +455,16 @@ def load_project(
 def get_or_create_project(
     name: str,
     context: str = "./",
-    url: str = None,
-    secrets: dict = None,
+    url: Optional[str] = None,
+    secrets: Optional[dict] = None,
     init_git=False,
-    subpath: str = None,
+    subpath: Optional[str] = None,
     clone: bool = False,
     user_project: bool = False,
-    from_template: str = None,
+    from_template: Optional[str] = None,
     save: bool = True,
-    parameters: dict = None,
-    allow_cross_project: bool = None,
+    parameters: Optional[dict] = None,
+    allow_cross_project: Optional[bool] = None,
 ) -> "MlrunProject":
     """Load a project from MLRun DB, or create/import if it does not exist
 
@@ -823,14 +841,14 @@ class ProjectSpec(ModelObj):
         origin_url=None,
         goals=None,
         load_source_on_run=None,
-        default_requirements: typing.Union[str, list[str]] = None,
+        default_requirements: Optional[typing.Union[str, list[str]]] = None,
         desired_state=mlrun.common.schemas.ProjectState.online.value,
         owner=None,
         disable_auto_mount=None,
         workdir=None,
         default_image=None,
         build=None,
-        custom_packagers: list[tuple[str, bool]] = None,
+        custom_packagers: Optional[list[tuple[str, bool]]] = None,
         default_function_node_selector=None,
     ):
         self.repo = None
@@ -1253,7 +1271,11 @@ class MlrunProject(ModelObj):
             raise exc
 
     def get_artifact_uri(
-        self, key: str, category: str = "artifact", tag: str = None, iter: int = None
+        self,
+        key: str,
+        category: str = "artifact",
+        tag: Optional[str] = None,
+        iter: Optional[int] = None,
     ) -> str:
         """return the project artifact uri (store://..) from the artifact key
 
@@ -1353,7 +1375,7 @@ class MlrunProject(ModelObj):
         workflow_path: str,
         embed: bool = False,
         engine: Optional[str] = None,
-        args_schema: list[EntrypointParam] = None,
+        args_schema: Optional[list[EntrypointParam]] = None,
         handler: Optional[str] = None,
         schedule: typing.Union[str, mlrun.common.schemas.ScheduleCronTrigger] = None,
         ttl: Optional[int] = None,
@@ -1425,8 +1447,8 @@ class MlrunProject(ModelObj):
         self,
         key,
         artifact: typing.Union[str, dict, Artifact] = None,
-        target_path: str = None,
-        tag: str = None,
+        target_path: Optional[str] = None,
+        tag: Optional[str] = None,
     ):
         """add/set an artifact in the project spec (will be registered on load)
 
@@ -1515,6 +1537,12 @@ class MlrunProject(ModelObj):
                     is_retained_producer=is_retained_producer,
                 )
 
+    def update_artifact(self, artifact_object: Artifact):
+        artifacts_manager = self._get_artifact_manager()
+        project_tag = self._get_project_tag()
+        producer, _ = self._resolve_artifact_producer(artifact_object, project_tag)
+        artifacts_manager.update_artifact(producer, artifact_object)
+
     def _get_artifact_manager(self):
         if self._artifact_manager:
             return self._artifact_manager
@@ -1646,7 +1674,7 @@ class MlrunProject(ModelObj):
         deletion_strategy: mlrun.common.schemas.artifact.ArtifactsDeletionStrategies = (
             mlrun.common.schemas.artifact.ArtifactsDeletionStrategies.metadata_only
         ),
-        secrets: dict = None,
+        secrets: Optional[dict] = None,
     ):
         """Delete an artifact object in the DB and optionally delete the artifact data
 
@@ -1710,7 +1738,7 @@ class MlrunProject(ModelObj):
         :param upload:        upload to datastore (default is True)
         :param labels:        a set of key/value labels to tag the artifact with
 
-        :returns: artifact object
+        :returns: dataset artifact object
         """
         ds = DatasetArtifact(
             key,
@@ -1723,14 +1751,17 @@ class MlrunProject(ModelObj):
             **kwargs,
         )
 
-        item = self.log_artifact(
-            ds,
-            local_path=local_path,
-            artifact_path=artifact_path,
-            target_path=target_path,
-            tag=tag,
-            upload=upload,
-            labels=labels,
+        item = cast(
+            DatasetArtifact,
+            self.log_artifact(
+                ds,
+                local_path=local_path,
+                artifact_path=artifact_path,
+                target_path=target_path,
+                tag=tag,
+                upload=upload,
+                labels=labels,
+            ),
         )
         return item
 
@@ -1777,7 +1808,7 @@ class MlrunProject(ModelObj):
         :param key:             artifact key or artifact class ()
         :param body:            will use the body as the artifact content
         :param model_file:      path to the local model file we upload (see also model_dir)
-                                or to a model file data url (e.g. http://host/path/model.pkl)
+                                or to a model file data url (e.g. `http://host/path/model.pkl`)
         :param model_dir:       path to the local dir holding the model file and extra files
         :param artifact_path:   target artifact path (when not using the default)
                                 to define a subpath under the default location use:
@@ -1798,7 +1829,7 @@ class MlrunProject(ModelObj):
         :param extra_data:      key/value list of extra files/charts to link with this dataset
                                 value can be absolute path | relative path (to model dir) | bytes | artifact object
 
-        :returns: artifact object
+        :returns: model artifact object
         """
 
         if training_set is not None and inputs:
@@ -1825,14 +1856,73 @@ class MlrunProject(ModelObj):
         if training_set is not None:
             model.infer_from_df(training_set, label_column)
 
-        item = self.log_artifact(
-            model,
-            artifact_path=artifact_path,
+        item = cast(
+            ModelArtifact,
+            self.log_artifact(
+                model,
+                artifact_path=artifact_path,
+                tag=tag,
+                upload=upload,
+                labels=labels,
+            ),
+        )
+        return item
+
+    def get_vector_store_collection(
+        self,
+        collection_name: str,
+        vector_store: "VectorStore",  # noqa: F821
+    ) -> VectorStoreCollection:
+        return VectorStoreCollection(
+            self,
+            collection_name,
+            vector_store,
+        )
+
+    def log_document(
+        self,
+        key: str,
+        tag: str = "",
+        local_path: str = "",
+        artifact_path: Optional[str] = None,
+        document_loader_spec: Optional[DocumentLoaderSpec] = None,
+        upload: Optional[bool] = False,
+        labels: Optional[dict[str, str]] = None,
+        target_path: Optional[str] = None,
+        **kwargs,
+    ) -> DocumentArtifact:
+        """
+        Log a document as an artifact.
+
+        :param key: Artifact key
+        :param tag: Version tag
+        :param local_path:    path to the local file we upload, will also be use
+                              as the destination subpath (under "artifact_path")
+        :param artifact_path: Target path for artifact storage
+        :param document_loader_spec: Spec to use to load the artifact as langchain document
+        :param upload: Whether to upload the artifact
+        :param labels: Key-value labels
+        :param target_path: Target file path
+        :param kwargs: Additional keyword arguments
+        :return: DocumentArtifact object
+        """
+        doc_artifact = DocumentArtifact(
+            key=key,
+            original_source=local_path or target_path,
+            document_loader_spec=document_loader_spec
+            if document_loader_spec
+            else DocumentLoaderSpec(),
+            **kwargs,
+        )
+        return self.log_artifact(
+            item=doc_artifact,
             tag=tag,
+            local_path=local_path,
+            artifact_path=artifact_path,
             upload=upload,
             labels=labels,
+            target_path=target_path,
         )
-        return item
 
     def import_artifact(
         self, item_path: str, new_key=None, artifact_path=None, tag=None
@@ -1946,6 +2036,85 @@ class MlrunProject(ModelObj):
         )
         return _run_project_setup(self, setup_file_path, save)
 
+    def create_model_monitoring_alert_configs(
+        self,
+        name: str,
+        summary: str,
+        endpoints: mlrun.common.schemas.ModelEndpointList,
+        events: Union[list[alert_constants.EventKind], alert_constants.EventKind],
+        notifications: list[alert_constants.AlertNotification],
+        result_names: Optional[
+            list[str]
+        ] = None,  # can use wildcards - see below for explanation.
+        severity: alert_constants.AlertSeverity = alert_constants.AlertSeverity.MEDIUM,
+        criteria: alert_constants.AlertCriteria = alert_constants.AlertCriteria(
+            count=1, period="10m"
+        ),
+        reset_policy: mlrun.common.schemas.alert.ResetPolicy = mlrun.common.schemas.alert.ResetPolicy.AUTO,
+    ) -> list[mlrun.alerts.alert.AlertConfig]:
+        """
+        :param name:                   AlertConfig name.
+        :param summary:                Summary of the alert, will be sent in the generated notifications
+        :param endpoints:              The endpoints from which to retrieve the metrics that the
+                                       alerts will be based on.
+        :param events:                 AlertTrigger event types (EventKind).
+        :param notifications:          List of notifications to invoke once the alert is triggered
+        :param result_names:           Optional. Filters the result names used to create the alert configuration,
+                                       constructed from the app and result_name regex.
+
+                                       For example:
+                                       [`app1.result-*`, `*.result1`]
+                                       will match "mep1.app1.result.result-1" and "mep1.app2.result.result1".
+        :param severity:               Severity of the alert.
+        :param criteria:               When the alert will be triggered based on the
+                                       specified number of events within the defined time period.
+        :param reset_policy:           When to clear the alert. May be "manual" for manual reset of the alert,
+                                       or "auto" if the criteria contains a time period.
+        :returns:                       List of AlertConfig according to endpoints results,
+                                       filtered by result_names.
+        """
+        db = mlrun.db.get_run_db(secrets=self._secrets)
+        matching_results = []
+        alerts = []
+        # TODO: Refactor to use a single request to improve performance at scale, ML-8473
+        for endpoint in endpoints.endpoints:
+            results_by_endpoint = db.get_model_endpoint_monitoring_metrics(
+                project=self.name, endpoint_id=endpoint.metadata.uid, type="results"
+            )
+            results_fqn_by_endpoint = [
+                get_result_instance_fqn(
+                    model_endpoint_id=endpoint.metadata.uid,
+                    app_name=result.app,
+                    result_name=result.name,
+                )
+                for result in results_by_endpoint
+            ]
+            matching_results += filter_results_by_regex(
+                existing_result_names=results_fqn_by_endpoint,
+                result_name_filters=result_names,
+            )
+        for result_fqn in matching_results:
+            alerts.append(
+                mlrun.alerts.alert.AlertConfig(
+                    project=self.name,
+                    name=name,
+                    summary=summary,
+                    severity=severity,
+                    entities=alert_constants.EventEntities(
+                        kind=alert_constants.EventEntityKind.MODEL_ENDPOINT_RESULT,
+                        project=self.name,
+                        ids=[result_fqn],
+                    ),
+                    trigger=alert_constants.AlertTrigger(
+                        events=events if isinstance(events, list) else [events]
+                    ),
+                    criteria=criteria,
+                    notifications=notifications,
+                    reset_policy=reset_policy,
+                )
+            )
+        return alerts
+
     def set_model_monitoring_function(
         self,
         func: typing.Union[str, mlrun.runtimes.BaseRuntime, None] = None,
@@ -1953,12 +2122,12 @@ class MlrunProject(ModelObj):
             str,
             mm_app.ModelMonitoringApplicationBase,
         ] = None,
-        name: str = None,
-        image: str = None,
+        name: Optional[str] = None,
+        image: Optional[str] = None,
         handler=None,
-        with_repo: bool = None,
-        tag: str = None,
-        requirements: typing.Union[str, list[str]] = None,
+        with_repo: Optional[bool] = None,
+        tag: Optional[str] = None,
+        requirements: Optional[typing.Union[str, list[str]]] = None,
         requirements_file: str = "",
         **application_kwargs,
     ) -> mlrun.runtimes.BaseRuntime:
@@ -1990,8 +2159,6 @@ class MlrunProject(ModelObj):
         :param application_kwargs:      Additional keyword arguments to be passed to the
                                         monitoring application's constructor.
         """
-
-        function_object: RemoteRuntime = None
         (
             resolved_function_name,
             function_object,
@@ -2015,17 +2182,17 @@ class MlrunProject(ModelObj):
 
     def create_model_monitoring_function(
         self,
-        func: str = None,
+        func: Optional[str] = None,
         application_class: typing.Union[
             str,
             mm_app.ModelMonitoringApplicationBase,
         ] = None,
-        name: str = None,
-        image: str = None,
-        handler: str = None,
-        with_repo: bool = None,
-        tag: str = None,
-        requirements: typing.Union[str, list[str]] = None,
+        name: Optional[str] = None,
+        image: Optional[str] = None,
+        handler: Optional[str] = None,
+        with_repo: Optional[bool] = None,
+        tag: Optional[str] = None,
+        requirements: Optional[typing.Union[str, list[str]]] = None,
         requirements_file: str = "",
         **application_kwargs,
     ) -> mlrun.runtimes.BaseRuntime:
@@ -2089,7 +2256,6 @@ class MlrunProject(ModelObj):
     ) -> tuple[str, mlrun.runtimes.BaseRuntime, dict]:
         import mlrun.model_monitoring.api
 
-        function_object: RemoteRuntime = None
         kind = None
         if (isinstance(func, str) or func is None) and application_class is not None:
             kind = mlrun.run.RuntimeKinds.serving
@@ -2128,9 +2294,6 @@ class MlrunProject(ModelObj):
             mm_constants.ModelMonitoringAppLabel.VAL,
         )
 
-        if not mlrun.mlconf.is_ce_mode():
-            function_object.apply(mlrun.mount_v3io())
-
         return resolved_function_name, function_object, func
 
     def _wait_for_functions_deployment(self, function_names: list[str]) -> None:
@@ -2269,7 +2432,7 @@ class MlrunProject(ModelObj):
         delete_stream_function: bool = False,
         delete_histogram_data_drift_app: bool = True,
         delete_user_applications: bool = False,
-        user_application_list: list[str] = None,
+        user_application_list: Optional[list[str]] = None,
     ) -> None:
         """
         Disable model monitoring application controller, writer, stream, histogram data drift application
@@ -2326,14 +2489,14 @@ class MlrunProject(ModelObj):
 
     def set_function(
         self,
-        func: typing.Union[str, mlrun.runtimes.BaseRuntime] = None,
+        func: typing.Union[str, mlrun.runtimes.BaseRuntime, None] = None,
         name: str = "",
         kind: str = "job",
-        image: str = None,
-        handler: str = None,
-        with_repo: bool = None,
-        tag: str = None,
-        requirements: typing.Union[str, list[str]] = None,
+        image: Optional[str] = None,
+        handler: Optional[str] = None,
+        with_repo: Optional[bool] = None,
+        tag: Optional[str] = None,
+        requirements: Optional[typing.Union[str, list[str]]] = None,
         requirements_file: str = "",
     ) -> mlrun.runtimes.BaseRuntime:
         """
@@ -2427,11 +2590,11 @@ class MlrunProject(ModelObj):
         func: typing.Union[str, mlrun.runtimes.BaseRuntime] = None,
         name: str = "",
         kind: str = "",
-        image: str = None,
-        handler: str = None,
-        with_repo: bool = None,
-        tag: str = None,
-        requirements: typing.Union[str, list[str]] = None,
+        image: Optional[str] = None,
+        handler: Optional[str] = None,
+        with_repo: Optional[bool] = None,
+        tag: Optional[str] = None,
+        requirements: Optional[typing.Union[str, list[str]]] = None,
         requirements_file: str = "",
     ) -> tuple[str, str, mlrun.runtimes.BaseRuntime, dict]:
         if (
@@ -2654,8 +2817,8 @@ class MlrunProject(ModelObj):
 
     def pull(
         self,
-        branch: str = None,
-        remote: str = None,
+        branch: Optional[str] = None,
+        remote: Optional[str] = None,
         secrets: Union[SecretsStore, dict] = None,
     ):
         """pull/update sources from git or tar into the context dir
@@ -2768,10 +2931,10 @@ class MlrunProject(ModelObj):
         branch,
         message=None,
         update=True,
-        remote: str = None,
-        add: list = None,
-        author_name: str = None,
-        author_email: str = None,
+        remote: Optional[str] = None,
+        add: Optional[list] = None,
+        author_name: Optional[str] = None,
+        author_email: Optional[str] = None,
         secrets: Union[SecretsStore, dict] = None,
     ):
         """update spec and push updates to remote git repo
@@ -2834,7 +2997,7 @@ class MlrunProject(ModelObj):
 
     def sync_functions(
         self,
-        names: list = None,
+        names: Optional[list] = None,
         always: bool = True,
         save: bool = False,
         silent: bool = False,
@@ -2978,8 +3141,8 @@ class MlrunProject(ModelObj):
 
     def set_secrets(
         self,
-        secrets: dict = None,
-        file_path: str = None,
+        secrets: Optional[dict] = None,
+        file_path: Optional[str] = None,
         provider: typing.Union[str, mlrun.common.schemas.SecretProviderName] = None,
     ):
         """
@@ -3056,24 +3219,24 @@ class MlrunProject(ModelObj):
 
     def run(
         self,
-        name: str = None,
-        workflow_path: str = None,
-        arguments: dict[str, typing.Any] = None,
-        artifact_path: str = None,
-        workflow_handler: typing.Union[str, typing.Callable] = None,
-        namespace: str = None,
+        name: Optional[str] = None,
+        workflow_path: Optional[str] = None,
+        arguments: Optional[dict[str, typing.Any]] = None,
+        artifact_path: Optional[str] = None,
+        workflow_handler: Optional[typing.Union[str, typing.Callable]] = None,
+        namespace: Optional[str] = None,
         sync: bool = False,
         watch: bool = False,
         dirty: bool = False,
-        engine: str = None,
-        local: bool = None,
+        engine: Optional[str] = None,
+        local: Optional[bool] = None,
         schedule: typing.Union[
             str, mlrun.common.schemas.ScheduleCronTrigger, bool
         ] = None,
-        timeout: int = None,
-        source: str = None,
-        cleanup_ttl: int = None,
-        notifications: list[mlrun.model.Notification] = None,
+        timeout: Optional[int] = None,
+        source: Optional[str] = None,
+        cleanup_ttl: Optional[int] = None,
+        notifications: Optional[list[mlrun.model.Notification]] = None,
         workflow_runner_node_selector: typing.Optional[dict[str, str]] = None,
     ) -> _PipelineRunStatus:
         """Run a workflow using kubeflow pipelines
@@ -3280,7 +3443,7 @@ class MlrunProject(ModelObj):
 
         return db.create_project(self.to_dict())
 
-    def export(self, filepath=None, include_files: str = None):
+    def export(self, filepath=None, include_files: Optional[str] = None):
         """save the project object into a yaml file or zip archive (default to project.yaml)
 
         By default, the project object is exported to a yaml file, when the filepath suffix is '.zip'
@@ -3325,7 +3488,6 @@ class MlrunProject(ModelObj):
     def set_model_monitoring_credentials(
         self,
         access_key: Optional[str] = None,
-        endpoint_store_connection: Optional[str] = None,
         stream_path: Optional[str] = None,
         tsdb_connection: Optional[str] = None,
         replace_creds: bool = False,
@@ -3336,7 +3498,6 @@ class MlrunProject(ModelObj):
         model monitoring or serving function.
 
         :param access_key:                Model monitoring access key for managing user permissions.
-        :param endpoint_store_connection: Endpoint store connection string. By default, None. Options:
 
                                           * None - will be set from the system configuration.
                                           * v3io - for v3io endpoint store, pass `v3io` and the system will generate the
@@ -3369,7 +3530,6 @@ class MlrunProject(ModelObj):
             project=self.name,
             credentials={
                 "access_key": access_key,
-                "endpoint_store_connection": endpoint_store_connection,
                 "stream_path": stream_path,
                 "tsdb_connection": tsdb_connection,
             },
@@ -3385,30 +3545,86 @@ class MlrunProject(ModelObj):
                 "and set `rebuild_images=True`"
             )
 
+    def list_model_endpoints(
+        self,
+        name: Optional[str] = None,
+        model_name: Optional[str] = None,
+        function_name: Optional[str] = None,
+        labels: Optional[list[str]] = None,
+        start: Optional[datetime.datetime] = None,
+        end: Optional[datetime.datetime] = None,
+        top_level: bool = False,
+        uids: Optional[list[str]] = None,
+    ) -> mlrun.common.schemas.ModelEndpointList:
+        """
+        Returns a list of `ModelEndpoint` objects. Each `ModelEndpoint` object represents the current state of a
+        model endpoint. This functions supports filtering by the following parameters:
+        1) name
+        2) model_name
+        3) function_name
+        4) labels
+        5) top level
+        6) uids
+        7) start and end time, corresponding to the `created` field.
+        By default, when no filters are applied, all available endpoints for the given project will be listed.
+
+        In addition, this functions provides a facade for listing endpoint related metrics. This facade is time-based
+        and depends on the 'start' and 'end' parameters.
+
+        :param name: The name of the model to filter by
+        :param model_name: The name of the model to filter by
+        :param function_name: The name of the function to filter by
+        :param labels: Filter model endpoints by label key-value pairs or key existence. This can be provided as:
+            - A dictionary in the format `{"label": "value"}` to match specific label key-value pairs,
+            or `{"label": None}` to check for key existence.
+            - A list of strings formatted as `"label=value"` to match specific label key-value pairs,
+            or just `"label"` for key existence.
+            - A comma-separated string formatted as `"label1=value1,label2"` to match entities with
+            the specified key-value pairs or key existence.
+        :param start:                     The start time to filter by.Corresponding to the `created` field.
+        :param end:                       The end time to filter by. Corresponding to the `created` field.
+        :param top_level: if true will return only routers and endpoint that are NOT children of any router
+        :param uids: if passed will return a list `ModelEndpoint` object with uid in uids
+
+        :returns: Returns a list of `ModelEndpoint` objects.
+        """
+        db = mlrun.db.get_run_db(secrets=self._secrets)
+        return db.list_model_endpoints(
+            project=self.name,
+            name=name,
+            model_name=model_name,
+            function_name=function_name,
+            labels=labels,
+            start=start,
+            end=end,
+            top_level=top_level,
+            uids=uids,
+        )
+
     def run_function(
         self,
         function: typing.Union[str, mlrun.runtimes.BaseRuntime],
-        handler: str = None,
+        handler: Optional[str] = None,
         name: str = "",
-        params: dict = None,
-        hyperparams: dict = None,
+        params: Optional[dict] = None,
+        hyperparams: Optional[dict] = None,
         hyper_param_options: mlrun.model.HyperParamOptions = None,
-        inputs: dict = None,
-        outputs: list[str] = None,
+        inputs: Optional[dict] = None,
+        outputs: Optional[list[str]] = None,
         workdir: str = "",
-        labels: dict = None,
+        labels: Optional[dict] = None,
         base_task: mlrun.model.RunTemplate = None,
         watch: bool = True,
-        local: bool = None,
-        verbose: bool = None,
-        selector: str = None,
-        auto_build: bool = None,
+        local: Optional[bool] = None,
+        verbose: Optional[bool] = None,
+        selector: Optional[str] = None,
+        auto_build: Optional[bool] = None,
         schedule: typing.Union[str, mlrun.common.schemas.ScheduleCronTrigger] = None,
-        artifact_path: str = None,
-        notifications: list[mlrun.model.Notification] = None,
+        artifact_path: Optional[str] = None,
+        notifications: Optional[list[mlrun.model.Notification]] = None,
         returns: Optional[list[Union[str, dict[str, str]]]] = None,
         builder_env: Optional[dict] = None,
-        reset_on_run: bool = None,
+        reset_on_run: Optional[bool] = None,
     ) -> typing.Union[mlrun.model.RunObject, PipelineNodeWrapper]:
         """Run a local or remote task as part of a local/kubeflow pipeline
 
@@ -3501,18 +3717,18 @@ class MlrunProject(ModelObj):
     def build_function(
         self,
         function: typing.Union[str, mlrun.runtimes.BaseRuntime],
-        with_mlrun: bool = None,
+        with_mlrun: Optional[bool] = None,
         skip_deployed: bool = False,
-        image: str = None,
-        base_image: str = None,
-        commands: list = None,
-        secret_name: str = None,
-        requirements: typing.Union[str, list[str]] = None,
-        mlrun_version_specifier: str = None,
-        builder_env: dict = None,
+        image: Optional[str] = None,
+        base_image: Optional[str] = None,
+        commands: Optional[list] = None,
+        secret_name: Optional[str] = None,
+        requirements: Optional[typing.Union[str, list[str]]] = None,
+        mlrun_version_specifier: Optional[str] = None,
+        builder_env: Optional[dict] = None,
         overwrite_build_params: bool = False,
-        requirements_file: str = None,
-        extra_args: str = None,
+        requirements_file: Optional[str] = None,
+        extra_args: Optional[str] = None,
         force_build: bool = False,
     ) -> typing.Union[BuildStatus, PipelineNodeWrapper]:
         """deploy ML function, build container with its dependencies
@@ -3557,18 +3773,18 @@ class MlrunProject(ModelObj):
 
     def build_config(
         self,
-        image: str = None,
+        image: Optional[str] = None,
         set_as_default: bool = False,
-        with_mlrun: bool = None,
-        base_image: str = None,
-        commands: list = None,
-        secret_name: str = None,
-        requirements: typing.Union[str, list[str]] = None,
+        with_mlrun: Optional[bool] = None,
+        base_image: Optional[str] = None,
+        commands: Optional[list] = None,
+        secret_name: Optional[str] = None,
+        requirements: Optional[typing.Union[str, list[str]]] = None,
         overwrite_build_params: bool = False,
-        requirements_file: str = None,
-        builder_env: dict = None,
-        extra_args: str = None,
-        source_code_target_dir: str = None,
+        requirements_file: Optional[str] = None,
+        builder_env: Optional[dict] = None,
+        extra_args: Optional[str] = None,
+        source_code_target_dir: Optional[str] = None,
     ):
         """specify builder configuration for the project
 
@@ -3622,19 +3838,19 @@ class MlrunProject(ModelObj):
 
     def build_image(
         self,
-        image: str = None,
+        image: Optional[str] = None,
         set_as_default: bool = True,
-        with_mlrun: bool = None,
-        base_image: str = None,
-        commands: list = None,
-        secret_name: str = None,
-        requirements: typing.Union[str, list[str]] = None,
-        mlrun_version_specifier: str = None,
-        builder_env: dict = None,
+        with_mlrun: Optional[bool] = None,
+        base_image: Optional[str] = None,
+        commands: Optional[list] = None,
+        secret_name: Optional[str] = None,
+        requirements: Optional[typing.Union[str, list[str]]] = None,
+        mlrun_version_specifier: Optional[str] = None,
+        builder_env: Optional[dict] = None,
         overwrite_build_params: bool = False,
-        requirements_file: str = None,
-        extra_args: str = None,
-        target_dir: str = None,
+        requirements_file: Optional[str] = None,
+        extra_args: Optional[str] = None,
+        target_dir: Optional[str] = None,
     ) -> typing.Union[BuildStatus, PipelineNodeWrapper]:
         """Builder docker image for the project, based on the project's build config. Parameters allow to override
         the build config.
@@ -3740,12 +3956,12 @@ class MlrunProject(ModelObj):
     def deploy_function(
         self,
         function: typing.Union[str, mlrun.runtimes.BaseRuntime],
-        models: list = None,
-        env: dict = None,
-        tag: str = None,
-        verbose: bool = None,
-        builder_env: dict = None,
-        mock: bool = None,
+        models: Optional[list] = None,
+        env: Optional[dict] = None,
+        tag: Optional[str] = None,
+        verbose: Optional[bool] = None,
+        builder_env: Optional[dict] = None,
+        mock: Optional[bool] = None,
     ) -> typing.Union[DeployStatus, PipelineNodeWrapper]:
         """deploy real-time (nuclio based) functions
 
@@ -3792,18 +4008,28 @@ class MlrunProject(ModelObj):
         self,
         name=None,
         tag=None,
-        labels: Optional[Union[dict[str, str], list[str]]] = None,
+        labels: Optional[Union[str, dict[str, Optional[str]], list[str]]] = None,
         since=None,
         until=None,
-        iter: int = None,
+        iter: Optional[int] = None,
         best_iteration: bool = False,
-        kind: str = None,
+        kind: Optional[str] = None,
         category: typing.Union[str, mlrun.common.schemas.ArtifactCategories] = None,
-        tree: str = None,
-        limit: int = None,
+        tree: Optional[str] = None,
+        limit: Optional[int] = None,
         format_: Optional[
             mlrun.common.formatters.ArtifactFormat
         ] = mlrun.common.formatters.ArtifactFormat.full,
+        partition_by: Optional[
+            Union[mlrun.common.schemas.ArtifactPartitionByField, str]
+        ] = None,
+        rows_per_partition: int = 1,
+        partition_sort_by: Optional[
+            Union[mlrun.common.schemas.SortField, str]
+        ] = mlrun.common.schemas.SortField.updated,
+        partition_order: Union[
+            mlrun.common.schemas.OrderType, str
+        ] = mlrun.common.schemas.OrderType.desc,
     ) -> mlrun.lists.ArtifactList:
         """List artifacts filtered by various parameters.
 
@@ -3813,7 +4039,7 @@ class MlrunProject(ModelObj):
         Examples::
 
             # Get latest version of all artifacts in project
-            latest_artifacts = project.list_artifacts("", tag="latest")
+            latest_artifacts = project.list_artifacts(tag="latest")
             # check different artifact versions for a specific artifact, return as objects list
             result_versions = project.list_artifacts("results", tag="*").to_objects()
 
@@ -3821,8 +4047,13 @@ class MlrunProject(ModelObj):
             case-sensitive. This means that querying for ``~name`` may return artifacts named
             ``my_Name_1`` or ``surname``.
         :param tag: Return artifacts assigned this tag.
-        :param labels: Return artifacts that have these labels. Labels can either be a dictionary {"label": "value"} or
-            a list of "label=value" (match label key and value) or "label" (match just label key) strings.
+        :param labels: Filter artifacts by label key-value pairs or key existence. This can be provided as:
+            - A dictionary in the format `{"label": "value"}` to match specific label key-value pairs,
+            or `{"label": None}` to check for key existence.
+            - A list of strings formatted as `"label=value"` to match specific label key-value pairs,
+            or just `"label"` for key existence.
+            - A comma-separated string formatted as `"label1=value1,label2"` to match entities with
+            the specified key-value pairs or key existence.
         :param since: Not in use in :py:class:`HTTPRunDB`.
         :param until: Not in use in :py:class:`HTTPRunDB`.
         :param iter: Return artifacts from a specific iteration (where ``iter=0`` means the root iteration). If
@@ -3835,6 +4066,13 @@ class MlrunProject(ModelObj):
         :param tree: Return artifacts of the requested tree.
         :param limit: Maximum number of artifacts to return.
         :param format_: The format in which to return the artifacts. Default is 'full'.
+        :param partition_by: Field to group results by. When `partition_by` is specified, the `partition_sort_by`
+            parameter must be provided as well.
+        :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`.
+        :param partition_order: Order of sorting within partitions - `asc` or `desc`. Default is `desc`.
         """
         db = mlrun.db.get_run_db(secrets=self._secrets)
         return db.list_artifacts(
@@ -3851,19 +4089,86 @@ class MlrunProject(ModelObj):
             tree=tree,
             format_=format_,
             limit=limit,
+            partition_by=partition_by,
+            rows_per_partition=rows_per_partition,
+            partition_sort_by=partition_sort_by,
+            partition_order=partition_order,
+        )
+
+    def paginated_list_artifacts(
+        self,
+        *args,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
+        **kwargs,
+    ) -> tuple[mlrun.lists.ArtifactList, Optional[str]]:
+        """List artifacts with support for pagination and various filtering options.
+
+        This method retrieves a paginated list of artifacts based on the specified filter parameters.
+        Pagination is controlled using the `page`, `page_size`, and `page_token` parameters. The method
+        will return a list of artifacts that match the filtering criteria provided.
+
+        The returned result is an `ArtifactList` (list of dict), use `.to_objects()` to convert it to a list of
+        RunObjects, `.show()` to view graphically in Jupyter, and `.to_df()` to convert to a DataFrame.
+
+        For detailed information about the parameters, refer to the list_artifacts method:
+            See :py:func:`~list_artifacts` for more details.
+
+        Examples::
+
+            # Fetch first page of artifacts with page size of 5
+            artifacts, token = project.paginated_list_artifacts("results", page_size=5)
+            # Fetch next page using the pagination token from the previous response
+            artifacts, token = project.paginated_list_artifacts("results", page_token=token)
+            # Fetch artifacts for a specific page (e.g., page 3)
+            artifacts, token = project.paginated_list_artifacts(
+                "results", page=3, page_size=5
+            )
+
+            # Automatically iterate over all pages without explicitly specifying the page number
+            artifacts = []
+            token = None
+            while True:
+                page_artifacts, token = project.paginated_list_artifacts(
+                    page_token=token, page_size=5
+                )
+                artifacts.extend(page_artifacts)
+
+                # If token is None and page_artifacts is empty, we've reached the end (no more artifacts).
+                # If token is None and page_artifacts is not empty, we've fetched the last page of artifacts.
+                if not token:
+                    break
+            print(f"Total artifacts retrieved: {len(artifacts)}")
+
+        :param page: The page number to retrieve. If not provided, the next page will be retrieved.
+        :param page_size: The number of items per page to retrieve. Up to `page_size` responses are expected.
+        :param page_token: A pagination token used to retrieve the next page of results. Should not be provided
+            for the first request.
+
+        :returns: A tuple containing the list of artifacts and an optional `page_token` for pagination.
+        """
+        db = mlrun.db.get_run_db(secrets=self._secrets)
+        return db.paginated_list_artifacts(
+            *args,
+            project=self.metadata.name,
+            page=page,
+            page_size=page_size,
+            page_token=page_token,
+            **kwargs,
         )
 
     def list_models(
         self,
         name=None,
         tag=None,
-        labels: Optional[Union[dict[str, str], list[str]]] = None,
+        labels: Optional[Union[str, dict[str, Optional[str]], list[str]]] = None,
         since=None,
         until=None,
-        iter: int = None,
+        iter: Optional[int] = None,
         best_iteration: bool = False,
-        tree: str = None,
-        limit: int = None,
+        tree: Optional[str] = None,
+        limit: Optional[int] = None,
         format_: Optional[
             mlrun.common.formatters.ArtifactFormat
         ] = mlrun.common.formatters.ArtifactFormat.full,
@@ -3873,15 +4178,20 @@ class MlrunProject(ModelObj):
         Examples::
 
             # Get latest version of all models in project
-            latest_models = project.list_models("", tag="latest")
+            latest_models = project.list_models(tag="latest")
 
 
         :param name: Name of artifacts to retrieve. Name with '~' prefix is used as a like query, and is not
             case-sensitive. This means that querying for ``~name`` may return artifacts named
             ``my_Name_1`` or ``surname``.
         :param tag: Return artifacts assigned this tag.
-        :param labels: Return artifacts that have these labels. Labels can either be a dictionary {"label": "value"} or
-            a list of "label=value" (match label key and value) or "label" (match just label key) strings.
+        :param labels: Filter model artifacts by label key-value pairs or key existence. This can be provided as:
+            - A dictionary in the format `{"label": "value"}` to match specific label key-value pairs,
+            or `{"label": None}` to check for key existence.
+            - A list of strings formatted as `"label=value"` to match specific label key-value pairs,
+            or just `"label"` for key existence.
+            - A comma-separated string formatted as `"label1=value1,label2"` to match entities with
+            the specified key-value pairs or key existence.
         :param since: Not in use in :py:class:`HTTPRunDB`.
         :param until: Not in use in :py:class:`HTTPRunDB`.
         :param iter: Return artifacts from a specific iteration (where ``iter=0`` means the root iteration). If
@@ -3903,13 +4213,79 @@ class MlrunProject(ModelObj):
             until=until,
             iter=iter,
             best_iteration=best_iteration,
-            kind="model",
+            kind=mlrun.artifacts.model.ModelArtifact.kind,
             tree=tree,
             limit=limit,
             format_=format_,
         ).to_objects()
 
-    def list_functions(self, name=None, tag=None, labels=None):
+    def paginated_list_models(
+        self,
+        *args,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
+        **kwargs,
+    ) -> tuple[mlrun.lists.ArtifactList, Optional[str]]:
+        """List models in project with support for pagination and various filtering options.
+
+        This method retrieves a paginated list of artifacts based on the specified filter parameters.
+        Pagination is controlled using the `page`, `page_size`, and `page_token` parameters. The method
+        will return a list of artifacts that match the filtering criteria provided.
+
+        For detailed information about the parameters, refer to the list_models method:
+            See :py:func:`~list_models` for more details.
+
+        Examples::
+
+            # Fetch first page of artifacts with page size of 5
+            artifacts, token = project.paginated_list_models("results", page_size=5)
+            # Fetch next page using the pagination token from the previous response
+            artifacts, token = project.paginated_list_models("results", page_token=token)
+            # Fetch artifacts for a specific page (e.g., page 3)
+            artifacts, token = project.paginated_list_models("results", page=3, page_size=5)
+
+            # Automatically iterate over all pages without explicitly specifying the page number
+            artifacts = []
+            token = None
+            while True:
+                page_artifacts, token = project.paginated_list_models(
+                    page_token=token, page_size=5
+                )
+                artifacts.extend(page_artifacts)
+
+                # If token is None and page_artifacts is empty, we've reached the end (no more artifacts).
+                # If token is None and page_artifacts is not empty, we've fetched the last page of artifacts.
+                if not token:
+                    break
+            print(f"Total artifacts retrieved: {len(artifacts)}")
+
+        :param page: The page number to retrieve. If not provided, the next page will be retrieved.
+        :param page_size: The number of items per page to retrieve. Up to `page_size` responses are expected.
+        :param page_token: A pagination token used to retrieve the next page of results. Should not be provided
+            for the first request.
+
+        :returns: A tuple containing the list of artifacts and an optional `page_token` for pagination.
+        """
+        db = mlrun.db.get_run_db(secrets=self._secrets)
+        return db.paginated_list_artifacts(
+            *args,
+            project=self.metadata.name,
+            kind=mlrun.artifacts.model.ModelArtifact.kind,
+            page=page,
+            page_size=page_size,
+            page_token=page_token,
+            **kwargs,
+        )
+
+    def list_functions(
+        self,
+        name: Optional[str] = None,
+        tag: Optional[str] = None,
+        labels: Optional[Union[str, dict[str, Optional[str]], list[str]]] = None,
+        kind: Optional[str] = None,
+        format_: Optional[str] = None,
+    ):
         """Retrieve a list of functions, filtered by specific criteria.
 
         example::
@@ -3919,20 +4295,95 @@ class MlrunProject(ModelObj):
 
         :param name: Return only functions with a specific name.
         :param tag: Return function versions with specific tags. To return only tagged functions, set tag to ``"*"``.
-        :param labels: Return functions that have specific labels assigned to them.
+        :param labels: Filter functions by label key-value pairs or key existence. This can be provided as:
+            - A dictionary in the format `{"label": "value"}` to match specific label key-value pairs,
+            or `{"label": None}` to check for key existence.
+            - A list of strings formatted as `"label=value"` to match specific label key-value pairs,
+            or just `"label"` for key existence.
+            - A comma-separated string formatted as `"label1=value1,label2"` to match entities with
+            the specified key-value pairs or key existence.
+        :param kind: Return functions of the specified kind. If not provided, all function kinds will be returned.
+        :param format_: The format in which to return the functions. Default is 'full'.
         :returns: List of function objects.
         """
         db = mlrun.db.get_run_db(secrets=self._secrets)
-        functions = db.list_functions(name, self.metadata.name, tag=tag, labels=labels)
+        functions = db.list_functions(
+            name,
+            project=self.metadata.name,
+            tag=tag,
+            kind=kind,
+            labels=labels,
+            format_=format_,
+        )
         if functions:
             # convert dict to function objects
             return [mlrun.new_function(runtime=func) for func in functions]
 
+    def paginated_list_functions(
+        self,
+        *args,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
+        **kwargs,
+    ) -> tuple[list, Optional[str]]:
+        """List functions with support for pagination and various filtering options.
+
+        This method retrieves a paginated list of functions based on the specified filter parameters.
+        Pagination is controlled using the `page`, `page_size`, and `page_token` parameters. The method
+        will return a list of functions that match the filtering criteria provided.
+
+        For detailed information about the parameters, refer to the list_functions method:
+            See :py:func:`~list_functions` for more details.
+
+        Examples::
+
+            # Fetch first page of functions with page size of 5
+            functions, token = project.paginated_list_functions(page_size=5)
+            # Fetch next page using the pagination token from the previous response
+            functions, token = project.paginated_list_functions(page_token=token)
+            # Fetch functions for a specific page (e.g., page 3)
+            functions, token = project.paginated_list_functions(page=3, page_size=5)
+
+            # Automatically iterate over all pages without explicitly specifying the page number
+            functions = []
+            token = None
+            while True:
+                page_functions, token = project.paginated_list_functions(
+                    page_token=token, page_size=5
+                )
+                functions.extend(page_functions)
+
+                # If token is None and page_functions is empty, we've reached the end (no more functions).
+                # If token is None and page_functions is not empty, we've fetched the last page of functions.
+                if not token:
+                    break
+            print(f"Total functions retrieved: {len(functions)}")
+
+        :param page: The page number to retrieve. If not provided, the next page will be retrieved.
+        :param page_size: The number of items per page to retrieve. Up to `page_size` responses are expected.
+        :param page_token: A pagination token used to retrieve the next page of results. Should not be provided
+            for the first request.
+
+        :returns: A tuple containing the list of functions and an optional `page_token` for pagination.
+        """
+        db = mlrun.db.get_run_db(secrets=self._secrets)
+        functions, token = db.paginated_list_functions(
+            *args,
+            project=self.metadata.name,
+            page=page,
+            page_size=page_size,
+            page_token=page_token,
+            **kwargs,
+        )
+        # convert dict to function objects
+        return [mlrun.new_function(runtime=func) for func in functions], token
+
     def list_model_monitoring_functions(
         self,
         name: Optional[str] = None,
         tag: Optional[str] = None,
-        labels: Optional[list[str]] = None,
+        labels: Optional[Union[str, dict[str, Optional[str]], list[str]]] = None,
     ) -> Optional[list]:
         """
         Retrieve a list of all the model monitoring functions.
@@ -3942,8 +4393,13 @@ class MlrunProject(ModelObj):
 
         :param name:    Return only functions with a specific name.
         :param tag:     Return function versions with specific tags.
-        :param labels:  Return functions that have specific labels assigned to them.
-
+        :param labels: Filter functions by label key-value pairs or key existence. This can be provided as:
+            - A dictionary in the format `{"label": "value"}` to match specific label key-value pairs,
+            or `{"label": None}` to check for key existence.
+            - A list of strings formatted as `"label=value"` to match specific label key-value pairs,
+            or just `"label"` for key existence.
+            - A comma-separated string formatted as `"label1=value1,label2"` to match entities with
+            the specified key-value pairs or key existence.
         :returns: List of function objects.
         """
 
@@ -3960,7 +4416,7 @@ class MlrunProject(ModelObj):
         self,
         name: Optional[str] = None,
         uid: Optional[Union[str, list[str]]] = None,
-        labels: Optional[Union[str, list[str]]] = None,
+        labels: Optional[Union[str, dict[str, Optional[str]], list[str]]] = None,
         state: Optional[
             mlrun.common.runtimes.constants.RunStates
         ] = None,  # Backward compatibility
@@ -3995,9 +4451,13 @@ class MlrunProject(ModelObj):
 
         :param name: Name of the run to retrieve.
         :param uid: Unique ID of the run.
-        :param labels:  A list of labels to filter by. Label filters work by either filtering a specific value
-                of a label (i.e. list("key=value")) or by looking for the existence of a given
-                key (i.e. "key").
+        :param labels: Filter runs by label key-value pairs or key existence. This can be provided as:
+            - A dictionary in the format `{"label": "value"}` to match specific label key-value pairs,
+            or `{"label": None}` to check for key existence.
+            - A list of strings formatted as `"label=value"` to match specific label key-value pairs,
+            or just `"label"` for key existence.
+            - A comma-separated string formatted as `"label1=value1,label2"` to match entities with
+            the specified key-value pairs or key existence.
         :param state: Deprecated - List only runs whose state is specified.
         :param states: List only runs whose state is one of the provided states.
         :param sort: Whether to sort the result according to their start time. Otherwise, results will be
@@ -4023,9 +4483,11 @@ class MlrunProject(ModelObj):
             uid,
             self.metadata.name,
             labels=labels,
-            states=mlrun.utils.helpers.as_list(state)
-            if state is not None
-            else states or None,
+            states=(
+                mlrun.utils.helpers.as_list(state)
+                if state is not None
+                else states or None
+            ),
             sort=sort,
             last=last,
             iter=iter,
@@ -4036,6 +4498,68 @@ class MlrunProject(ModelObj):
             **kwargs,
         )
 
+    def paginated_list_runs(
+        self,
+        *args,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
+        **kwargs,
+    ) -> tuple[mlrun.lists.RunList, Optional[str]]:
+        """List runs with support for pagination and various filtering options.
+
+        This method retrieves a paginated list of runs based on the specified filter parameters.
+        Pagination is controlled using the `page`, `page_size`, and `page_token` parameters. The method
+        will return a list of runs that match the filtering criteria provided.
+
+        The returned result is a `` (list of dict), use `.to_objects()` to convert it to a list of RunObjects,
+        `.show()` to view graphically in Jupyter, `.to_df()` to convert to a DataFrame, and `compare()` to
+        generate comparison table and PCP plot.
+
+        For detailed information about the parameters, refer to the list_runs method:
+            See :py:func:`~list_runs` for more details.
+
+        Examples::
+
+            # Fetch first page of runs with page size of 5
+            runs, token = project.paginated_list_runs(page_size=5)
+            # Fetch next page using the pagination token from the previous response
+            runs, token = project.paginated_list_runs(page_token=token)
+            # Fetch runs for a specific page (e.g., page 3)
+            runs, token = project.paginated_list_runs(page=3, page_size=5)
+
+            # Automatically iterate over all pages without explicitly specifying the page number
+            runs = []
+            token = None
+            while True:
+                page_runs, token = project.paginated_list_runs(
+                    page_token=token, page_size=5
+                )
+                runs.extend(page_runs)
+
+                # If token is None and page_runs is empty, we've reached the end (no more runs).
+                # If token is None and page_runs is not empty, we've fetched the last page of runs.
+                if not token:
+                    break
+            print(f"Total runs retrieved: {len(runs)}")
+
+        :param page: The page number to retrieve. If not provided, the next page will be retrieved.
+        :param page_size: The number of items per page to retrieve. Up to `page_size` responses are expected.
+        :param page_token: A pagination token used to retrieve the next page of results. Should not be provided
+            for the first request.
+
+        :returns: A tuple containing the list of runs and an optional `page_token` for pagination.
+        """
+        db = mlrun.db.get_run_db(secrets=self._secrets)
+        return db.paginated_list_runs(
+            *args,
+            project=self.metadata.name,
+            page=page,
+            page_size=page_size,
+            page_token=page_token,
+            **kwargs,
+        )
+
     def register_datastore_profile(self, profile: DatastoreProfile):
         private_body = DatastoreProfile2Json.get_json_private(profile)
         public_body = DatastoreProfile2Json.get_json_public(profile)
@@ -4051,6 +4575,25 @@ class MlrunProject(ModelObj):
             profile, self.name
         )
 
+    def get_config_profile_attributes(self, name: str) -> dict:
+        """
+        Get the merged attributes from a named configuration profile.
+
+        Retrieves a profile from the datastore using the provided name and returns its
+        merged public and private attributes as a dictionary.
+
+        Args:
+            name (str): Name of the configuration profile to retrieve. Will be prefixed
+                with "ds://" to form the full profile path.
+
+        Returns:
+            dict: The merged attributes dictionary containing both public and private
+                configuration settings from the profile. Returns nested dictionaries if
+                the profile contains nested configurations.
+        """
+        profile = datastore_profile_read(f"ds://{name}", self.name)
+        return profile.attributes()
+
     def delete_datastore_profile(self, profile: str):
         mlrun.db.get_run_db(secrets=self._secrets).delete_datastore_profile(
             profile, self.name
@@ -4188,13 +4731,17 @@ class MlrunProject(ModelObj):
         mlrun.db.get_run_db().delete_api_gateway(name=name, project=self.name)
 
     def store_alert_config(
-        self, alert_data: AlertConfig, alert_name: typing.Optional[str] = None
+        self,
+        alert_data: AlertConfig,
+        alert_name: typing.Optional[str] = None,
+        force_reset: bool = False,
     ) -> AlertConfig:
         """
         Create/modify an alert.
 
         :param alert_data: The data of the alert.
         :param alert_name: The name of the alert.
+        :param force_reset: If True and the alert already exists, the alert would be reset.
         :return: the created/modified alert.
         """
         if not alert_data:
@@ -4208,7 +4755,9 @@ class MlrunProject(ModelObj):
                 project=alert_data.project,
             )
         alert_data.project = self.metadata.name
-        return db.store_alert_config(alert_name, alert_data, project=self.metadata.name)
+        return db.store_alert_config(
+            alert_name, alert_data, project=self.metadata.name, force_reset=force_reset
+        )
 
     def get_alert_config(self, alert_name: str) -> AlertConfig:
         """
@@ -4230,7 +4779,7 @@ class MlrunProject(ModelObj):
         return db.list_alerts_configs(self.metadata.name)
 
     def delete_alert_config(
-        self, alert_data: AlertConfig = None, alert_name: str = None
+        self, alert_data: AlertConfig = None, alert_name: Optional[str] = None
     ):
         """
         Delete an alert.
@@ -4250,7 +4799,7 @@ class MlrunProject(ModelObj):
         db.delete_alert_config(alert_name, self.metadata.name)
 
     def reset_alert_config(
-        self, alert_data: AlertConfig = None, alert_name: str = None
+        self, alert_data: AlertConfig = None, alert_name: Optional[str] = None
     ):
         """
         Reset an alert.
@@ -4269,7 +4818,9 @@ class MlrunProject(ModelObj):
             alert_name = alert_data.name
         db.reset_alert_config(alert_name, self.metadata.name)
 
-    def get_alert_template(self, template_name: str) -> AlertTemplate:
+    def get_alert_template(
+        self, template_name: str
+    ) -> mlrun.common.schemas.alert.AlertTemplate:
         """
         Retrieve a specific alert template.
 
@@ -4279,7 +4830,7 @@ class MlrunProject(ModelObj):
         db = mlrun.db.get_run_db(secrets=self._secrets)
         return db.get_alert_template(template_name)
 
-    def list_alert_templates(self) -> list[AlertTemplate]:
+    def list_alert_templates(self) -> list[mlrun.common.schemas.alert.AlertTemplate]:
         """
         Retrieve list of all alert templates.
 
@@ -4288,12 +4839,114 @@ class MlrunProject(ModelObj):
         db = mlrun.db.get_run_db(secrets=self._secrets)
         return db.list_alert_templates()
 
+    def list_alert_activations(
+        self,
+        name: Optional[str] = None,
+        since: Optional[datetime.datetime] = None,
+        until: Optional[datetime.datetime] = None,
+        entity: Optional[str] = None,
+        severity: Optional[
+            list[Union[mlrun.common.schemas.alert.AlertSeverity, str]]
+        ] = None,
+        entity_kind: Optional[
+            Union[mlrun.common.schemas.alert.EventEntityKind, str]
+        ] = None,
+        event_kind: Optional[Union[mlrun.common.schemas.alert.EventKind, str]] = None,
+    ) -> list[mlrun.common.schemas.alert.AlertActivation]:
+        """
+        Retrieve a list of alert activations for a project.
+
+        :param name: The alert name to filter by. Supports exact matching or partial matching if prefixed with `~`.
+        :param since: Filters for alert activations occurring after this timestamp.
+        :param until: Filters for alert activations occurring before this timestamp.
+        :param entity: The entity ID to filter by. Supports wildcard matching if prefixed with `~`.
+        :param severity: A list of severity levels to filter by (e.g., ["high", "low"]).
+        :param entity_kind: The kind of entity (e.g., "job", "endpoint") to filter by.
+        :param event_kind: The kind of event (e.g., ""data-drift-detected"", "failed") to filter by.
+
+        :returns: A list of alert activations matching the provided filters.
+        """
+        db = mlrun.db.get_run_db(secrets=self._secrets)
+        return db.list_alert_activations(
+            project=self.metadata.name,
+            name=name,
+            since=since,
+            until=until,
+            entity=entity,
+            severity=severity,
+            entity_kind=entity_kind,
+            event_kind=event_kind,
+        )
+
+    def paginated_list_alert_activations(
+        self,
+        *args,
+        page: Optional[int] = None,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
+        **kwargs,
+    ) -> tuple[mlrun.common.schemas.alert.AlertActivation, Optional[str]]:
+        """
+        List alerts activations with support for pagination and various filtering options.
+
+        This method retrieves a paginated list of alert activations based on the specified filter parameters.
+        Pagination is controlled using the `page`, `page_size`, and `page_token` parameters. The method
+        will return a list of alert activations that match the filtering criteria provided.
+
+        For detailed information about the parameters, refer to the list_alert_activations method:
+            See :py:func:`~list_alert_activations` for more details.
+
+        Examples::
+
+            # Fetch first page of alert activations with page size of 5
+            alert_activations, token = project.paginated_list_alert_activations(page_size=5)
+            # Fetch next page using the pagination token from the previous response
+            alert_activations, token = project.paginated_list_alert_activations(
+                page_token=token
+            )
+            # Fetch alert activations for a specific page (e.g., page 3)
+            alert_activations, token = project.paginated_list_alert_activations(
+                page=3, page_size=5
+            )
+
+            # Automatically iterate over all pages without explicitly specifying the page number
+            alert_activations = []
+            token = None
+            while True:
+                page_alert_activations, token = project.paginated_list_alert_activations(
+                    page_token=token, page_size=5
+                )
+                alert_activations.extend(page_alert_activations)
+
+                # If token is None and page_alert_activations is empty, we've reached the end (no more activations).
+                # If token is None and page_alert_activations is not empty, we've fetched the last page of activations.
+                if not token:
+                    break
+            print(f"Total alert activations retrieved: {len(alert_activations)}")
+
+        :param page: The page number to retrieve. If not provided, the next page will be retrieved.
+        :param page_size: The number of items per page to retrieve. Up to `page_size` responses are expected.
+        :param page_token: A pagination token used to retrieve the next page of results. Should not be provided
+            for the first request.
+
+        :returns: A tuple containing the list of alert activations and an optional `page_token` for pagination.
+        """
+        db = mlrun.db.get_run_db(secrets=self._secrets)
+        return db.paginated_list_alert_activations(
+            *args,
+            project=self.metadata.name,
+            page=page,
+            page_size=page_size,
+            page_token=page_token,
+            **kwargs,
+        )
+
     def _run_authenticated_git_action(
         self,
         action: Callable,
         remote: str,
-        args: list = None,
-        kwargs: dict = None,
+        args: Optional[list] = None,
+        kwargs: Optional[dict] = None,
         secrets: Union[SecretsStore, dict] = None,
     ):
         """Run an arbitrary Git routine while the remote is enriched with secrets
@@ -4370,7 +5023,7 @@ class MlrunProject(ModelObj):
     def _resolve_artifact_producer(
         self,
         artifact: typing.Union[str, Artifact],
-        project_producer_tag: str = None,
+        project_producer_tag: Optional[str] = None,
     ) -> tuple[ArtifactProducer, bool]:
         """
         Resolve the artifact producer of the given artifact.
@@ -4400,28 +5053,34 @@ class MlrunProject(ModelObj):
                 )
 
             if producer_dict.get("kind", "") == "run":
-                return ArtifactProducer(
-                    name=producer_dict.get("name", ""),
-                    kind=producer_dict.get("kind", ""),
-                    project=producer_project,
-                    tag=producer_tag,
-                    owner=producer_dict.get("owner", ""),
-                ), True
+                return (
+                    ArtifactProducer(
+                        name=producer_dict.get("name", ""),
+                        kind=producer_dict.get("kind", ""),
+                        project=producer_project,
+                        tag=producer_tag,
+                        owner=producer_dict.get("owner", ""),
+                    ),
+                    True,
+                )
 
         # do not retain the artifact's producer, replace it with the project as the producer
         project_producer_tag = project_producer_tag or self._get_project_tag()
-        return ArtifactProducer(
-            kind="project",
-            name=self.metadata.name,
-            project=self.metadata.name,
-            tag=project_producer_tag,
-            owner=self._resolve_artifact_owner(),
-        ), False
+        return (
+            ArtifactProducer(
+                kind="project",
+                name=self.metadata.name,
+                project=self.metadata.name,
+                tag=project_producer_tag,
+                owner=self._resolve_artifact_owner(),
+            ),
+            False,
+        )
 
     def _resolve_existing_artifact(
         self,
         item: typing.Union[str, Artifact],
-        tag: str = None,
+        tag: Optional[str] = None,
     ) -> typing.Optional[Artifact]:
         """
         Check if there is and existing artifact with the given item and tag.