mlrun 1.6.0rc13__py3-none-any.whl → 1.6.0rc15__py3-none-any.whl

mlrun/db/httpdb.py

@@ -18,6 +18,7 @@ import tempfile
 import time
 import traceback
 import typing
+import warnings
 from datetime import datetime, timedelta
 from os import path, remove
 from typing import Dict, List, Optional, Union
@@ -280,9 +281,12 @@ class HTTPRunDB(RunDBInterface):
             retry_on_post=retry_on_post,
         )
 
-    def _path_of(self, prefix, project, uid):
+    def _path_of(self, resource, project, uid=None):
         project = project or config.default_project
-        return f"{prefix}/{project}/{uid}"
+        _path = f"projects/{project}/{resource}"
+        if uid:
+            _path += f"/{uid}"
+        return _path
 
     def _is_retry_on_post_allowed(self, method, path: str):
         """
@@ -477,28 +481,37 @@ class HTTPRunDB(RunDBInterface):
         if not body:
             return
 
-        path = self._path_of("log", project, uid)
+        path = self._path_of("logs", project, uid)
         params = {"append": bool2str(append)}
         error = f"store log {project}/{uid}"
         self.api_call("POST", path, error, params, body)
 
-    def get_log(self, uid, project="", offset=0, size=-1):
-        """Retrieve a log.
+    def get_log(self, uid, project="", offset=0, size=None):
+        """Retrieve 1 MB data of log.
 
         :param uid: Log unique ID
         :param project: Project name for which the log belongs
         :param offset: Retrieve partial log, get up to ``size`` bytes starting at offset ``offset``
             from beginning of log
-        :param size: See ``offset``. If set to ``-1`` (the default) will retrieve all data to end of log.
+        :param size: If set to ``-1`` will retrieve and print all data to end of the log by chunks of 1MB each.
         :returns: The following objects:
 
             - state - The state of the runtime object which generates this log, if it exists. In case no known state
               exists, this will be ``unknown``.
             - content - The actual log content.
+            * in case size = -1, return the state and the final offset
         """
+        if size is None:
+            size = int(mlrun.mlconf.httpdb.logs.pull_logs_default_size_limit)
+        elif size == -1:
+            logger.warning(
+                "Retrieving all logs. This may be inefficient and can result in a large log."
+            )
+            state, offset = self.watch_log(uid, project, watch=False, offset=offset)
+            return state, offset
 
         params = {"offset": offset, "size": size}
-        path = self._path_of("log", project, uid)
+        path = self._path_of("logs", project, uid)
         error = f"get log {project}/{uid}"
         resp = self.api_call("GET", path, error, params=params)
         if resp.headers:
@@ -508,46 +521,50 @@ class HTTPRunDB(RunDBInterface):
         return "unknown", resp.content
 
     def watch_log(self, uid, project="", watch=True, offset=0):
-        """Retrieve logs of a running process, and watch the progress of the execution until it completes. This
-        method will print out the logs and continue to periodically poll for, and print, new logs as long as the
-        state of the runtime which generates this log is either ``pending`` or ``running``.
+        """Retrieve logs of a running process by chunks of 1MB, and watch the progress of the execution until it
+        completes. This method will print out the logs and continue to periodically poll for, and print,
+        new logs as long as the state of the runtime which generates this log is either ``pending`` or ``running``.
 
         :param uid: The uid of the log object to watch.
         :param project: Project that the log belongs to.
         :param watch: If set to ``True`` will continue tracking the log as described above. Otherwise this function
             is practically equivalent to the :py:func:`~get_log` function.
         :param offset: Minimal offset in the log to watch.
-        :returns: The final state of the log being watched.
+        :returns: The final state of the log being watched and the final offset.
         """
 
         state, text = self.get_log(uid, project, offset=offset)
         if text:
             print(text.decode(errors=mlrun.mlconf.httpdb.logs.decode.errors))
-        if watch:
-            nil_resp = 0
-            while state in ["pending", "running"]:
-                offset += len(text)
-                # if we get 3 nil responses in a row, increase the sleep time to 10 seconds
-                # TODO: refactor this to use a conditional backoff mechanism
-                if nil_resp < 3:
-                    time.sleep(int(mlrun.mlconf.httpdb.logs.pull_logs_default_interval))
-                else:
-                    time.sleep(
-                        int(
-                            mlrun.mlconf.httpdb.logs.pull_logs_backoff_no_logs_default_interval
-                        )
-                    )
-                state, text = self.get_log(uid, project, offset=offset)
-                if text:
-                    nil_resp = 0
-                    print(
-                        text.decode(errors=mlrun.mlconf.httpdb.logs.decode.errors),
-                        end="",
-                    )
-                else:
-                    nil_resp += 1
-        else:
+        nil_resp = 0
+        while True:
             offset += len(text)
+            # if we get 3 nil responses in a row, increase the sleep time to 10 seconds
+            # TODO: refactor this to use a conditional backoff mechanism
+            if nil_resp < 3:
+                time.sleep(int(mlrun.mlconf.httpdb.logs.pull_logs_default_interval))
+            else:
+                time.sleep(
+                    int(
+                        mlrun.mlconf.httpdb.logs.pull_logs_backoff_no_logs_default_interval
+                    )
+                )
+            state, text = self.get_log(uid, project, offset=offset)
+            if text:
+                nil_resp = 0
+                print(
+                    text.decode(errors=mlrun.mlconf.httpdb.logs.decode.errors),
+                    end="",
+                )
+            else:
+                nil_resp += 1
+
+            if watch and state in ["pending", "running"]:
+                continue
+            else:
+                # the whole log was retrieved
+                if len(text) == 0:
+                    break
 
         return state, offset
 
@@ -555,7 +572,7 @@ class HTTPRunDB(RunDBInterface):
         """Store run details in the DB. This method is usually called from within other :py:mod:`mlrun` flows
         and not called directly by the user."""
 
-        path = self._path_of("run", project, uid)
+        path = self._path_of("runs", project, uid)
         params = {"iter": iter}
         error = f"store run {project}/{uid}"
         body = _as_json(struct)
@@ -564,7 +581,7 @@ class HTTPRunDB(RunDBInterface):
     def update_run(self, updates: dict, uid, project="", iter=0, timeout=45):
         """Update the details of a stored run in the DB."""
 
-        path = self._path_of("run", project, uid)
+        path = self._path_of("runs", project, uid)
         params = {"iter": iter}
         error = f"update run {project}/{uid}"
         body = _as_json(updates)
@@ -605,7 +622,7 @@ class HTTPRunDB(RunDBInterface):
         :param iter: Iteration within a specific execution.
         """
 
-        path = self._path_of("run", project, uid)
+        path = self._path_of("runs", project, uid)
         params = {"iter": iter}
         error = f"get run {project}/{uid}"
         resp = self.api_call("GET", path, error, params=params)
@@ -619,7 +636,7 @@ class HTTPRunDB(RunDBInterface):
         :param iter: Iteration within a specific task.
         """
 
-        path = self._path_of("run", project, uid)
+        path = self._path_of("runs", project, uid)
         params = {"iter": iter}
         error = f"del run {project}/{uid}"
         self.api_call("DELETE", path, error, params=params)
@@ -711,7 +728,6 @@ class HTTPRunDB(RunDBInterface):
         params = {
             "name": name,
             "uid": uid,
-            "project": project,
             "label": labels or [],
             "state": state,
             "sort": bool2str(sort),
@@ -735,7 +751,8 @@ class HTTPRunDB(RunDBInterface):
                 )
             )
         error = "list runs"
-        resp = self.api_call("GET", "runs", error, params=params)
+        _path = self._path_of("runs", project)
+        resp = self.api_call("GET", _path, error, params=params)
         return RunList(resp.json()["runs"])
 
     def del_runs(self, name=None, project=None, labels=None, state=None, days_ago=0):
@@ -761,56 +778,113 @@ class HTTPRunDB(RunDBInterface):
             "days_ago": str(days_ago),
         }
         error = "del runs"
-        self.api_call("DELETE", "runs", error, params=params)
+        _path = self._path_of("runs", project)
+        self.api_call("DELETE", _path, error, params=params)
 
-    def store_artifact(self, key, artifact, uid, iter=None, tag=None, project=""):
+    def store_artifact(
+        self,
+        key,
+        artifact,
+        # TODO: deprecated, remove in 1.8.0
+        uid=None,
+        iter=None,
+        tag=None,
+        project="",
+        tree=None,
+    ):
         """Store an artifact in the DB.
 
         :param key: Identifying key of the artifact.
         :param artifact: The actual artifact to store.
-        :param uid: A unique ID for this specific version of the artifact.
+        :param uid: A unique ID for this specific version of the artifact
+                    (deprecated, artifact uid is generated in the backend use `tree` instead)
         :param iter: The task iteration which generated this artifact. If ``iter`` is not ``None`` the iteration will
             be added to the key provided to generate a unique key for the artifact of the specific iteration.
         :param tag: Tag of the artifact.
         :param project: Project that the artifact belongs to.
+        :param tree: The tree (producer id) which generated this artifact.
         """
+        if uid:
+            warnings.warn(
+                "'uid' is deprecated in 1.6.0 and will be removed in 1.8.0, use 'tree' instead.",
+                # TODO: Remove this in 1.8.0
+                FutureWarning,
+            )
 
-        endpoint_path = f"projects/{project}/artifacts/{uid}/{key}"
-        params = {
-            "tag": tag,
-        }
+        # we do this because previously the 'uid' name was used for the 'tree' parameter
+        tree = tree or uid
+
+        endpoint_path = f"projects/{project}/artifacts/{key}"
+
+        error = f"store artifact {project}/{key}"
+
+        params = {}
         if iter:
             params["iter"] = str(iter)
-
-        error = f"store artifact {project}/{uid}/{key}"
+        if tag:
+            params["tag"] = tag
+        if tree:
+            params["tree"] = tree
 
         body = _as_json(artifact)
-        self.api_call("POST", endpoint_path, error, params=params, body=body)
+        self.api_call(
+            "PUT", endpoint_path, error, body=body, params=params, version="v2"
+        )
 
-    def read_artifact(self, key, tag=None, iter=None, project=""):
-        """Read an artifact, identified by its key, tag and iteration."""
+    def read_artifact(
+        self,
+        key,
+        tag=None,
+        iter=None,
+        project="",
+        tree=None,
+        uid=None,
+    ):
+        """Read an artifact, identified by its key, tag, tree and iteration.
+
+        :param key: Identifying key of the artifact.
+        :param tag: Tag of the artifact.
+        :param iter: The iteration which generated this artifact (where ``iter=0`` means the root iteration).
+        :param project: Project that the artifact belongs to.
+        :param tree: The tree which generated this artifact.
+        :param uid: A unique ID for this specific version of the artifact (the uid that was generated in the backend)
+        """
 
         project = project or config.default_project
         tag = tag or "latest"
-        endpoint_path = f"projects/{project}/artifacts/{key}?tag={tag}"
+        endpoint_path = f"projects/{project}/artifacts/{key}"
         error = f"read artifact {project}/{key}"
         # explicitly set artifacts format to 'full' since old servers may default to 'legacy'
-        params = {"format": mlrun.common.schemas.ArtifactsFormat.full.value}
+        params = {
+            "format": mlrun.common.schemas.ArtifactsFormat.full.value,
+            "tag": tag,
+            "tree": tree,
+            "uid": uid,
+        }
         if iter:
             params["iter"] = str(iter)
-        resp = self.api_call("GET", endpoint_path, error, params=params)
-        return resp.json()["data"]
+        resp = self.api_call("GET", endpoint_path, error, params=params, version="v2")
+        return resp.json()
+
+    def del_artifact(self, key, tag=None, project="", tree=None, uid=None):
+        """Delete an artifact.
 
-    def del_artifact(self, key, tag=None, project=""):
-        """Delete an artifact."""
+        :param key: Identifying key of the artifact.
+        :param tag: Tag of the artifact.
+        :param project: Project that the artifact belongs to.
+        :param tree: The tree which generated this artifact.
+        :param uid: A unique ID for this specific version of the artifact (the uid that was generated in the backend)
+        """
 
         endpoint_path = f"projects/{project}/artifacts/{key}"
         params = {
             "key": key,
             "tag": tag,
+            "tree": tree,
+            "uid": uid,
         }
         error = f"del artifact {project}/{key}"
-        self.api_call("DELETE", endpoint_path, error, params=params)
+        self.api_call("DELETE", endpoint_path, error, params=params, version="v2")
 
     def list_artifacts(
         self,
@@ -824,6 +898,7 @@ class HTTPRunDB(RunDBInterface):
         best_iteration: bool = False,
         kind: str = None,
         category: Union[str, mlrun.common.schemas.ArtifactCategories] = None,
+        tree: str = None,
     ) -> ArtifactList:
         """List artifacts filtered by various parameters.
 
@@ -852,6 +927,7 @@ class HTTPRunDB(RunDBInterface):
             from that iteration. If using ``best_iter``, the ``iter`` parameter must not be used.
         :param kind: Return artifacts of the requested kind.
         :param category: Return artifacts of the requested category.
+        :param tree: Return artifacts of the requested tree.
         """
 
         project = project or config.default_project
@@ -868,16 +944,19 @@ class HTTPRunDB(RunDBInterface):
             "best-iteration": best_iteration,
             "kind": kind,
             "category": category,
+            "tree": tree,
             "format": mlrun.common.schemas.ArtifactsFormat.full.value,
         }
         error = "list artifacts"
         endpoint_path = f"projects/{project}/artifacts"
-        resp = self.api_call("GET", endpoint_path, error, params=params)
+        resp = self.api_call("GET", endpoint_path, error, params=params, version="v2")
         values = ArtifactList(resp.json()["artifacts"])
         values.tag = tag
         return values
 
-    def del_artifacts(self, name=None, project=None, tag=None, labels=None, days_ago=0):
+    def del_artifacts(
+        self, name=None, project=None, tag=None, labels=None, days_ago=0, tree=None
+    ):
         """Delete artifacts referenced by the parameters.
 
         :param name: Name of artifacts to delete. Note that this is a like query, and is case-insensitive. See
@@ -891,12 +970,13 @@ class HTTPRunDB(RunDBInterface):
         params = {
             "name": name,
             "tag": tag,
+            "tree": tree,
             "label": labels or [],
             "days_ago": str(days_ago),
         }
         error = "del artifacts"
         endpoint_path = f"projects/{project}/artifacts"
-        self.api_call("DELETE", endpoint_path, error, params=params)
+        self.api_call("DELETE", endpoint_path, error, params=params, version="v2")
 
     def list_artifact_tags(
         self,
@@ -3414,9 +3494,9 @@ class HTTPRunDB(RunDBInterface):
         self, name: str, project: str
     ) -> Optional[mlrun.common.schemas.DatastoreProfile]:
         project = project or config.default_project
-        path = self._path_of("projects", project, "datastore-profiles") + f"/{name}"
+        _path = self._path_of("datastore-profiles", project, name)
 
-        res = self.api_call(method="GET", path=path)
+        res = self.api_call(method="GET", path=_path)
         if res:
             public_wrapper = res.json()
             datastore = DatastoreProfile2Json.create_from_json(
@@ -3427,17 +3507,17 @@ class HTTPRunDB(RunDBInterface):
 
     def delete_datastore_profile(self, name: str, project: str):
         project = project or config.default_project
-        path = self._path_of("projects", project, "datastore-profiles") + f"/{name}"
-        self.api_call(method="DELETE", path=path)
+        _path = self._path_of("datastore-profiles", project, name)
+        self.api_call(method="DELETE", path=_path)
         return None
 
     def list_datastore_profiles(
         self, project: str
     ) -> List[mlrun.common.schemas.DatastoreProfile]:
         project = project or config.default_project
-        path = self._path_of("projects", project, "datastore-profiles")
+        _path = self._path_of("datastore-profiles", project)
 
-        res = self.api_call(method="GET", path=path)
+        res = self.api_call(method="GET", path=_path)
         if res:
             public_wrapper = res.json()
             datastores = [
@@ -3455,9 +3535,9 @@ class HTTPRunDB(RunDBInterface):
         :returns: None
         """
         project = project or config.default_project
-        path = self._path_of("projects", project, "datastore-profiles")
+        _path = self._path_of("datastore-profiles", project)
 
-        self.api_call(method="PUT", path=path, json=profile.dict())
+        self.api_call(method="PUT", path=_path, json=profile.dict())
 
 
 def _as_json(obj):

mlrun/db/nopdb.py

@@ -104,10 +104,12 @@ class NopDB(RunDBInterface):
     def del_runs(self, name="", project="", labels=None, state="", days_ago=0):
         pass
 
-    def store_artifact(self, key, artifact, uid, iter=None, tag="", project=""):
+    def store_artifact(
+        self, key, artifact, uid=None, iter=None, tag="", project="", tree=None
+    ):
         pass
 
-    def read_artifact(self, key, tag="", iter=None, project=""):
+    def read_artifact(self, key, tag="", iter=None, project="", tree=None, uid=None):
         pass
 
     def list_artifacts(
@@ -122,10 +124,11 @@ class NopDB(RunDBInterface):
         best_iteration: bool = False,
         kind: str = None,
         category: Union[str, mlrun.common.schemas.ArtifactCategories] = None,
+        tree: str = None,
     ):
         pass
 
-    def del_artifact(self, key, tag="", project=""):
+    def del_artifact(self, key, tag="", project="", tree=None, uid=None):
         pass
 
     def del_artifacts(self, name="", project="", tag="", labels=None):

mlrun/feature_store/feature_vector.py

@@ -938,7 +938,7 @@ class OnlineVectorService:
                     for name in data.keys():
                         v = data[name]
                         if v is None or (
-                            type(v) == float and (np.isinf(v) or np.isnan(v))
+                            isinstance(v, float) and (np.isinf(v) or np.isnan(v))
                         ):
                             data[name] = self._impute_values.get(name, v)
                 if not self.vector.spec.with_indexes:

mlrun/feature_store/steps.py

@@ -254,7 +254,7 @@ class MapValues(StepToDict, MLRunStep):
         source_column_names = df.columns
         for column, column_map in self.mapping.items():
             new_column_name = self._get_feature_name(column)
-            if not self.get_ranges_key() in column_map:
+            if self.get_ranges_key() not in column_map:
                 if column not in source_column_names:
                     continue
                 mapping_expr = create_map([lit(x) for x in chain(*column_map.items())])
@@ -330,7 +330,7 @@ class MapValues(StepToDict, MLRunStep):
     def validate_args(cls, feature_set, **kwargs):
         mapping = kwargs.get("mapping", [])
         for column, column_map in mapping.items():
-            if not cls.get_ranges_key() in column_map:
+            if cls.get_ranges_key() not in column_map:
                 types = set(
                     type(val)
                     for val in column_map.values()

mlrun/frameworks/_common/model_handler.py

@@ -25,7 +25,7 @@ from typing import Any, Dict, Generic, List, Type, Union
 import numpy as np
 
 import mlrun
-from mlrun.artifacts import Artifact, ModelArtifact
+from mlrun.artifacts import Artifact
 from mlrun.execution import MLClientCtx
 from mlrun.features import Feature
 

mlrun/frameworks/lgbm/mlrun_interfaces/booster_mlrun_interface.py

@@ -17,7 +17,6 @@ from abc import ABC
 import lightgbm as lgb
 
 from ..._common import MLRunInterface
-from ..._ml_common import MLModelHandler
 from ..utils import LGBMTypes
 
 

mlrun/frameworks/pytorch/callbacks/tensorboard_logging_callback.py

@@ -48,7 +48,7 @@ class _MLRunSummaryWriter(SummaryWriter):
         :param run_name:               Not used in this SummaryWriter.
         """
         torch._C._log_api_usage_once("tensorboard.logging.add_hparams")
-        if type(hparam_dict) is not dict or type(metric_dict) is not dict:
+        if not isinstance(hparam_dict, dict) or not isinstance(metric_dict, dict):
             raise TypeError("hparam_dict and metric_dict should be dictionary.")
         exp, ssi, sei = hparams(hparam_dict, metric_dict)
         self._get_file_writer().add_summary(exp)

mlrun/frameworks/sklearn/metric.py

@@ -15,7 +15,6 @@
 import importlib
 import json
 import sys
-from types import ModuleType
 from typing import Callable, Union
 
 import mlrun.errors

mlrun/frameworks/tf_keras/mlrun_interface.py

@@ -15,8 +15,7 @@
 import importlib
 import os
 from abc import ABC
-from types import ModuleType
-from typing import List, Set, Tuple, Union
+from typing import List, Tuple, Union
 
 import tensorflow as tf
 from tensorflow import keras

mlrun/model_monitoring/application.py

@@ -11,11 +11,10 @@
 # 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 dataclasses
 import json
-from typing import Any, Dict, List, Tuple, Union
+from typing import Any, Optional, Tuple, Union
 
 import numpy as np
 import pandas as pd
@@ -45,7 +44,7 @@ class ModelMonitoringApplicationResult:
     :param result_kind:           (ResultKindApp) Kind of application result.
     :param result_status:         (ResultStatusApp) Status of the application result.
     :param result_extra_data:     (dict) Extra data associated with the application result.
-
+    :param _current_stats:        (dict) Current statistics of the data.
     """
 
     application_name: str
@@ -57,7 +56,7 @@ class ModelMonitoringApplicationResult:
     result_kind: mm_constant.ResultKindApp
     result_status: mm_constant.ResultStatusApp
     result_extra_data: dict = dataclasses.field(default_factory=dict)
-    _current_stats: dict = None
+    _current_stats: dict = dataclasses.field(default_factory=dict)
 
     def to_dict(self):
         """
@@ -103,7 +102,7 @@ class ModelMonitoringApplication(StepToDict):
                 latest_request: pd.Timestamp,
                 endpoint_id: str,
                 output_stream_uri: str,
-            ) -> typing.Union[ModelMonitoringApplicationResult, typing.List[ModelMonitoringApplicationResult]
+            ) -> Union[ModelMonitoringApplicationResult, list[ModelMonitoringApplicationResult]
             ]:
                 self.context.log_artifact(TableArtifact("sample_df_stats", df=sample_df_stats))
                 return ModelMonitoringApplicationResult(
@@ -121,23 +120,23 @@ class ModelMonitoringApplication(StepToDict):
 
     kind = "monitoring_application"
 
-    def do(self, event: Dict[str, Any]):
+    def do(self, event: dict[str, Any]) -> list[ModelMonitoringApplicationResult]:
         """
         Process the monitoring event and return application results.
 
         :param event:   (dict) The monitoring event to process.
-        :returns:       (List[ModelMonitoringApplicationResult]) The application results.
+        :returns:       (list[ModelMonitoringApplicationResult]) The application results.
         """
         resolved_event = self._resolve_event(event)
         if not (
             hasattr(self, "context") and isinstance(self.context, mlrun.MLClientCtx)
         ):
             self._lazy_init(app_name=resolved_event[0])
-        # Run application and get the result in the required `ModelMonitoringApplicationResult` format
-        result = self.run_application(*resolved_event)
-        # Add current stats to the result as provided in the event
-        result._current_stats = event[mm_constant.ApplicationEvent.CURRENT_STATS]
-        return result
+        results = self.run_application(*resolved_event)
+        results = results if isinstance(results, list) else [results]
+        for result in results:
+            result._current_stats = event[mm_constant.ApplicationEvent.CURRENT_STATS]
+        return results
 
     def _lazy_init(self, app_name: str):
         self.context = self._create_context_for_logging(app_name=app_name)
@@ -154,7 +153,7 @@ class ModelMonitoringApplication(StepToDict):
         endpoint_id: str,
         output_stream_uri: str,
     ) -> Union[
-        ModelMonitoringApplicationResult, List[ModelMonitoringApplicationResult]
+        ModelMonitoringApplicationResult, list[ModelMonitoringApplicationResult]
     ]:
         """
         Implement this method with your custom monitoring logic.
@@ -170,13 +169,13 @@ class ModelMonitoringApplication(StepToDict):
         :param output_stream_uri:       (str) URI of the output stream for results
 
         :returns:                       (ModelMonitoringApplicationResult) or
-                                        (List[ModelMonitoringApplicationResult]) of the application results.
+                                        (list[ModelMonitoringApplicationResult]) of the application results.
         """
         raise NotImplementedError
 
     @staticmethod
     def _resolve_event(
-        event: Dict[str, Any],
+        event: dict[str, Any],
     ) -> Tuple[
         str,
         pd.DataFrame,
@@ -235,7 +234,7 @@ class ModelMonitoringApplication(StepToDict):
         return context
 
     @staticmethod
-    def _dict_to_histogram(histogram_dict: Dict[str, Dict[str, Any]]) -> pd.DataFrame:
+    def _dict_to_histogram(histogram_dict: dict[str, dict[str, Any]]) -> pd.DataFrame:
         """
         Convert histogram dictionary to pandas DataFrame with feature histograms as columns
 
@@ -262,10 +261,10 @@ class PushToMonitoringWriter(StepToDict):
 
     def __init__(
         self,
-        project: str = None,
-        writer_application_name: str = None,
-        stream_uri: str = None,
-        name: str = None,
+        project: Optional[str] = None,
+        writer_application_name: Optional[str] = None,
+        stream_uri: Optional[str] = None,
+        name: Optional[str] = None,
     ):
         """
         Class for pushing application results to the monitoring writer stream.
@@ -284,19 +283,13 @@ class PushToMonitoringWriter(StepToDict):
         self.output_stream = None
         self.name = name or "PushToMonitoringWriter"
 
-    def do(
-        self,
-        event: Union[
-            ModelMonitoringApplicationResult, List[ModelMonitoringApplicationResult]
-        ],
-    ):
+    def do(self, event: list[ModelMonitoringApplicationResult]) -> None:
         """
         Push application results to the monitoring writer stream.
 
         :param event: Monitoring result(s) to push.
         """
         self._lazy_init()
-        event = event if isinstance(event, List) else [event]
         for result in event:
             data = result.to_dict()
             logger.info(f"Pushing data = {data} \n to stream = {self.stream_uri}")