mlrun 1.7.0rc6__py3-none-any.whl → 1.7.0rc9__py3-none-any.whl

mlrun/model_monitoring/{stores → db/stores}/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2023 Iguazio
+# Copyright 2024 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -16,60 +16,54 @@
 
 import enum
 import typing
+import warnings
 
 import mlrun.common.schemas.secret
 import mlrun.errors
 
-from .model_endpoint_store import ModelEndpointStore
+from .base import StoreBase
 
 
-class ModelEndpointStoreType(enum.Enum):
-    """Enum class to handle the different store type values for saving a model endpoint record."""
+class ObjectStoreFactory(enum.Enum):
+    """Enum class to handle the different store type values for saving model monitoring records."""
 
     v3io_nosql = "v3io-nosql"
     SQL = "sql"
 
-    def to_endpoint_store(
+    def to_object_store(
         self,
         project: str,
         access_key: str = None,
-        endpoint_store_connection: str = None,
         secret_provider: typing.Callable = None,
-    ) -> ModelEndpointStore:
+    ) -> StoreBase:
         """
-        Return a ModelEndpointStore object based on the provided enum value.
-
-        :param project:                    The name of the project.
-        :param access_key:                 Access key with permission to the DB table. Note that if access key is None
-                                           and the endpoint target is from type KV then the access key will be
-                                           retrieved from the environment variable.
-        :param endpoint_store_connection: A valid connection string for model endpoint target. Contains several
-                                          key-value pairs that required for the database connection.
-                                          e.g. A root user with password 1234, tries to connect a schema called
-                                          mlrun within a local MySQL DB instance:
-                                          'mysql+pymysql://root:1234@localhost:3306/mlrun'.
+        Return a StoreBase object based on the provided enum value.
+
+        :param project:                   The name of the project.
+        :param access_key:                Access key with permission to the DB table. Note that if access key is None
+                                          and the endpoint target is from type KV then the access key will be
+                                          retrieved from the environment variable.
         :param secret_provider:           An optional secret provider to get the connection string secret.
 
-        :return: `ModelEndpointStore` object.
+        :return: `StoreBase` object.
 
         """
 
-        if self.value == ModelEndpointStoreType.v3io_nosql.value:
-            from .kv_model_endpoint_store import KVModelEndpointStore
+        if self == self.v3io_nosql:
+            from mlrun.model_monitoring.db.stores.v3io_kv.kv_store import KVStoreBase
 
             # Get V3IO access key from env
             access_key = access_key or mlrun.mlconf.get_v3io_access_key()
 
-            return KVModelEndpointStore(project=project, access_key=access_key)
+            return KVStoreBase(project=project, access_key=access_key)
 
         # Assuming SQL store target if store type is not KV.
         # Update these lines once there are more than two store target types.
 
-        from .sql_model_endpoint_store import SQLModelEndpointStore
+        from mlrun.model_monitoring.db.stores.sqldb.sql_store import SQLStoreBase
 
-        return SQLModelEndpointStore(
+        return SQLStoreBase(
             project=project,
-            sql_connection_string=endpoint_store_connection,
             secret_provider=secret_provider,
         )
 
@@ -88,7 +82,24 @@ def get_model_endpoint_store(
     project: str,
     access_key: str = None,
     secret_provider: typing.Callable = None,
-) -> ModelEndpointStore:
+) -> StoreBase:
+    # Leaving here for backwards compatibility
+    warnings.warn(
+        "The 'get_model_endpoint_store' function is deprecated and will be removed in 1.9.0. "
+        "Please use `get_store_object` instead.",
+        # TODO: remove in 1.9.0
+        FutureWarning,
+    )
+    return get_store_object(
+        project=project, access_key=access_key, secret_provider=secret_provider
+    )
+
+
+def get_store_object(
+    project: str,
+    access_key: str = None,
+    secret_provider: typing.Callable = None,
+) -> StoreBase:
     """
     Getting the DB target type based on mlrun.config.model_endpoint_monitoring.store_type.
 
@@ -96,16 +107,14 @@ def get_model_endpoint_store(
     :param access_key:      Access key with permission to the DB table.
     :param secret_provider: An optional secret provider to get the connection string secret.
 
-    :return: `ModelEndpointStore` object. Using this object, the user can apply different operations on the
-             model endpoint record such as write, update, get and delete.
+    :return: `StoreBase` object. Using this object, the user can apply different operations on the
+             model monitoring record such as write, update, get and delete a model endpoint.
     """
 
-    # Get store type value from ModelEndpointStoreType enum class
-    model_endpoint_store_type = ModelEndpointStoreType(
-        mlrun.mlconf.model_endpoint_monitoring.store_type
-    )
+    # Get store type value from ObjectStoreFactory enum class
+    store_type = ObjectStoreFactory(mlrun.mlconf.model_endpoint_monitoring.store_type)
 
-    # Convert into model endpoint store target object
-    return model_endpoint_store_type.to_endpoint_store(
+    # Convert into store target object
+    return store_type.to_object_store(
         project=project, access_key=access_key, secret_provider=secret_provider
     )

mlrun/model_monitoring/db/stores/base/__init__.py

@@ -0,0 +1,15 @@
+# Copyright 2024 Iguazio
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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 .store import StoreBase

mlrun/model_monitoring/{stores/model_endpoint_store.py → db/stores/base/store.py}

@@ -1,4 +1,4 @@
-# Copyright 2023 Iguazio
+# Copyright 2024 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,22 +11,21 @@
 # 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 typing
 from abc import ABC, abstractmethod
 
 
-class ModelEndpointStore(ABC):
+class StoreBase(ABC):
     """
-    An abstract class to handle the model endpoint in the DB target.
+    An abstract class to handle the store object in the DB target.
     """
 
     def __init__(self, project: str):
         """
-        Initialize a new model endpoint target.
+        Initialize a new store target.
 
-        :param project:             The name of the project.
+        :param project: The name of the project.
         """
         self.project = project
 
@@ -143,3 +142,45 @@ class ModelEndpointStore(ABC):
         """
 
         pass
+
+    @abstractmethod
+    def write_application_result(self, event: dict[str, typing.Any]):
+        """
+        Write a new application result event in the target table.
+
+        :param event: An event dictionary that represents the application result, should be corresponded to the
+                      schema defined in the :py:class:`~mlrun.common.schemas.model_monitoring.constants.WriterEvent`
+                      object.
+        """
+        pass
+
+    @abstractmethod
+    def get_last_analyzed(self, endpoint_id: str, application_name: str) -> int:
+        """
+        Get the last analyzed time for the provided model endpoint and application.
+
+        :param endpoint_id:      The unique id of the model endpoint.
+        :param application_name: Registered application name.
+
+        :return: Timestamp as a Unix time.
+        :raise:  MLRunNotFoundError if last analyzed value is not found.
+        """
+        pass
+
+    @abstractmethod
+    def update_last_analyzed(
+        self,
+        endpoint_id: str,
+        application_name: str,
+        last_analyzed: int,
+    ):
+        """
+        Update the last analyzed time for the provided model endpoint and application.
+
+        :param endpoint_id:      The unique id of the model endpoint.
+        :param application_name: Registered application name.
+        :param last_analyzed:    Timestamp as a Unix time that represents the last analyzed time of a certain
+                                 application and model endpoint.
+
+        """
+        pass

mlrun/model_monitoring/db/stores/sqldb/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2024 Iguazio
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.

mlrun/model_monitoring/db/stores/sqldb/models/__init__.py

@@ -0,0 +1,49 @@
+# Copyright 2023 Iguazio
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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 typing import Optional, Union
+
+from .mysql import ApplicationResultTable as MySQLApplicationResultTable
+from .mysql import ModelEndpointsTable as MySQLModelEndpointsTable
+from .mysql import MonitoringSchedulesTable as MySQLMonitoringSchedulesTable
+from .sqlite import ApplicationResultTable as SQLiteApplicationResultTable
+from .sqlite import ModelEndpointsTable as SQLiteModelEndpointsTable
+from .sqlite import MonitoringSchedulesTable as SQLiteMonitoringSchedulesTable
+
+
+def _get_model_endpoints_table(
+    connection_string: Optional[str] = None,
+) -> Union[type[MySQLModelEndpointsTable], type[SQLiteModelEndpointsTable]]:
+    """Return ModelEndpointsTable based on the provided connection string"""
+    if connection_string and "mysql:" in connection_string:
+        return MySQLModelEndpointsTable
+    return SQLiteModelEndpointsTable
+
+
+def _get_application_result_table(
+    connection_string: Optional[str] = None,
+) -> Union[type[MySQLApplicationResultTable], type[SQLiteApplicationResultTable]]:
+    """Return ModelEndpointsTable based on the provided connection string"""
+    if connection_string and "mysql:" in connection_string:
+        return MySQLApplicationResultTable
+    return SQLiteApplicationResultTable
+
+
+def _get_monitoring_schedules_table(
+    connection_string: Optional[str] = None,
+) -> Union[type[MySQLMonitoringSchedulesTable], type[SQLiteMonitoringSchedulesTable]]:
+    """Return ModelEndpointsTable based on the provided connection string"""
+    if connection_string and "mysql:" in connection_string:
+        return MySQLMonitoringSchedulesTable
+    return SQLiteMonitoringSchedulesTable

mlrun/model_monitoring/{stores → db/stores/sqldb}/models/base.py

@@ -11,10 +11,22 @@
 # 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 sqlalchemy import (
+    TIMESTAMP,
+    Boolean,
+    Column,
+    Float,
+    Integer,
+    String,
+    Text,
+)
 
-from sqlalchemy import TIMESTAMP, Boolean, Column, Integer, String, Text
-
-from mlrun.common.schemas.model_monitoring import EventFieldType
+from mlrun.common.schemas.model_monitoring import (
+    EventFieldType,
+    FileTargetKind,
+    SchedulingKeys,
+    WriterEvent,
+)
 from mlrun.utils.db import BaseModel
 
 
@@ -82,3 +94,64 @@ class ModelEndpointsBaseTable(BaseModel):
         EventFieldType.LAST_REQUEST,
         TIMESTAMP,
     )
+
+
+class ApplicationResultBaseTable(BaseModel):
+    __tablename__ = FileTargetKind.APP_RESULTS
+
+    uid = Column(EventFieldType.UID, String(120), primary_key=True)
+
+    application_name = Column(
+        WriterEvent.APPLICATION_NAME,
+        String(40),
+        nullable=True,
+    )
+
+    endpoint_id = Column(
+        WriterEvent.ENDPOINT_ID,
+        String(40),
+        nullable=True,
+    )
+
+    result_name = Column(
+        WriterEvent.RESULT_NAME,
+        String(40),
+    )
+
+    start_infer_time = Column(
+        WriterEvent.START_INFER_TIME,
+        TIMESTAMP(timezone=True),
+    )
+    end_infer_time = Column(
+        WriterEvent.END_INFER_TIME,
+        TIMESTAMP(timezone=True),
+    )
+
+    result_status = Column(WriterEvent.RESULT_STATUS, String(10))
+    result_kind = Column(WriterEvent.RESULT_KIND, String(40))
+    result_value = Column(WriterEvent.RESULT_VALUE, Float)
+    result_extra_data = Column(WriterEvent.RESULT_EXTRA_DATA, Text)
+    current_stats = Column(WriterEvent.CURRENT_STATS, Text)
+
+
+class MonitoringSchedulesBaseTable(BaseModel):
+    __tablename__ = FileTargetKind.MONITORING_SCHEDULES
+
+    uid = Column(SchedulingKeys.UID, String(32), primary_key=True)
+
+    application_name = Column(
+        SchedulingKeys.APPLICATION_NAME,
+        String(40),
+        nullable=False,
+    )
+
+    endpoint_id = Column(
+        SchedulingKeys.ENDPOINT_ID,
+        String(40),
+        nullable=False,
+    )
+
+    last_analyzed = Column(
+        SchedulingKeys.LAST_ANALYZED,
+        Integer,
+    )

mlrun/model_monitoring/db/stores/sqldb/models/mysql.py

@@ -0,0 +1,68 @@
+# Copyright 2023 Iguazio
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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 sqlalchemy.dialects.mysql
+from sqlalchemy import Column, ForeignKey, String
+from sqlalchemy.ext.declarative import declarative_base, declared_attr
+
+from mlrun.common.schemas.model_monitoring import (
+    EventFieldType,
+    WriterEvent,
+)
+
+from .base import (
+    ApplicationResultBaseTable,
+    ModelEndpointsBaseTable,
+    MonitoringSchedulesBaseTable,
+)
+
+Base = declarative_base()
+
+
+class ModelEndpointsTable(Base, ModelEndpointsBaseTable):
+    first_request = Column(
+        EventFieldType.FIRST_REQUEST,
+        sqlalchemy.dialects.mysql.TIMESTAMP(fsp=3),
+    )
+    last_request = Column(
+        EventFieldType.LAST_REQUEST,
+        sqlalchemy.dialects.mysql.TIMESTAMP(fsp=3),
+    )
+
+
+class ApplicationResultTable(Base, ApplicationResultBaseTable):
+    start_infer_time = Column(
+        WriterEvent.START_INFER_TIME,
+        sqlalchemy.dialects.mysql.TIMESTAMP(fsp=3),
+    )
+    end_infer_time = Column(
+        WriterEvent.END_INFER_TIME,
+        sqlalchemy.dialects.mysql.TIMESTAMP(fsp=3),
+    )
+
+    @declared_attr
+    def endpoint_id(cls):
+        return Column(
+            String(40),
+            ForeignKey(f"{EventFieldType.MODEL_ENDPOINTS}.{EventFieldType.UID}"),
+        )
+
+
+class MonitoringSchedulesTable(Base, MonitoringSchedulesBaseTable):
+    @declared_attr
+    def endpoint_id(cls):
+        return Column(
+            String(40),
+            ForeignKey(f"{EventFieldType.MODEL_ENDPOINTS}.{EventFieldType.UID}"),
+        )

mlrun/model_monitoring/{stores → db/stores/sqldb}/models/sqlite.py

@@ -14,10 +14,22 @@
 
 from sqlalchemy.ext.declarative import declarative_base
 
-from .base import ModelEndpointsBaseTable
+from .base import (
+    ApplicationResultBaseTable,
+    ModelEndpointsBaseTable,
+    MonitoringSchedulesBaseTable,
+)
 
 Base = declarative_base()
 
 
 class ModelEndpointsTable(Base, ModelEndpointsBaseTable):
     pass
+
+
+class ApplicationResultTable(Base, ApplicationResultBaseTable):
+    pass
+
+
+class MonitoringSchedulesTable(Base, MonitoringSchedulesBaseTable):
+    pass