mlrun 1.10.0rc14__tar.gz → 1.10.0rc16__tar.gz

{mlrun-1.10.0rc14/mlrun.egg-info → mlrun-1.10.0rc16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mlrun
-Version: 1.10.0rc14
+Version: 1.10.0rc16
 Summary: Tracking and config of machine learning runs
 Home-page: https://github.com/mlrun/mlrun
 Author: Yaron Haviv
@@ -28,7 +28,7 @@ Requires-Dist: aiohttp-retry~=2.9
 Requires-Dist: click~=8.1
 Requires-Dist: nest-asyncio~=1.0
 Requires-Dist: ipython~=8.10
-Requires-Dist: nuclio-jupyter~=0.11.1
+Requires-Dist: nuclio-jupyter~=0.11.2
 Requires-Dist: numpy<1.27.0,>=1.26.4
 Requires-Dist: pandas<2.2,>=1.2
 Requires-Dist: pyarrow<18,>=10.0
@@ -101,8 +101,6 @@ Provides-Extra: tdengine
 Requires-Dist: taos-ws-py==0.3.2; extra == "tdengine"
 Provides-Extra: snowflake
 Requires-Dist: snowflake-connector-python~=3.7; extra == "snowflake"
-Provides-Extra: openai
-Requires-Dist: openai~=1.88; extra == "openai"
 Provides-Extra: dev-postgres
 Requires-Dist: pytest-mock-resources[postgres]~=2.12; extra == "dev-postgres"
 Provides-Extra: kfp18
@@ -148,7 +146,6 @@ Requires-Dist: graphviz~=0.20.0; extra == "all"
 Requires-Dist: kafka-python~=2.1.0; extra == "all"
 Requires-Dist: mlflow~=2.22; extra == "all"
 Requires-Dist: msrest~=0.6.21; extra == "all"
-Requires-Dist: openai~=1.88; extra == "all"
 Requires-Dist: oss2==2.18.1; extra == "all"
 Requires-Dist: ossfs==2023.12.0; extra == "all"
 Requires-Dist: plotly~=5.23; extra == "all"
@@ -180,7 +177,6 @@ Requires-Dist: graphviz~=0.20.0; extra == "complete"
 Requires-Dist: kafka-python~=2.1.0; extra == "complete"
 Requires-Dist: mlflow~=2.22; extra == "complete"
 Requires-Dist: msrest~=0.6.21; extra == "complete"
-Requires-Dist: openai~=1.88; extra == "complete"
 Requires-Dist: oss2==2.18.1; extra == "complete"
 Requires-Dist: ossfs==2023.12.0; extra == "complete"
 Requires-Dist: plotly~=5.23; extra == "complete"
@@ -223,7 +219,6 @@ Requires-Dist: mlflow~=2.22; extra == "complete-api"
 Requires-Dist: mlrun-pipelines-kfp-v1-8~=0.5.7; extra == "complete-api"
 Requires-Dist: msrest~=0.6.21; extra == "complete-api"
 Requires-Dist: objgraph~=3.6; extra == "complete-api"
-Requires-Dist: openai~=1.88; extra == "complete-api"
 Requires-Dist: oss2==2.18.1; extra == "complete-api"
 Requires-Dist: ossfs==2023.12.0; extra == "complete-api"
 Requires-Dist: plotly~=5.23; extra == "complete-api"

{mlrun-1.10.0rc14 → mlrun-1.10.0rc16}/dependencies.py

@@ -75,7 +75,6 @@ def extra_requirements() -> dict[str, list[str]]:
         "alibaba-oss": ["ossfs==2023.12.0", "oss2==2.18.1"],
         "tdengine": ["taos-ws-py==0.3.2"],
         "snowflake": ["snowflake-connector-python~=3.7"],
-        "openai": ["openai~=1.88"],
     }
 
     api_deps = list(

{mlrun-1.10.0rc14 → mlrun-1.10.0rc16}/dev-requirements.txt

@@ -43,3 +43,7 @@ evidently~=0.7.6
 # code coverage
 coverage[toml]~=7.8
 diff-cover~=9.2
+openai~=1.88
+transformers~=4.53
+# for hugging face image classifier test:
+tf-keras~=2.18

{mlrun-1.10.0rc14 → mlrun-1.10.0rc16}/extras-requirements.txt

@@ -52,4 +52,3 @@ dask~=2024.12.1; python_version >= "3.11"
 distributed~=2024.12.1; python_version >= "3.11"
 taos-ws-py==0.3.2
 snowflake-connector-python~=3.7
-openai~=1.88

{mlrun-1.10.0rc14 → mlrun-1.10.0rc16}/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-1.10.0rc14 → mlrun-1.10.0rc16}/mlrun/artifacts/llm_prompt.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 import json
 import tempfile
+from collections import defaultdict
 from typing import Optional, Union
 
 import mlrun
@@ -253,3 +254,8 @@ class LLMPromptArtifact(Artifact):
             self.spec.prompt_template = None
             self._src_is_temp = True
         super().before_log()
+
+
+class PlaceholderDefaultDict(defaultdict):
+    def __missing__(self, key):
+        return f"{{{key}}}"

{mlrun-1.10.0rc14 → mlrun-1.10.0rc16}/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-1.10.0rc14 → mlrun-1.10.0rc16}/mlrun/common/constants.py

@@ -83,6 +83,7 @@ class MLRunInternalLabels:
     mlrun_type = "mlrun__type"
     original_workflow_id = "original-workflow-id"
     workflow_id = "workflow-id"
+    retrying = "retrying"
 
     owner = "owner"
     v3io_user = "v3io_user"

{mlrun-1.10.0rc14 → mlrun-1.10.0rc16}/mlrun/common/schemas/__init__.py

@@ -147,6 +147,7 @@ from .model_monitoring import (
     GrafanaTable,
     ModelEndpoint,
     ModelEndpointCreationStrategy,
+    ModelEndpointDriftValues,
     ModelEndpointList,
     ModelEndpointMetadata,
     ModelEndpointSchema,

{mlrun-1.10.0rc14 → mlrun-1.10.0rc16}/mlrun/common/schemas/model_monitoring/__init__.py

@@ -59,6 +59,7 @@ from .model_endpoints import (
     Features,
     FeatureValues,
     ModelEndpoint,
+    ModelEndpointDriftValues,
     ModelEndpointList,
     ModelEndpointMetadata,
     ModelEndpointMonitoringMetric,

{mlrun-1.10.0rc14 → mlrun-1.10.0rc16}/mlrun/common/schemas/model_monitoring/functions.py

@@ -64,5 +64,5 @@ class FunctionSummary(BaseModel):
             updated_time=func_dict["metadata"].get("updated"),
             status=func_dict["status"].get("state"),
             base_period=base_period,
-            stats=stats,
+            stats=stats or {},
         )

{mlrun-1.10.0rc14 → mlrun-1.10.0rc16}/mlrun/common/schemas/model_monitoring/model_endpoints.py

@@ -352,6 +352,16 @@ class ApplicationMetricRecord(ApplicationBaseRecord):
     type: Literal["metric"] = "metric"
 
 
+class _DriftBin(NamedTuple):
+    timestamp: datetime
+    count_suspected: int
+    count_detected: int
+
+
+class ModelEndpointDriftValues(BaseModel):
+    values: list[_DriftBin]
+
+
 def _mapping_attributes(
     model_class: type[Model],
     flattened_dictionary: dict,

{mlrun-1.10.0rc14 → mlrun-1.10.0rc16}/mlrun/common/schemas/workflow.py

@@ -51,6 +51,8 @@ class RerunWorkflowRequest(pydantic.v1.BaseModel):
     run_id: typing.Optional[str] = None
     notifications: typing.Optional[list[Notification]] = None
     workflow_runner_node_selector: typing.Optional[dict[str, str]] = None
+    original_workflow_runner_uid: typing.Optional[str] = None
+    original_workflow_name: typing.Optional[str] = None
 
 
 class WorkflowResponse(pydantic.v1.BaseModel):

{mlrun-1.10.0rc14 → mlrun-1.10.0rc16}/mlrun/config.py

@@ -193,7 +193,7 @@ default_config = {
     },
     "v3io_framesd": "http://framesd:8080",
     "model_providers": {
-        "openai_default_model": "gpt-4",
+        "openai_default_model": "gpt-4o",
     },
     # default node selector to be applied to all functions - json string base64 encoded format
     "default_function_node_selector": "e30=",

{mlrun-1.10.0rc14 → mlrun-1.10.0rc16}/mlrun/datastore/model_provider/model_provider.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from collections.abc import Awaitable
-from typing import Callable, Optional, TypeVar, Union
+from typing import Any, Callable, Optional, TypeVar, Union
 
 import mlrun.errors
 from mlrun.datastore.remote_client import (
@@ -56,9 +56,16 @@ class ModelProvider(BaseRemoteClient):
         )
         self.default_invoke_kwargs = default_invoke_kwargs or {}
         self._client = None
-        self._default_operation = None
         self._async_client = None
-        self._default_async_operation = None
+
+    def get_client_options(self) -> dict:
+        """
+        Returns a dictionary containing credentials and configuration
+        options required for client creation.
+
+        :return:           A dictionary with client-specific settings.
+        """
+        return {}
 
     def load_client(self) -> None:
         """
@@ -68,8 +75,6 @@ class ModelProvider(BaseRemoteClient):
         Subclasses should override this method to:
         - Create and configure the provider-specific client instance.
         - Assign the client instance to self._client.
-        - Define a default operation callable (e.g., a method to invoke model completions)
-        and assign it to self._default_operation.
         """
 
         raise NotImplementedError("load_client method is not implemented")
@@ -122,39 +127,62 @@ class ModelProvider(BaseRemoteClient):
         """
         raise NotImplementedError("invoke method is not implemented")
 
-    def customized_invoke(
+    def custom_invoke(
         self, operation: Optional[Callable[..., T]] = None, **invoke_kwargs
     ) -> Optional[T]:
-        raise NotImplementedError("customized_invoke method is not implemented")
+        """
+        Invokes a model operation from a provider (e.g., OpenAI, Hugging Face, etc.) with the given keyword arguments.
+
+        Useful for dynamically calling model methods like text generation, chat completions, or image generation.
+        The operation must be a callable that accepts keyword arguments.
+
+        :param operation:       A callable representing the model operation (e.g., a client method).
+        :param invoke_kwargs:   Keyword arguments to pass to the operation.
+        :return:                The full response returned by the operation.
+        """
+        raise NotImplementedError("custom_invoke method is not implemented")
 
     @property
-    def client(self):
+    def client(self) -> Any:
         return self._client
 
     @property
-    def model(self):
+    def model(self) -> Optional[str]:
         return None
 
-    def get_invoke_kwargs(self, invoke_kwargs):
+    def get_invoke_kwargs(self, invoke_kwargs) -> dict:
         kwargs = self.default_invoke_kwargs.copy()
         kwargs.update(invoke_kwargs)
         return kwargs
 
     @property
-    def async_client(self):
+    def async_client(self) -> Any:
         if not self.support_async:
             raise mlrun.errors.MLRunInvalidArgumentError(
                 f"{self.__class__.__name__} does not support async operations"
             )
         return self._async_client
 
-    async def async_customized_invoke(self, **kwargs):
-        raise NotImplementedError("async_customized_invoke is not implemented")
+    async def async_custom_invoke(
+        self, operation: Optional[Callable[..., Awaitable[T]]], **invoke_kwargs
+    ) -> Optional[T]:
+        """
+        Asynchronously invokes a model operation from a provider (e.g., OpenAI, Hugging Face, etc.)
+        with the given keyword arguments.
+
+        The operation must be an async callable (e.g., a method from an async client) that accepts keyword arguments.
+
+        :param operation:       An async callable representing the model operation (e.g., an async_client method).
+        :param invoke_kwargs:   Keyword arguments to pass to the operation.
+        :return:                The full response returned by the awaited operation.
+        """
+        raise NotImplementedError("async_custom_invoke is not implemented")
 
     async def async_invoke(
         self,
         messages: Optional[list[dict]] = None,
         as_str: bool = False,
         **invoke_kwargs,
-    ) -> Awaitable[str]:
+    ) -> Optional[str]:
+        """Async version of `invoke`. See `invoke` for full documentation."""
         raise NotImplementedError("async_invoke is not implemented")

{mlrun-1.10.0rc14 → mlrun-1.10.0rc16}/mlrun/datastore/model_provider/openai_provider.py

@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
+from collections.abc import Awaitable
 from typing import Callable, Optional, TypeVar, Union
 
 import mlrun
@@ -33,6 +33,8 @@ class OpenAIProvider(ModelProvider):
     operations tailored to the OpenAI API.
     """
 
+    support_async = True
+
     def __init__(
         self,
         parent,
@@ -67,7 +69,7 @@ class OpenAIProvider(ModelProvider):
         return endpoint, subpath
 
     @property
-    def model(self):
+    def model(self) -> Optional[str]:
         return self.endpoint
 
     def load_client(self) -> None:
@@ -76,23 +78,20 @@ class OpenAIProvider(ModelProvider):
 
         This method imports the `OpenAI` class from the `openai` package, instantiates
         a client with the given keyword arguments (`self.options`), and assigns it to
-        `self._client`.
-
-        It also sets the default operation to `self.client.chat.completions.create`, which is
-        typically used for invoking chat-based model completions.
+        `self._client` and `self._async_client`.
 
         Raises:
             ImportError: If the `openai` package is not installed.
         """
         try:
-            from openai import OpenAI  # noqa
+            from openai import OpenAI, AsyncOpenAI  # noqa
 
             self._client = OpenAI(**self.options)
-            self._default_operation = self.client.chat.completions.create
+            self._async_client = AsyncOpenAI(**self.options)
         except ImportError as exc:
             raise ImportError("openai package is not installed") from exc
 
-    def get_client_options(self):
+    def get_client_options(self) -> dict:
         res = dict(
             api_key=self._get_secret_or_env("OPENAI_API_KEY"),
             organization=self._get_secret_or_env("OPENAI_ORG_ID"),
@@ -103,14 +102,69 @@ class OpenAIProvider(ModelProvider):
         )
         return self._sanitize_options(res)
 
-    def customized_invoke(
+    def custom_invoke(
         self, operation: Optional[Callable[..., T]] = None, **invoke_kwargs
     ) -> Optional[T]:
+        """
+        OpenAI-specific implementation of `ModelProvider.custom_invoke`.
+
+        Invokes an OpenAI model operation using the sync client. For full details, see
+        `ModelProvider.custom_invoke`.
+
+        Example:
+            ```python
+            result = openai_model_provider.invoke(
+                openai_model_provider.client.images.generate,
+                prompt="A futuristic cityscape at sunset",
+                n=1,
+                size="1024x1024",
+            )
+            ```
+        :param      operation:      Same as ModelProvider.custom_invoke.
+        :param      invoke_kwargs:  Same as ModelProvider.custom_invoke.
+        :return:                    Same as ModelProvider.custom_invoke.
+
+        """
         invoke_kwargs = self.get_invoke_kwargs(invoke_kwargs)
         if operation:
             return operation(**invoke_kwargs, model=self.model)
         else:
-            return self._default_operation(**invoke_kwargs, model=self.model)
+            return self.client.chat.completions.create(
+                **invoke_kwargs, model=self.model
+            )
+
+    async def async_custom_invoke(
+        self,
+        operation: Optional[Callable[..., Awaitable[T]]] = None,
+        **invoke_kwargs,
+    ) -> Optional[T]:
+        """
+        OpenAI-specific implementation of `ModelProvider.async_custom_invoke`.
+
+        Invokes an OpenAI model operation using the async client. For full details, see
+        `ModelProvider.async_custom_invoke`.
+
+        Example:
+            ```python
+            result = openai_model_provider.invoke(
+                openai_model_provider.async_client.images.generate,
+                prompt="A futuristic cityscape at sunset",
+                n=1,
+                size="1024x1024",
+            )
+            ```
+        :param operation:       Same as ModelProvider.async_custom_invoke.
+        :param invoke_kwargs:   Same as ModelProvider.async_custom_invoke.
+        :return:                Same as ModelProvider.async_custom_invoke.
+
+        """
+        invoke_kwargs = self.get_invoke_kwargs(invoke_kwargs)
+        if operation:
+            return await operation(**invoke_kwargs, model=self.model)
+        else:
+            return await self.async_client.chat.completions.create(
+                **invoke_kwargs, model=self.model
+            )
 
     def invoke(
         self,
@@ -133,12 +187,39 @@ class OpenAIProvider(ModelProvider):
 
         :param invoke_kwargs:
                             Same as ModelProvider.invoke.
+        :return:            Same as ModelProvider.invoke.
 
         """
-        invoke_kwargs = self.get_invoke_kwargs(invoke_kwargs)
-        response = self._default_operation(
-            model=self.endpoint, messages=messages, **invoke_kwargs
-        )
+        response = self.custom_invoke(messages=messages, **invoke_kwargs)
+        if as_str:
+            return response.choices[0].message.content
+        return response
+
+    async def async_invoke(
+        self,
+        messages: Optional[list[dict]] = None,
+        as_str: bool = False,
+        **invoke_kwargs,
+    ) -> str:
+        """
+        OpenAI-specific implementation of `ModelProvider.async_invoke`.
+        Invokes an OpenAI model operation using the async client.
+        For full details, see `ModelProvider.async_invoke`.
+
+        :param messages:    Same as ModelProvider.async_invoke.
+
+        :param as_str: bool
+                            If `True`, returns only the main content of the first response
+                            (`response.choices[0].message.content`).
+                            If `False`, returns the full awaited response object, whose type depends on
+                            the specific OpenAI SDK operation used (e.g., chat completion, completion, etc.).
+
+        :param invoke_kwargs:
+                            Same as ModelProvider.async_invoke.
+        :returns            Same as ModelProvider.async_invoke.
+
+        """
+        response = await self.async_custom_invoke(messages=messages, **invoke_kwargs)
         if as_str:
             return response.choices[0].message.content
         return response

{mlrun-1.10.0rc14 → mlrun-1.10.0rc16}/mlrun/db/base.py

@@ -55,6 +55,12 @@ class RunDBInterface(ABC):
     def update_run(self, updates: dict, uid, project="", iter=0):
         pass
 
+    @abstractmethod
+    def set_run_retrying_status(
+        self, project: str, name: str, run_id: str, retrying: bool
+    ):
+        pass
+
     @abstractmethod
     def abort_run(self, uid, project="", iter=0, timeout=45, status_text=""):
         pass
@@ -638,6 +644,11 @@ class RunDBInterface(ABC):
     ):
         pass
 
+    def wait_for_background_task_to_reach_terminal_state(
+        self, name: str, project: str = ""
+    ) -> mlrun.common.schemas.BackgroundTask:
+        pass
+
     @abstractmethod
     def retry_pipeline(
         self,
@@ -1145,3 +1156,12 @@ class RunDBInterface(ABC):
     @abstractmethod
     def get_project_summary(self, project: str) -> mlrun.common.schemas.ProjectSummary:
         pass
+
+    @abstractmethod
+    def get_drift_over_time(
+        self,
+        project: str,
+        start: Optional[datetime.datetime] = None,
+        end: Optional[datetime.datetime] = None,
+    ) -> mlrun.common.schemas.model_monitoring.ModelEndpointDriftValues:
+        pass