mlrun 1.7.2rc3__py3-none-any.whl → 1.8.0rc2__py3-none-any.whl

mlrun/projects/project.py

@@ -33,13 +33,11 @@ from typing import Callable, Optional, Union
 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
@@ -51,16 +49,19 @@ 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.runtimes.nuclio.function import RemoteRuntime
+from mlrun_pipelines.models import PipelineNodeWrapper
 
 from ..artifacts import Artifact, ArtifactProducer, DatasetArtifact, ModelArtifact
 from ..artifacts.manager import ArtifactManager, dict_to_artifact, extend_artifact_path
@@ -126,15 +127,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 +292,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 +438,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 +824,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 +1254,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 +1358,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 +1430,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)
 
@@ -1646,7 +1651,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
 
@@ -1777,7 +1782,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:
@@ -1953,12 +1958,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 +1995,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 +2018,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 +2092,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 +2130,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 +2268,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
@@ -2329,11 +2328,11 @@ class MlrunProject(ModelObj):
         func: typing.Union[str, mlrun.runtimes.BaseRuntime] = 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 +2426,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 +2653,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 +2767,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 +2833,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 +2977,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 +3055,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 +3279,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'
@@ -3385,30 +3384,85 @@ class MlrunProject(ModelObj):
                 "and set `rebuild_images=True`"
             )
 
+    def list_model_endpoints(
+        self,
+        model: Optional[str] = None,
+        function: Optional[str] = None,
+        labels: Optional[list[str]] = None,
+        start: str = "now-1h",
+        end: str = "now",
+        top_level: bool = False,
+        uids: Optional[list[str]] = None,
+    ) -> list[mlrun.model_monitoring.model_endpoint.ModelEndpoint]:
+        """
+        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) model
+        2) function
+        3) labels
+        4) top level
+        5) uids
+        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 model: The name of the model to filter by
+        :param function: 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 of the metrics. Can be represented by a string containing an RFC 3339 time, a
+                      Unix timestamp in milliseconds, a relative time (`'now'` or `'now-[0-9]+[mhd]'`, where
+                      `m` = minutes, `h` = hours, `'d'` = days, and `'s'` = seconds), or 0 for the earliest time.
+        :param end: The end time of the metrics. Can be represented by a string containing an RFC 3339 time, a
+                      Unix timestamp in milliseconds, a relative time (`'now'` or `'now-[0-9]+[mhd]'`, where
+                      `m` = minutes, `h` = hours, `'d'` = days, and `'s'` = seconds), or 0 for the earliest time.
+        :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,
+            model=model,
+            function=function,
+            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 +3555,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 +3611,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 +3676,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 +3794,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,15 +3846,15 @@ 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,
@@ -3813,7 +3867,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 +3875,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
@@ -3853,17 +3912,80 @@ class MlrunProject(ModelObj):
             limit=limit,
         )
 
+    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 +3995,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 +4030,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 +4112,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 +4210,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 +4233,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 +4268,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 +4300,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 +4315,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)
@@ -4188,13 +4529,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 +4553,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 +4577,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 +4597,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.
@@ -4292,8 +4639,8 @@ class MlrunProject(ModelObj):
         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 +4717,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 +4747,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.