mlrun 1.10.0rc13__py3-none-any.whl → 1.10.0rc42__py3-none-any.whl

mlrun/__init__.py

@@ -31,11 +31,13 @@ from typing import Optional
 
 import dotenv
 
+from .common.constants import MLRUN_ACTIVE_PROJECT
 from .config import config as mlconf
 from .datastore import DataItem, ModelProvider, store_manager
 from .db import get_run_db
 from .errors import MLRunInvalidArgumentError, MLRunNotFoundError
 from .execution import MLClientCtx
+from .hub import get_hub_module, import_module
 from .model import RunObject, RunTemplate, new_task
 from .package import ArtifactType, DefaultPackager, Packager, handler
 from .projects import (
@@ -167,11 +169,29 @@ def set_environment(
 
 
 def get_current_project(silent: bool = False) -> Optional[MlrunProject]:
-    if not pipeline_context.project and not silent:
+    if pipeline_context.project:
+        return pipeline_context.project
+
+    project_name = environ.get(MLRUN_ACTIVE_PROJECT, None)
+    if not project_name:
+        if not silent:
+            raise MLRunInvalidArgumentError(
+                "No current project is initialized. Use new, get or load project functions first."
+            )
+        return None
+
+    project = load_project(
+        name=project_name,
+        url=project_name,
+        save=False,
+        sync_functions=False,
+    )
+
+    if not project and not silent:
         raise MLRunInvalidArgumentError(
             "No current project is initialized. Use new, get or load project functions first."
         )
-    return pipeline_context.project
+    return project
 
 
 def get_sample_path(subpath=""):

mlrun/artifacts/base.py

@@ -16,7 +16,6 @@ import os
 import pathlib
 import tempfile
 import typing
-import warnings
 import zipfile
 
 import yaml
@@ -876,36 +875,6 @@ def generate_target_path(item: Artifact, artifact_path, producer):
     return f"{artifact_path}{item.key}{suffix}"
 
 
-# TODO: Remove once data migration v5 is obsolete
-def convert_legacy_artifact_to_new_format(
-    legacy_artifact: dict,
-) -> Artifact:
-    """Converts a legacy artifact to a new format.
-    :param legacy_artifact: The legacy artifact to convert.
-    :return: The converted artifact.
-    """
-    artifact_key = legacy_artifact.get("key", "")
-    artifact_tag = legacy_artifact.get("tag", "")
-    if artifact_tag:
-        artifact_key = f"{artifact_key}:{artifact_tag}"
-    # TODO: Remove once data migration v5 is obsolete
-    warnings.warn(
-        f"Converting legacy artifact '{artifact_key}' to new format. This will not be supported in MLRun 1.10.0. "
-        f"Make sure to save the artifact/project in the new format.",
-        FutureWarning,
-    )
-
-    artifact = mlrun.artifacts.artifact_types.get(
-        legacy_artifact.get("kind", "artifact"), mlrun.artifacts.Artifact
-    )()
-
-    artifact.metadata = artifact.metadata.from_dict(legacy_artifact)
-    artifact.spec = artifact.spec.from_dict(legacy_artifact)
-    artifact.status = artifact.status.from_dict(legacy_artifact)
-
-    return artifact
-
-
 def fill_artifact_object_hash(object_dict, iteration=None, producer_id=None):
     # remove artifact related fields before calculating hash
     object_dict.setdefault("metadata", {})

mlrun/artifacts/document.py

@@ -359,7 +359,12 @@ class DocumentArtifact(Artifact):
         self,
         splitter: Optional["TextSplitter"] = None,  # noqa: F821
     ) -> list["Document"]:  # noqa: F821
-        from langchain.schema import Document
+        # Try new langchain 1.0+ import path first
+        try:
+            from langchain_core.documents import Document
+        except ImportError:
+            # Fall back to old langchain <1.0 import path
+            from langchain.schema import Document
 
         """
         Create LC documents from the artifact

mlrun/artifacts/llm_prompt.py

@@ -11,12 +11,14 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+import json
 import tempfile
+from collections import defaultdict
 from typing import Optional, Union
 
 import mlrun
 import mlrun.artifacts.model as model_art
-import mlrun.common
+import mlrun.common.schemas
 from mlrun.artifacts import Artifact, ArtifactMetadata, ArtifactSpec
 from mlrun.utils import StorePrefix, logger
 
@@ -25,41 +27,52 @@ MAX_PROMPT_LENGTH = 1024
 
 class LLMPromptArtifactSpec(ArtifactSpec):
     _dict_fields = ArtifactSpec._dict_fields + [
-        "prompt_string",
+        "prompt_template",
         "prompt_legend",
-        "model_configuration",
+        "invocation_config",
         "description",
     ]
+    PROMPT_TEMPLATE_KEYS = ("content", "role")
+    PROMPT_LEGENDS_KEYS = ("field", "description")
 
     def __init__(
         self,
         model_artifact: Union[model_art.ModelArtifact, str] = None,
-        prompt_string: Optional[str] = None,
+        prompt_template: Optional[list[dict]] = None,
         prompt_path: Optional[str] = None,
         prompt_legend: Optional[dict] = None,
-        model_configuration: Optional[dict] = None,
+        invocation_config: Optional[dict] = None,
         description: Optional[str] = None,
         target_path: Optional[str] = None,
         **kwargs,
     ):
-        if prompt_string and prompt_path:
+        if prompt_template and prompt_path:
             raise mlrun.errors.MLRunInvalidArgumentError(
-                "Cannot specify both 'prompt_string' and 'prompt_path'"
+                "Cannot specify both 'prompt_template' and 'prompt_path'"
             )
-
+        if prompt_legend:
+            self._verify_prompt_legend(prompt_legend)
+        if prompt_path:
+            self._verify_prompt_path(prompt_path)
+        if prompt_template:
+            self._verify_prompt_template(prompt_template)
         super().__init__(
             src_path=prompt_path,
             target_path=target_path,
             parent_uri=model_artifact.uri
             if isinstance(model_artifact, model_art.ModelArtifact)
             else model_artifact,
-            body=prompt_string,
+            format=kwargs.pop("format", "") or "json",
             **kwargs,
         )
 
-        self.prompt_string = prompt_string
+        self.prompt_template = prompt_template
         self.prompt_legend = prompt_legend
-        self.model_configuration = model_configuration
+        if invocation_config is not None and not isinstance(invocation_config, dict):
+            raise mlrun.errors.MLRunInvalidArgumentError(
+                "LLMPromptArtifact invocation_config must be a dictionary or None"
+            )
+        self.invocation_config = invocation_config or {}
         self.description = description
         self._model_artifact = (
             model_artifact
@@ -67,10 +80,79 @@ class LLMPromptArtifactSpec(ArtifactSpec):
             else None
         )
 
+    def _verify_prompt_template(self, prompt_template):
+        if not (
+            isinstance(prompt_template, list)
+            and all(isinstance(item, dict) for item in prompt_template)
+        ):
+            raise mlrun.errors.MLRunInvalidArgumentError(
+                "Expected prompt_template to be a list of dicts"
+            )
+        for message in prompt_template:
+            if set(key.lower() for key in message.keys()) != set(
+                self.PROMPT_TEMPLATE_KEYS
+            ):
+                raise mlrun.errors.MLRunInvalidArgumentError(
+                    f"Expected prompt_template to contain dicts with keys "
+                    f"{self.PROMPT_TEMPLATE_KEYS}, got {message.keys()}"
+                )
+            keys_to_pop = []
+            for key in message.keys():
+                if isinstance(key, str):
+                    if not key.islower():
+                        message[key.lower()] = message[key]
+                        keys_to_pop.append(key)
+                else:
+                    raise mlrun.errors.MLRunInvalidArgumentError(
+                        f"Expected prompt_template to contain dict that only"
+                        f" has str keys got {key} of type {type(key)}"
+                    )
+            for key_to_pop in keys_to_pop:
+                message.pop(key_to_pop)
+
     @property
     def model_uri(self):
         return self.parent_uri
 
+    @staticmethod
+    def _verify_prompt_legend(prompt_legend: dict):
+        if prompt_legend is None:
+            return True
+        for place_holder, body_map in prompt_legend.items():
+            if isinstance(body_map, dict):
+                if body_map.get("field") is None:
+                    body_map["field"] = place_holder
+                body_map["description"] = body_map.get("description")
+                if diff := set(body_map.keys()) - set(
+                    LLMPromptArtifactSpec.PROMPT_LEGENDS_KEYS
+                ):
+                    raise mlrun.errors.MLRunInvalidArgumentError(
+                        "prompt_legend values must contain only 'field' and "
+                        f"'description' keys, got extra fields: {diff}"
+                    )
+            else:
+                raise mlrun.errors.MLRunInvalidArgumentError(
+                    f"Wrong prompt_legend format, {place_holder} is not mapped to dict"
+                )
+
+    @staticmethod
+    def _verify_prompt_path(prompt_path: str):
+        with mlrun.datastore.store_manager.object(prompt_path).open(mode="r") as p_file:
+            try:
+                json.load(p_file)
+            except json.JSONDecodeError:
+                raise mlrun.errors.MLRunInvalidArgumentError(
+                    f"Failed on decoding str in path "
+                    f"{prompt_path} expected file to contain a "
+                    f"json format."
+                )
+
+    def get_body(self):
+        if self.prompt_template:
+            return json.dumps(self.prompt_template)
+        else:
+            return None
+
 
 class LLMPromptArtifact(Artifact):
     """
@@ -90,20 +172,20 @@ class LLMPromptArtifact(Artifact):
         model_artifact: Union[
             model_art.ModelArtifact, str
         ] = None,  # TODO support partial model uri
-        prompt_string: Optional[str] = None,
+        prompt_template: Optional[list[dict]] = None,
         prompt_path: Optional[str] = None,
         prompt_legend: Optional[dict] = None,
-        model_configuration: Optional[dict] = None,
+        invocation_config: Optional[dict] = None,
         description: Optional[str] = None,
         target_path=None,
         **kwargs,
     ):
         llm_prompt_spec = LLMPromptArtifactSpec(
-            prompt_string=prompt_string,
+            prompt_template=prompt_template,
             prompt_path=prompt_path,
             prompt_legend=prompt_legend,
             model_artifact=model_artifact,
-            model_configuration=model_configuration,
+            invocation_config=invocation_config,
             target_path=target_path,
             description=description,
         )
@@ -137,33 +219,49 @@ class LLMPromptArtifact(Artifact):
             return self.spec._model_artifact
         return None
 
-    def read_prompt(self) -> Optional[str]:
+    def read_prompt(self) -> Optional[Union[str, list[dict]]]:
         """
-        Read the prompt string from the artifact.
+        Read the prompt json from the artifact or if provided prompt template.
+        @:param as_str: True to return the prompt string or a list of dicts.
+        @:return prompt string or list of dicts
         """
-        if self.spec.prompt_string:
-            return self.spec.prompt_string
+        if self.spec.prompt_template:
+            return self.spec.prompt_template
         if self.spec.target_path:
             with mlrun.datastore.store_manager.object(url=self.spec.target_path).open(
                 mode="r"
             ) as p_file:
-                return p_file.read()
+                try:
+                    return json.load(p_file)
+                except json.JSONDecodeError:
+                    raise mlrun.errors.MLRunInvalidArgumentError(
+                        f"Failed on decoding str in path "
+                        f"{self.spec.target_path} expected file to contain a "
+                        f"json format."
+                    )
 
     def before_log(self):
         """
         Prepare the artifact before logging.
         This method is called before the artifact is logged.
         """
-        if self.spec.prompt_string and len(self.spec.prompt_string) > MAX_PROMPT_LENGTH:
+        if (
+            self.spec.prompt_template
+            and len(str(self.spec.prompt_template)) > MAX_PROMPT_LENGTH
+        ):
             logger.debug(
                 "Prompt string exceeds maximum length, saving to a temporary file."
             )
             with tempfile.NamedTemporaryFile(
-                delete=False, mode="w", suffix=".txt"
+                delete=False, mode="w", suffix=".json"
             ) as temp_file:
-                temp_file.write(self.spec.prompt_string)
+                temp_file.write(json.dumps(self.spec.prompt_template))
             self.spec.src_path = temp_file.name
-            self.spec.prompt_string = None
+            self.spec.prompt_template = None
             self._src_is_temp = True
-
         super().before_log()
+
+
+class PlaceholderDefaultDict(defaultdict):
+    def __missing__(self, key):
+        return f"{{{key}}}"

mlrun/artifacts/manager.py

@@ -110,11 +110,6 @@ class ArtifactProducer:
 
 def dict_to_artifact(struct: dict) -> Artifact:
     kind = struct.get("kind", "")
-
-    # TODO: Remove once data migration v5 is obsolete
-    if mlrun.utils.is_legacy_artifact(struct):
-        return mlrun.artifacts.base.convert_legacy_artifact_to_new_format(struct)
-
     artifact_class = artifact_types[kind]
     return artifact_class.from_dict(struct)
 

mlrun/artifacts/model.py

@@ -190,10 +190,10 @@ class ModelArtifact(Artifact):
         """
         super().__init__(key, body, format=format, target_path=target_path, **kwargs)
         model_file = str(model_file or "")
-        if model_file and model_url:
+        if (model_file or model_dir or body) and model_url:
             raise mlrun.errors.MLRunInvalidArgumentError(
-                "Arguments 'model_file' and 'model_dir' cannot be"
-                " used together with 'model_url'."
+                "Arguments 'model_file' and 'model_url' cannot be"
+                " used together with 'model_file', 'model_dir' or 'body'."
             )
         if model_file and "/" in model_file:
             if model_dir:

mlrun/common/constants.py

@@ -27,9 +27,16 @@ DASK_LABEL_PREFIX = "dask.org/"
 NUCLIO_LABEL_PREFIX = "nuclio.io/"
 RESERVED_TAG_NAME_LATEST = "latest"
 
+# Kubernetes DNS-1123 label name length limit
+K8S_DNS_1123_LABEL_MAX_LENGTH = 63
+
+
+RESERVED_BATCH_JOB_SUFFIX = "-batch"
+
 JOB_TYPE_WORKFLOW_RUNNER = "workflow-runner"
 JOB_TYPE_PROJECT_LOADER = "project-loader"
 JOB_TYPE_RERUN_WORKFLOW_RUNNER = "rerun-workflow-runner"
+MLRUN_ACTIVE_PROJECT = "MLRUN_ACTIVE_PROJECT"
 
 
 class MLRunInternalLabels:
@@ -81,9 +88,11 @@ class MLRunInternalLabels:
     kind = "kind"
     component = "component"
     mlrun_type = "mlrun__type"
-    rerun_of = "rerun-of"
     original_workflow_id = "original-workflow-id"
     workflow_id = "workflow-id"
+    retrying = "retrying"
+    rerun_counter = "rerun-counter"
+    rerun_index = "rerun-index"
 
     owner = "owner"
     v3io_user = "v3io_user"

mlrun/common/formatters/artifact.py

@@ -41,6 +41,7 @@ class ArtifactFormat(ObjectFormat, mlrun.common.types.StrEnum):
                     "spec.metrics",
                     "spec.target_path",
                     "spec.parent_uri",
+                    "spec.has_children",
                 ]
             ),
         }[_format]

mlrun/common/model_monitoring/helpers.py

@@ -14,6 +14,7 @@
 
 import sys
 import typing
+from datetime import datetime
 
 import mlrun.common
 import mlrun.common.schemas.model_monitoring.constants as mm_constants
@@ -24,6 +25,7 @@ BinCounts = typing.NewType("BinCounts", list[int])
 BinEdges = typing.NewType("BinEdges", list[float])
 
 _MAX_FLOAT = sys.float_info.max
+logger = mlrun.utils.create_logger(level="info", name="mm_helpers")
 
 
 def parse_model_endpoint_project_prefix(path: str, project_name: str):
@@ -87,3 +89,87 @@ def pad_features_hist(feature_stats: FeatureStats) -> None:
     for feature in feature_stats.values():
         if hist_key in feature:
             pad_hist(Histogram(feature[hist_key]))
+
+
+def get_model_endpoints_creation_task_status(
+    server,
+) -> tuple[
+    mlrun.common.schemas.BackgroundTaskState,
+    typing.Optional[datetime],
+    typing.Optional[set[str]],
+]:
+    background_task = None
+    background_task_state = mlrun.common.schemas.BackgroundTaskState.running
+    background_task_check_timestamp = None
+    model_endpoint_uids = None
+    try:
+        background_task = mlrun.get_run_db().get_project_background_task(
+            server.project, server.model_endpoint_creation_task_name
+        )
+        background_task_check_timestamp = mlrun.utils.now_date()
+        log_background_task_state(
+            server, background_task.status.state, background_task_check_timestamp
+        )
+        background_task_state = background_task.status.state
+    except mlrun.errors.MLRunNotFoundError:
+        logger.warning(
+            "Model endpoint creation task not found listing model endpoints",
+            project=server.project,
+            task_name=server.model_endpoint_creation_task_name,
+        )
+    if background_task is None:
+        model_endpoints = mlrun.get_run_db().list_model_endpoints(
+            project=server.project,
+            function_name=server.function_name,
+            function_tag=server.function_tag,
+            tsdb_metrics=False,
+        )
+        if model_endpoints:
+            model_endpoint_uids = {
+                endpoint.metadata.uid for endpoint in model_endpoints.endpoints
+            }
+            logger.info(
+                "Model endpoints found after background task not found, model monitoring will monitor "
+                "events",
+                project=server.project,
+                function_name=server.function_name,
+                function_tag=server.function_tag,
+                uids=model_endpoint_uids,
+            )
+            background_task_state = mlrun.common.schemas.BackgroundTaskState.succeeded
+        else:
+            logger.warning(
+                "Model endpoints not found after background task not found, model monitoring will not "
+                "monitor events",
+                project=server.project,
+                function_name=server.function_name,
+                function_tag=server.function_tag,
+            )
+            background_task_state = mlrun.common.schemas.BackgroundTaskState.failed
+    return background_task_state, background_task_check_timestamp, model_endpoint_uids
+
+
+def log_background_task_state(
+    server,
+    background_task_state: mlrun.common.schemas.BackgroundTaskState,
+    background_task_check_timestamp: typing.Optional[datetime],
+):
+    logger.info(
+        "Checking model endpoint creation task status",
+        task_name=server.model_endpoint_creation_task_name,
+    )
+    if (
+        background_task_state
+        in mlrun.common.schemas.BackgroundTaskState.terminal_states()
+    ):
+        logger.info(
+            f"Model endpoint creation task completed with state {background_task_state}"
+        )
+    else:  # in progress
+        logger.info(
+            f"Model endpoint creation task is still in progress with the current state: "
+            f"{background_task_state}. Events will not be monitored for the next "
+            f"{mlrun.mlconf.model_endpoint_monitoring.model_endpoint_creation_check_period} seconds",
+            function_name=server.function_name,
+            background_task_check_timestamp=background_task_check_timestamp.isoformat(),
+        )

mlrun/common/schemas/__init__.py

@@ -133,6 +133,7 @@ from .k8s import NodeSelectorOperator, Resources, ResourceSpec
 from .memory_reports import MostCommonObjectTypesReport, ObjectTypeReport
 from .model_monitoring import (
     DriftStatus,
+    EndpointMode,
     EndpointType,
     EndpointUID,
     EventFieldType,
@@ -147,11 +148,13 @@ from .model_monitoring import (
     GrafanaTable,
     ModelEndpoint,
     ModelEndpointCreationStrategy,
+    ModelEndpointDriftValues,
     ModelEndpointList,
     ModelEndpointMetadata,
     ModelEndpointSchema,
     ModelEndpointSpec,
     ModelEndpointStatus,
+    ModelMonitoringInfraLabel,
     ModelMonitoringMode,
     MonitoringFunctionNames,
     TSDBTarget,

mlrun/common/schemas/auth.py

@@ -55,6 +55,7 @@ class AuthorizationResourceTypes(mlrun.common.types.StrEnum):
     secret = "secret"
     run = "run"
     model_endpoint = "model-endpoint"
+    model_monitoring = "model-monitoring"
     pipeline = "pipeline"
     hub_source = "hub-source"
     workflow = "workflow"
@@ -96,6 +97,7 @@ class AuthorizationResourceTypes(mlrun.common.types.StrEnum):
             # runtime resource doesn't have an identifier, we don't need any auth granularity behind project level
             AuthorizationResourceTypes.runtime_resource: "/projects/{project_name}/runtime-resources",
             AuthorizationResourceTypes.model_endpoint: "/projects/{project_name}/model-endpoints/{resource_name}",
+            AuthorizationResourceTypes.model_monitoring: "/projects/{project_name}/model-monitoring/{resource_name}",
             AuthorizationResourceTypes.pipeline: "/projects/{project_name}/pipelines/{resource_name}",
             AuthorizationResourceTypes.datastore_profile: "/projects/{project_name}/datastore_profiles",
             # Hub sources are not project-scoped, and auth is globally on the sources endpoint.

mlrun/common/schemas/function.py

@@ -114,11 +114,21 @@ class StateThresholds(pydantic.v1.BaseModel):
     default: typing.Optional[dict[str, str]]
 
 
+class Backoff(pydantic.v1.BaseModel):
+    default_base_delay: typing.Optional[str]
+    min_base_delay: typing.Optional[str]
+
+
+class RetrySpec(pydantic.v1.BaseModel):
+    backoff: Backoff
+
+
 class FunctionSpec(pydantic.v1.BaseModel):
     image_pull_secret: typing.Optional[ImagePullSecret]
     security_context: typing.Optional[SecurityContext]
     service_account: typing.Optional[ServiceAccount]
     state_thresholds: typing.Optional[StateThresholds]
+    retry: typing.Optional[RetrySpec]
 
     class Config:
         extra = pydantic.v1.Extra.allow