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

mlrun/artifacts/model.py

@@ -13,12 +13,12 @@
 # limitations under the License.
 
 import tempfile
+import warnings
 from os import path
 from typing import Any, Optional
 
 import pandas as pd
 import yaml
-from deprecated import deprecated
 
 import mlrun
 import mlrun.datastore
@@ -27,7 +27,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"
 
@@ -149,6 +149,12 @@ class ModelArtifact(Artifact):
         model_dir=None,
         **kwargs,
     ):
+        if key or body or format or target_path:
+            warnings.warn(
+                "Artifact constructor parameters are deprecated and will be removed in 1.9.0. "
+                "Use the metadata and spec parameters instead.",
+                DeprecationWarning,
+            )
         super().__init__(key, body, format=format, target_path=target_path, **kwargs)
         model_file = str(model_file or "")
         if model_file and "/" in model_file:
@@ -397,144 +403,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

@@ -13,14 +13,12 @@
 # limitations under the License.
 import base64
 import typing
+import warnings
 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
@@ -37,6 +35,12 @@ class PlotArtifact(Artifact):
     def __init__(
         self, key=None, body=None, is_inline=False, target_path=None, title=None
     ):
+        if key or body or is_inline or target_path:
+            warnings.warn(
+                "Artifact constructor parameters are deprecated and will be removed in 1.9.0. "
+                "Use the metadata and spec parameters instead.",
+                DeprecationWarning,
+            )
         super().__init__(key, body, format="html", target_path=target_path)
         self.metadata.description = title
 
@@ -70,138 +74,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.
@@ -222,6 +94,12 @@ class PlotlyArtifact(Artifact):
         :param key:         Key for the artifact to be stored in the database.
         :param target_path: Path to save the artifact.
         """
+        if key or target_path:
+            warnings.warn(
+                "Artifact constructor parameters are deprecated and will be removed in 1.9.0. "
+                "Use the metadata and spec parameters instead.",
+                DeprecationWarning,
+            )
         # Validate the plotly package:
         try:
             from plotly.graph_objs import Figure
@@ -258,242 +136,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/__init__.py

@@ -14,7 +14,7 @@
 #
 # flake8: noqa  - this is until we take care of the F401 violations with respect to __all__ & sphinx
 
-from .alert import AlertActiveState, AlertConfig, Event
+from .alert import AlertActiveState, AlertConfig, AlertTemplate, Event
 from .api_gateway import (
     APIGateway,
     APIGatewayAuthenticationMode,
@@ -142,8 +142,10 @@ from .model_monitoring import (
     ModelMonitoringMode,
     ModelMonitoringStoreKinds,
     MonitoringFunctionNames,
+    MonitoringTSDBTables,
     PrometheusEndpoints,
-    TimeSeriesTarget,
+    TimeSeriesConnector,
+    TSDBTarget,
 )
 from .notification import (
     Notification,