mlrun 1.7.0rc5__py3-none-any.whl → 1.7.0rc7__py3-none-any.whl

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