mlrun 1.7.0rc14__py3-none-any.whl → 1.7.0rc15__py3-none-any.whl

mlrun/artifacts/manager.py

@@ -24,7 +24,6 @@ from mlrun.utils.helpers import (
 )
 
 from ..utils import (
-    is_legacy_artifact,
     is_relative_path,
     logger,
     validate_artifact_key_name,
@@ -33,56 +32,28 @@ from ..utils import (
 from .base import (
     Artifact,
     DirArtifact,
-    LegacyArtifact,
-    LegacyDirArtifact,
-    LegacyLinkArtifact,
     LinkArtifact,
 )
 from .dataset import (
     DatasetArtifact,
-    LegacyDatasetArtifact,
-    LegacyTableArtifact,
     TableArtifact,
 )
-from .model import LegacyModelArtifact, ModelArtifact
+from .model import ModelArtifact
 from .plots import (
-    BokehArtifact,
-    ChartArtifact,
-    LegacyBokehArtifact,
-    LegacyChartArtifact,
-    LegacyPlotArtifact,
-    LegacyPlotlyArtifact,
     PlotArtifact,
     PlotlyArtifact,
 )
 
-# TODO - Remove deprecated types when deleted in 1.7.0
 artifact_types = {
     "": Artifact,
     "artifact": Artifact,
     "dir": DirArtifact,
     "link": LinkArtifact,
     "plot": PlotArtifact,
-    "chart": ChartArtifact,
     "table": TableArtifact,
     "model": ModelArtifact,
     "dataset": DatasetArtifact,
     "plotly": PlotlyArtifact,
-    "bokeh": BokehArtifact,
-}
-
-# TODO - Remove this when legacy types are deleted in 1.7.0
-legacy_artifact_types = {
-    "": LegacyArtifact,
-    "dir": LegacyDirArtifact,
-    "link": LegacyLinkArtifact,
-    "plot": LegacyPlotArtifact,
-    "chart": LegacyChartArtifact,
-    "table": LegacyTableArtifact,
-    "model": LegacyModelArtifact,
-    "dataset": LegacyDatasetArtifact,
-    "plotly": LegacyPlotlyArtifact,
-    "bokeh": LegacyBokehArtifact,
 }
 
 
@@ -102,15 +73,8 @@ class ArtifactProducer:
 
 
 def dict_to_artifact(struct: dict) -> Artifact:
-    # Need to distinguish between LegacyArtifact classes and Artifact classes. Use existence of the "metadata"
-    # property to make this distinction
     kind = struct.get("kind", "")
-
-    if 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)
 
 
@@ -308,10 +272,7 @@ class ArtifactManager:
             # before uploading the item, we want to ensure that its tags are valid,
             # so that we don't upload something that won't be stored later
             validate_tag_name(item.metadata.tag, "artifact.metadata.tag")
-            if is_legacy_artifact(item):
-                item.upload()
-            else:
-                item.upload(artifact_path=artifact_path)
+            item.upload(artifact_path=artifact_path)
 
         if db_key:
             self._log_to_db(db_key, project, producer.inputs, item)

mlrun/artifacts/model.py

@@ -18,7 +18,6 @@ from typing import Any, Optional
 
 import pandas as pd
 import yaml
-from deprecated import deprecated
 
 import mlrun
 import mlrun.datastore
@@ -27,7 +26,7 @@ from ..data_types import InferOptions, get_infer_interface
 from ..features import Feature
 from ..model import ObjectList
 from ..utils import StorePrefix, is_relative_path
-from .base import Artifact, ArtifactSpec, LegacyArtifact, upload_extra_data
+from .base import Artifact, ArtifactSpec, upload_extra_data
 
 model_spec_filename = "model_spec.yaml"
 
@@ -397,144 +396,6 @@ class ModelArtifact(Artifact):
         return mlrun.get_dataitem(target_model_path).get()
 
 
-# TODO: remove in 1.7.0
-@deprecated(
-    version="1.3.0",
-    reason="'LegacyModelArtifact' will be removed in 1.7.0, use 'ModelArtifact' instead",
-    category=FutureWarning,
-)
-class LegacyModelArtifact(LegacyArtifact):
-    """ML Model artifact
-
-    Store link to ML model file(s) along with the model metrics, parameters, schema, and stats
-    """
-
-    _dict_fields = LegacyArtifact._dict_fields + [
-        "model_file",
-        "metrics",
-        "parameters",
-        "inputs",
-        "outputs",
-        "framework",
-        "algorithm",
-        "extra_data",
-        "feature_vector",
-        "feature_weights",
-        "feature_stats",
-        "model_target_file",
-    ]
-    kind = "model"
-    _store_prefix = StorePrefix.Model
-
-    def __init__(
-        self,
-        key=None,
-        body=None,
-        format=None,
-        model_file=None,
-        metrics=None,
-        target_path=None,
-        parameters=None,
-        inputs=None,
-        outputs=None,
-        framework=None,
-        algorithm=None,
-        feature_vector=None,
-        feature_weights=None,
-        extra_data=None,
-        model_target_file=None,
-        **kwargs,
-    ):
-        super().__init__(key, body, format=format, target_path=target_path, **kwargs)
-        self._inputs: Optional[ObjectList] = None
-        self._outputs: Optional[ObjectList] = None
-
-        self.model_file = model_file
-        self.parameters = parameters or {}
-        self.metrics = metrics or {}
-        self.inputs = inputs or []
-        self.outputs = outputs or []
-        self.extra_data = extra_data or {}
-        self.framework = framework
-        self.algorithm = algorithm
-        self.feature_vector = feature_vector
-        self.feature_weights = feature_weights
-        self.feature_stats = None
-        self.model_target_file = model_target_file
-
-    @property
-    def inputs(self) -> Optional[ObjectList]:
-        """input feature list"""
-        return self._inputs
-
-    @inputs.setter
-    def inputs(self, inputs: list[Feature]) -> None:
-        self._inputs = ObjectList.from_list(Feature, inputs)
-
-    @property
-    def outputs(self) -> Optional[ObjectList]:
-        """output feature list"""
-        return self._outputs
-
-    @outputs.setter
-    def outputs(self, outputs: list[Feature]) -> None:
-        self._outputs = ObjectList.from_list(Feature, outputs)
-
-    def infer_from_df(self, df, label_columns=None, with_stats=True, num_bins=None):
-        """infer inputs, outputs, and stats from provided df (training set)
-
-        :param df:      dataframe to infer from
-        :param label_columns: name of the label (target) column
-        :param with_stats:    infer statistics (min, max, .. histogram)
-        :param num_bins:      number of bins for histogram
-        """
-        subset = df
-        inferer = get_infer_interface(subset)
-        if label_columns:
-            if not isinstance(label_columns, list):
-                label_columns = [label_columns]
-            subset = df.drop(columns=label_columns)
-        inferer.infer_schema(subset, self.inputs, {}, options=InferOptions.Features)
-        if label_columns:
-            inferer.infer_schema(
-                df[label_columns], self.outputs, {}, options=InferOptions.Features
-            )
-        if with_stats:
-            self.feature_stats = inferer.get_stats(
-                df, options=InferOptions.Histogram, num_bins=num_bins
-            )
-
-    @property
-    def is_dir(self):
-        return True
-
-    def before_log(self):
-        if not self.model_file:
-            raise ValueError("model_file attr must be specified")
-
-        super().before_log()
-
-        if self.framework:
-            self.labels = self.labels or {}
-            self.labels["framework"] = self.framework
-
-    def upload(self):
-        target_model_path = path.join(self.target_path, self.model_file)
-        body = self.get_body()
-        if body:
-            self._upload_body(body, target=target_model_path)
-        else:
-            src_model_path = _get_src_path(self, self.model_file)
-            if not path.isfile(src_model_path):
-                raise ValueError(f"model file {src_model_path} not found")
-            self._upload_file(src_model_path, target=target_model_path)
-
-        upload_extra_data(self, self.extra_data)
-
-        spec_path = path.join(self.target_path, model_spec_filename)
-        mlrun.datastore.store_manager.object(url=spec_path).put(self.to_yaml())
-
-
 def _get_src_path(model_spec: ModelArtifact, filename):
     if model_spec.src_path:
         return path.join(model_spec.src_path, filename)

mlrun/artifacts/plots.py

@@ -15,12 +15,9 @@ import base64
 import typing
 from io import BytesIO
 
-from deprecated import deprecated
-
 import mlrun
 
-from ..utils import dict_to_json
-from .base import Artifact, LegacyArtifact
+from .base import Artifact
 
 if typing.TYPE_CHECKING:
     from plotly.graph_objs import Figure
@@ -70,138 +67,6 @@ class PlotArtifact(Artifact):
         )
 
 
-# TODO: remove in 1.7.0
-@deprecated(
-    version="1.5.0",
-    reason="'ChartArtifact' will be removed in 1.7.0, use 'Artifact' instead",
-    category=FutureWarning,
-)
-class ChartArtifact(Artifact):
-    kind = "chart"
-
-    _TEMPLATE = """
-<html>
-  <head>
-    <script
-        type="text/javascript"
-        src="https://www.gstatic.com/charts/loader.js"></script>
-    <script type="text/javascript">
-      google.charts.load('current', {'packages':['corechart']});
-      google.charts.setOnLoadCallback(drawChart);
-      function drawChart() {
-        var data = google.visualization.arrayToDataTable($data$);
-        var options = $opts$;
-        var chart = new google.visualization.$chart$(
-            document.getElementById('chart_div'));
-        chart.draw(data, options);
-      }
-    </script>
-  </head>
-  <body>
-    <div id="chart_div" style="width: 100%; height: 500px;"></div>
-  </body>
-</html>
-"""
-
-    def __init__(
-        self,
-        key=None,
-        data=None,
-        header=None,
-        options=None,
-        title=None,
-        chart=None,
-        target_path=None,
-    ):
-        data = [] if data is None else data
-        options = {} if options is None else options
-        super().__init__(key, target_path=target_path)
-        self.viewer = "chart"
-        self.header = header or []
-        self.title = title
-        self.rows = []
-        if data:
-            if header:
-                self.rows = data
-            else:
-                self.header = data[0]
-                self.rows = data[1:]
-        self.options = options
-        self.chart = chart or "LineChart"
-        self.format = "html"
-
-    def add_row(self, row):
-        self.rows += [row]
-
-    def get_body(self):
-        if not self.options.get("title"):
-            self.options["title"] = self.title or self.key
-        data = [self.header] + self.rows
-        return (
-            self._TEMPLATE.replace("$data$", dict_to_json(data))
-            .replace("$opts$", dict_to_json(self.options))
-            .replace("$chart$", self.chart)
-        )
-
-
-# TODO: remove in 1.7.0
-@deprecated(
-    version="1.5.0",
-    reason="'BokehArtifact' will be removed in 1.7.0, use 'Artifact' instead",
-    category=FutureWarning,
-)
-class BokehArtifact(Artifact):
-    """
-    Bokeh artifact is an artifact for saving Bokeh generated figures. They will be stored in a html format.
-    """
-
-    kind = "bokeh"
-
-    def __init__(
-        self,
-        figure=None,
-        key: str = None,
-        target_path: str = None,
-    ):
-        """
-        Initialize a Bokeh artifact with the given figure.
-
-        :param figure:      Bokeh figure ('bokeh.plotting.Figure' object) to save as an artifact.
-        :param key:         Key for the artifact to be stored in the database.
-        :param target_path: Path to save the artifact.
-        """
-        # Validate input:
-        try:
-            from bokeh.plotting import Figure
-        except (ModuleNotFoundError, ImportError) as Error:
-            raise Error(
-                "Using 'BokehArtifact' requires bokeh package. Use pip install mlrun[bokeh] to install it."
-            )
-        if figure is not None and not isinstance(figure, Figure):
-            raise ValueError(
-                "BokehArtifact requires the figure parameter to be a "
-                f"'bokeh.plotting.Figure' but received '{type(figure)}'"
-            )
-
-        # Call the artifact initializer:
-        super().__init__(key=key, target_path=target_path, viewer="bokeh")
-
-        # Continue initializing the bokeh artifact:
-        self._figure = figure
-        self.spec.format = "html"
-
-    def get_body(self):
-        """
-        Get the artifact's body - the bokeh figure's html code.
-
-        :return: The figure's html code.
-        """
-        from bokeh.embed import file_html
-        from bokeh.resources import CDN
-
-        return file_html(self._figure, CDN, self.metadata.key)
-
-
 class PlotlyArtifact(Artifact):
     """
     Plotly artifact is an artifact for saving Plotly generated figures. They will be stored in a html format.
@@ -258,242 +123,3 @@ class PlotlyArtifact(Artifact):
         :return: The figure's html code.
         """
         return self._figure.to_html()
-
-
-# TODO: remove in 1.7.0
-@deprecated(
-    version="1.3.0",
-    reason="'LegacyPlotArtifact' will be removed in 1.7.0, use 'PlotArtifact' instead",
-    category=FutureWarning,
-)
-class LegacyPlotArtifact(LegacyArtifact):
-    _TEMPLATE = """
-<h3 style="text-align:center">{}</h3>
-<img title="{}" src="data:image/png;base64,{}">
-"""
-    kind = "plot"
-
-    def __init__(
-        self, key=None, body=None, is_inline=False, target_path=None, title=None
-    ):
-        super().__init__(key, body, format="html", target_path=target_path)
-        self.description = title
-
-    def before_log(self):
-        self.viewer = "chart"
-        import matplotlib
-
-        if not self._body or not isinstance(
-            self._body, (bytes, matplotlib.figure.Figure)
-        ):
-            raise ValueError(
-                "matplotlib fig or png bytes must be provided as artifact body"
-            )
-
-    def get_body(self):
-        """Convert Matplotlib figure 'fig' into a <img> tag for HTML use
-        using base64 encoding."""
-        if isinstance(self._body, bytes):
-            data = self._body
-        else:
-            from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
-
-            canvas = FigureCanvas(self._body)
-            png_output = BytesIO()
-            canvas.print_png(png_output)
-            data = png_output.getvalue()
-
-        data_uri = base64.b64encode(data).decode("utf-8")
-        return self._TEMPLATE.format(self.description or self.key, self.key, data_uri)
-
-
-# TODO: remove in 1.7.0
-@deprecated(
-    version="1.3.0",
-    reason="'LegacyChartArtifact' will be removed in 1.7.0, use 'ChartArtifact' instead",
-    category=FutureWarning,
-)
-class LegacyChartArtifact(LegacyArtifact):
-    _TEMPLATE = """
-<html>
-  <head>
-    <script
-        type="text/javascript"
-        src="https://www.gstatic.com/charts/loader.js"></script>
-    <script type="text/javascript">
-      google.charts.load('current', {'packages':['corechart']});
-      google.charts.setOnLoadCallback(drawChart);
-      function drawChart() {
-        var data = google.visualization.arrayToDataTable($data$);
-        var options = $opts$;
-        var chart = new google.visualization.$chart$(
-            document.getElementById('chart_div'));
-        chart.draw(data, options);
-      }
-    </script>
-  </head>
-  <body>
-    <div id="chart_div" style="width: 100%; height: 500px;"></div>
-  </body>
-</html>
-"""
-
-    kind = "chart"
-
-    def __init__(
-        self,
-        key=None,
-        data=None,
-        header=None,
-        options=None,
-        title=None,
-        chart=None,
-        target_path=None,
-    ):
-        data = [] if data is None else data
-        options = {} if options is None else options
-        super().__init__(key, target_path=target_path)
-        self.viewer = "chart"
-        self.header = header or []
-        self.title = title
-        self.rows = []
-        if data:
-            if header:
-                self.rows = data
-            else:
-                self.header = data[0]
-                self.rows = data[1:]
-        self.options = options
-        self.chart = chart or "LineChart"
-        self.format = "html"
-
-    def add_row(self, row):
-        self.rows += [row]
-
-    def get_body(self):
-        if not self.options.get("title"):
-            self.options["title"] = self.title or self.key
-        data = [self.header] + self.rows
-        return (
-            self._TEMPLATE.replace("$data$", dict_to_json(data))
-            .replace("$opts$", dict_to_json(self.options))
-            .replace("$chart$", self.chart)
-        )
-
-
-# TODO: remove in 1.7.0
-@deprecated(
-    version="1.3.0",
-    reason="'LegacyBokehArtifact' will be removed in 1.7.0, use 'BokehArtifact' instead",
-    category=FutureWarning,
-)
-class LegacyBokehArtifact(LegacyArtifact):
-    """
-    Bokeh artifact is an artifact for saving Bokeh generated figures. They will be stored in a html format.
-    """
-
-    kind = "bokeh"
-
-    def __init__(
-        self,
-        figure=None,
-        key: str = None,
-        target_path: str = None,
-    ):
-        """
-        Initialize a Bokeh artifact with the given figure.
-        :param figure:      Bokeh figure ('bokeh.plotting.Figure' object) to save as an artifact.
-        :param key:         Key for the artifact to be stored in the database.
-        :param target_path: Path to save the artifact.
-        """
-        # Validate input:
-        try:
-            from bokeh.plotting import Figure
-        except (ModuleNotFoundError, ImportError) as Error:
-            raise Error(
-                "Using 'BokehArtifact' requires bokeh package. Use pip install mlrun[bokeh] to install it."
-            )
-        if figure is not None and not isinstance(figure, Figure):
-            raise ValueError(
-                "BokehArtifact requires the figure parameter to be a "
-                f"'bokeh.plotting.Figure' but received '{type(figure)}'"
-            )
-
-        # Call the artifact initializer:
-        super().__init__(key=key, target_path=target_path, viewer="bokeh")
-
-        # Continue initializing the bokeh artifact:
-        self._figure = figure
-        self.format = "html"
-
-    def get_body(self):
-        """
-        Get the artifact's body - the bokeh figure's html code.
-        :return: The figure's html code.
-        """
-        from bokeh.embed import file_html
-        from bokeh.resources import CDN
-
-        return file_html(self._figure, CDN, self.key)
-
-
-# TODO: remove in 1.7.0
-@deprecated(
-    version="1.3.0",
-    reason="'LegacyPlotlyArtifact' will be removed in 1.7.0, use 'PlotlyArtifact' instead",
-    category=FutureWarning,
-)
-class LegacyPlotlyArtifact(LegacyArtifact):
-    """
-    Plotly artifact is an artifact for saving Plotly generated figures. They will be stored in a html format.
-    """
-
-    kind = "plotly"
-
-    def __init__(
-        self,
-        figure=None,
-        key: str = None,
-        target_path: str = None,
-    ):
-        """
-        Initialize a Plotly artifact with the given figure.
-        :param figure:      Plotly figure ('plotly.graph_objs.Figure' object) to save as an artifact.
-        :param key:         Key for the artifact to be stored in the database.
-        :param target_path: Path to save the artifact.
-        """
-        # Validate the plotly package:
-        try:
-            from plotly.graph_objs import Figure
-        except ModuleNotFoundError:
-            raise mlrun.errors.MLRunMissingDependencyError(
-                "Using `PlotlyArtifact` requires plotly package. Use `pip install mlrun[plotly]` to install it."
-            )
-        except ImportError:
-            import plotly
-
-            raise mlrun.errors.MLRunMissingDependencyError(
-                f"Using `PlotlyArtifact` requires plotly version >= 5.4.0 but found version {plotly.__version__}. "
-                f"Use `pip install -U mlrun[plotly]` to install it."
-            )
-
-        # Call the artifact initializer:
-        super().__init__(key=key, target_path=target_path, viewer="plotly")
-
-        # Validate input:
-        if figure is not None and not isinstance(figure, Figure):
-            raise mlrun.errors.MLRunInvalidArgumentError(
-                f"PlotlyArtifact requires the figure parameter to be a "
-                f"`plotly.graph_objs.Figure` but received '{type(figure)}'"
-            )
-
-        # Continue initializing the plotly artifact:
-        self._figure = figure
-        self.format = "html"
-
-    def get_body(self):
-        """
-        Get the artifact's body - the Plotly figure's html code.
-        :return: The figure's html code.
-        """
-        return self._figure.to_html()

mlrun/common/schemas/model_monitoring/__init__.py

@@ -25,6 +25,7 @@ from .constants import (
     FeatureSetFeatures,
     FileTargetKind,
     FunctionURI,
+    MetricData,
     ModelEndpointTarget,
     ModelMonitoringMode,
     ModelMonitoringStoreKinds,
@@ -32,6 +33,7 @@ from .constants import (
     ProjectSecretKeys,
     PrometheusEndpoints,
     PrometheusMetric,
+    ResultData,
     SchedulingKeys,
     TimeSeriesTarget,
     VersionedModel,
@@ -51,6 +53,8 @@ from .model_endpoints import (
     ModelEndpoint,
     ModelEndpointList,
     ModelEndpointMetadata,
+    ModelEndpointMonitoringMetric,
+    ModelEndpointMonitoringMetricType,
     ModelEndpointSpec,
     ModelEndpointStatus,
 )