mlrun 1.6.4rc2__py3-none-any.whl → 1.7.0rc20__py3-none-any.whl

mlrun/frameworks/onnx/dataset.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 #
 import math
-from typing import Callable, List, Tuple, Union
+from typing import Callable, Union
 
 import numpy as np
 
@@ -25,11 +25,11 @@ class ONNXDataset:
 
     def __init__(
         self,
-        x: Union[np.ndarray, List[np.ndarray]],
-        y: Union[np.ndarray, List[np.ndarray]] = None,
+        x: Union[np.ndarray, list[np.ndarray]],
+        y: Union[np.ndarray, list[np.ndarray]] = None,
         batch_size: int = 1,
-        x_transforms: List[Callable[[np.ndarray], np.ndarray]] = None,
-        y_transforms: List[Callable[[np.ndarray], np.ndarray]] = None,
+        x_transforms: list[Callable[[np.ndarray], np.ndarray]] = None,
+        y_transforms: list[Callable[[np.ndarray], np.ndarray]] = None,
         is_batched_transforms: bool = False,
     ):
         """
@@ -71,7 +71,7 @@ class ONNXDataset:
         self._index = 0
         return self
 
-    def __next__(self) -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray]]:
+    def __next__(self) -> Union[np.ndarray, tuple[np.ndarray, np.ndarray]]:
         """
         Get the next item in line (by the inner index) since calling '__iter__'. If ground truth was provided (y),
         a tuple of (x, y) will be returned. Otherwise x.
@@ -92,7 +92,7 @@ class ONNXDataset:
 
     def __getitem__(
         self, index: int
-    ) -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray]]:
+    ) -> Union[np.ndarray, tuple[np.ndarray, np.ndarray]]:
         """
         Get the item at the given index. If ground truth was provided, a tuple of (x, y) will be returned. Otherwise x.
 
@@ -155,7 +155,7 @@ class ONNXDataset:
     def _call_transforms(
         self,
         items: np.ndarray,
-        transforms: List[Callable[[np.ndarray], np.ndarray]],
+        transforms: list[Callable[[np.ndarray], np.ndarray]],
         is_batched: bool,
     ):
         """

mlrun/frameworks/onnx/mlrun_interface.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-from typing import Callable, List
+from typing import Callable
 
 import numpy as np
 import onnx
@@ -35,7 +35,7 @@ class ONNXMLRunInterface:
     def __init__(
         self,
         model: onnx.ModelProto,
-        execution_providers: List[str] = None,
+        execution_providers: list[str] = None,
         context: mlrun.MLClientCtx = None,
     ):
         # Set the context:
@@ -74,7 +74,7 @@ class ONNXMLRunInterface:
     def evaluate(
         self,
         dataset: ONNXDataset,
-        metrics: List[Callable[[np.ndarray, np.ndarray], float]],
+        metrics: list[Callable[[np.ndarray, np.ndarray], float]],
     ):
         pass
 

mlrun/frameworks/onnx/model_handler.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 #
 import os
-from typing import Dict, List, Union
+from typing import Union
 
 import onnx
 import onnxoptimizer
@@ -60,7 +60,7 @@ class ONNXModelHandler(ModelHandler):
         :raise MLRunInvalidArgumentError: There was no model or model directory supplied.
         """
         # Setup the base handler class:
-        super(ONNXModelHandler, self).__init__(
+        super().__init__(
             model=model,
             model_path=model_path,
             model_name=model_name,
@@ -71,7 +71,7 @@ class ONNXModelHandler(ModelHandler):
     # TODO: output_path won't work well with logging artifacts. Need to look into changing the logic of 'log_artifact'.
     def save(
         self, output_path: str = None, **kwargs
-    ) -> Union[Dict[str, Artifact], None]:
+    ) -> Union[dict[str, Artifact], None]:
         """
         Save the handled model at the given output path. If a MLRun context is available, the saved model files will be
         logged and returned as artifacts.
@@ -81,7 +81,7 @@ class ONNXModelHandler(ModelHandler):
 
         :return The saved model additional artifacts (if needed) dictionary if context is available and None otherwise.
         """
-        super(ONNXModelHandler, self).save(output_path=output_path)
+        super().save(output_path=output_path)
 
         # Set the output path:
         if output_path is None:
@@ -97,7 +97,7 @@ class ONNXModelHandler(ModelHandler):
         """
         Load the specified model in this handler.
         """
-        super(ONNXModelHandler, self).load()
+        super().load()
 
         # Check that the model is well-formed:
         # TODO: Currently not working well with HuggingFace models so we skip it
@@ -106,7 +106,7 @@ class ONNXModelHandler(ModelHandler):
         # Load the ONNX model:
         self._model = onnx.load(self._model_file)
 
-    def optimize(self, optimizations: List[str] = None, fixed_point: bool = False):
+    def optimize(self, optimizations: list[str] = None, fixed_point: bool = False):
         """
         Use ONNX optimizer to optimize the ONNX model. The optimizations supported can be seen by calling
         'onnxoptimizer.get_available_passes()'

mlrun/frameworks/onnx/model_server.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-from typing import Any, Dict, List, Tuple, Union
+from typing import Any, Union
 
 import numpy as np
 import onnx
@@ -37,7 +37,7 @@ class ONNXModelServer(V2ModelServer):
         model: onnx.ModelProto = None,
         model_path: str = None,
         model_name: str = None,
-        execution_providers: List[Union[str, Tuple[str, Dict[str, Any]]]] = None,
+        execution_providers: list[Union[str, tuple[str, dict[str, Any]]]] = None,
         protocol: str = None,
         **class_args,
     ):
@@ -76,7 +76,7 @@ class ONNXModelServer(V2ModelServer):
         :param protocol:            -
         :param class_args:          -
         """
-        super(ONNXModelServer, self).__init__(
+        super().__init__(
             context=context,
             name=name,
             model_path=model_path,
@@ -98,8 +98,8 @@ class ONNXModelServer(V2ModelServer):
         # Prepare inference parameters:
         self._model_handler: ONNXModelHandler = None
         self._inference_session: onnxruntime.InferenceSession = None
-        self._input_layers: List[str] = None
-        self._output_layers: List[str] = None
+        self._input_layers: list[str] = None
+        self._output_layers: list[str] = None
 
     def load(self):
         """
@@ -134,7 +134,7 @@ class ONNXModelServer(V2ModelServer):
             output_layer.name for output_layer in self._inference_session.get_outputs()
         ]
 
-    def predict(self, request: Dict[str, Any]) -> np.ndarray:
+    def predict(self, request: dict[str, Any]) -> np.ndarray:
         """
         Infer the inputs through the model using ONNXRunTime and return its output. The inferred data will be
         read from the "inputs" key of the request.
@@ -155,7 +155,7 @@ class ONNXModelServer(V2ModelServer):
             },
         )
 
-    def explain(self, request: Dict[str, Any]) -> str:
+    def explain(self, request: dict[str, Any]) -> str:
         """
         Return a string explaining what model is being serve in this serving function and the function name.
 

mlrun/frameworks/parallel_coordinates.py

@@ -14,7 +14,7 @@
 #
 import datetime
 import os
-from typing import List, Union
+from typing import Union
 
 import numpy as np
 import pandas as pd
@@ -239,7 +239,7 @@ def _runs_list_to_df(runs_list, extend_iterations=False):
 
 @filter_warnings("ignore", FutureWarning)
 def compare_run_objects(
-    runs_list: Union[mlrun.model.RunObject, List[mlrun.model.RunObject]],
+    runs_list: Union[mlrun.model.RunObject, list[mlrun.model.RunObject]],
     hide_identical: bool = True,
     exclude: list = None,
     show: bool = None,
@@ -295,7 +295,7 @@ def compare_db_runs(
     iter=False,
     start_time_from: datetime = None,
     hide_identical: bool = True,
-    exclude: list = [],
+    exclude: list = None,
     show=None,
     colorscale: str = "Blues",
     filename=None,
@@ -332,6 +332,7 @@ def compare_db_runs(
         **query_args,
     )
 
+    exclude = exclude or []
     runs_df = _runs_list_to_df(runs_list)
     plot_as_html = gen_pcp_plot(
         runs_df,

mlrun/frameworks/pytorch/__init__.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 #
 # flake8: noqa  - this is until we take care of the F401 violations with respect to __all__ & sphinx
-from typing import Any, Dict, List, Tuple, Union
+from typing import Any, Union
 
 from torch.nn import Module
 from torch.optim import Optimizer
@@ -35,23 +35,23 @@ def train(
     loss_function: Module,
     optimizer: Optimizer,
     validation_set: DataLoader = None,
-    metric_functions: List[PyTorchTypes.MetricFunctionType] = None,
+    metric_functions: list[PyTorchTypes.MetricFunctionType] = None,
     scheduler=None,
     scheduler_step_frequency: Union[int, float, str] = "epoch",
     epochs: int = 1,
     training_iterations: int = None,
     validation_iterations: int = None,
-    callbacks_list: List[Callback] = None,
+    callbacks_list: list[Callback] = None,
     use_cuda: bool = True,
     use_horovod: bool = None,
     auto_log: bool = True,
     model_name: str = None,
-    modules_map: Union[Dict[str, Union[None, str, List[str]]], str] = None,
-    custom_objects_map: Union[Dict[str, Union[str, List[str]]], str] = None,
+    modules_map: Union[dict[str, Union[None, str, list[str]]], str] = None,
+    custom_objects_map: Union[dict[str, Union[str, list[str]]], str] = None,
     custom_objects_directory: str = None,
     tensorboard_directory: str = None,
-    mlrun_callback_kwargs: Dict[str, Any] = None,
-    tensorboard_callback_kwargs: Dict[str, Any] = None,
+    mlrun_callback_kwargs: dict[str, Any] = None,
+    tensorboard_callback_kwargs: dict[str, Any] = None,
     context: mlrun.MLClientCtx = None,
 ) -> PyTorchModelHandler:
     """
@@ -112,7 +112,7 @@ def train(
 
                                             {
                                                 "/.../custom_optimizer.py": "optimizer",
-                                                "/.../custom_layers.py": ["layer1", "layer2"]
+                                                "/.../custom_layers.py": ["layer1", "layer2"],
                                             }
 
                                         All the paths will be accessed from the given 'custom_objects_directory',
@@ -205,19 +205,19 @@ def evaluate(
     dataset: DataLoader,
     model: Module = None,
     loss_function: Module = None,
-    metric_functions: List[PyTorchTypes.MetricFunctionType] = None,
+    metric_functions: list[PyTorchTypes.MetricFunctionType] = None,
     iterations: int = None,
-    callbacks_list: List[Callback] = None,
+    callbacks_list: list[Callback] = None,
     use_cuda: bool = True,
     use_horovod: bool = False,
     auto_log: bool = True,
     model_name: str = None,
-    modules_map: Union[Dict[str, Union[None, str, List[str]]], str] = None,
-    custom_objects_map: Union[Dict[str, Union[str, List[str]]], str] = None,
+    modules_map: Union[dict[str, Union[None, str, list[str]]], str] = None,
+    custom_objects_map: Union[dict[str, Union[str, list[str]]], str] = None,
     custom_objects_directory: str = None,
-    mlrun_callback_kwargs: Dict[str, Any] = None,
+    mlrun_callback_kwargs: dict[str, Any] = None,
     context: mlrun.MLClientCtx = None,
-) -> Tuple[PyTorchModelHandler, List[PyTorchTypes.MetricValueType]]:
+) -> tuple[PyTorchModelHandler, list[PyTorchTypes.MetricValueType]]:
     """
     Use MLRun's PyTorch interface to evaluate the model with the given parameters. For more information and further
     options regarding the auto logging, see 'PyTorchMLRunInterface' documentation. Notice for auto-logging: In order to
@@ -264,7 +264,7 @@ def evaluate(
 
                                          {
                                              "/.../custom_optimizer.py": "optimizer",
-                                             "/.../custom_layers.py": ["layer1", "layer2"]
+                                             "/.../custom_layers.py": ["layer1", "layer2"],
                                          }
 
                                      All the paths will be accessed from the given 'custom_objects_directory', meaning
@@ -343,9 +343,9 @@ def evaluate(
 def _parse_callbacks_kwargs(
     handler: PyTorchModelHandler,
     tensorboard_directory: Union[str, None],
-    mlrun_callback_kwargs: Union[Dict[str, Any], None],
-    tensorboard_callback_kwargs: Union[Dict[str, Any], None],
-) -> Tuple[dict, dict]:
+    mlrun_callback_kwargs: Union[dict[str, Any], None],
+    tensorboard_callback_kwargs: Union[dict[str, Any], None],
+) -> tuple[dict, dict]:
     """
     Parse the given parameters into the MLRun and Tensorboard callbacks kwargs.
 

mlrun/frameworks/pytorch/callbacks/callback.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 #
 from abc import ABC, abstractmethod
-from typing import List
 
 from torch import Tensor
 from torch.nn import Module
@@ -68,7 +67,7 @@ class Callback(ABC):
         validation_set: DataLoader = None,
         loss_function: Module = None,
         optimizer: Optimizer = None,
-        metric_functions: List[PyTorchTypes.MetricFunctionType] = None,
+        metric_functions: list[PyTorchTypes.MetricFunctionType] = None,
         scheduler=None,
     ):
         """
@@ -141,7 +140,7 @@ class Callback(ABC):
         pass
 
     def on_validation_end(
-        self, loss_value: PyTorchTypes.MetricValueType, metric_values: List[float]
+        self, loss_value: PyTorchTypes.MetricValueType, metric_values: list[float]
     ) -> bool:
         """
         Before the validation (in a training case it will be per epoch) ends, this method will be called.
@@ -258,7 +257,7 @@ class Callback(ABC):
         """
         pass
 
-    def on_train_metrics_end(self, metric_values: List[PyTorchTypes.MetricValueType]):
+    def on_train_metrics_end(self, metric_values: list[PyTorchTypes.MetricValueType]):
         """
         After the training calculation of the metrics, this method will be called.
 
@@ -273,7 +272,7 @@ class Callback(ABC):
         pass
 
     def on_validation_metrics_end(
-        self, metric_values: List[PyTorchTypes.MetricValueType]
+        self, metric_values: list[PyTorchTypes.MetricValueType]
     ):
         """
         After the validating calculation of the metrics, this method will be called.

mlrun/frameworks/pytorch/callbacks/logging_callback.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-from typing import Callable, Dict, List, Tuple, Union
+from typing import Callable, Union
 
 import numpy as np
 from torch import Tensor
@@ -59,15 +59,15 @@ class LoggingCallback(Callback):
     def __init__(
         self,
         context: mlrun.MLClientCtx = None,
-        dynamic_hyperparameters: Dict[
+        dynamic_hyperparameters: dict[
             str,
-            Tuple[
+            tuple[
                 str,
-                Union[List[Union[str, int]], Callable[[], PyTorchTypes.TrackableType]],
+                Union[list[Union[str, int]], Callable[[], PyTorchTypes.TrackableType]],
             ],
         ] = None,
-        static_hyperparameters: Dict[
-            str, Union[PyTorchTypes.TrackableType, Tuple[str, List[Union[str, int]]]]
+        static_hyperparameters: dict[
+            str, Union[PyTorchTypes.TrackableType, tuple[str, list[Union[str, int]]]]
         ] = None,
         auto_log: bool = False,
     ):
@@ -100,7 +100,7 @@ class LoggingCallback(Callback):
         :param auto_log:                Whether or not to enable auto logging, trying to track common static and dynamic
                                         hyperparameters.
         """
-        super(LoggingCallback, self).__init__()
+        super().__init__()
 
         # Store the configurations:
         self._dynamic_hyperparameters_keys = (
@@ -117,7 +117,7 @@ class LoggingCallback(Callback):
         self._is_training = None  # type: bool
         self._auto_log = auto_log
 
-    def get_training_results(self) -> Dict[str, List[List[float]]]:
+    def get_training_results(self) -> dict[str, list[list[float]]]:
         """
         Get the training results logged. The results will be stored in a dictionary where each key is the metric name
         and the value is a list of lists of values. The first list is by epoch and the second list is by iteration
@@ -127,7 +127,7 @@ class LoggingCallback(Callback):
         """
         return self._logger.training_results
 
-    def get_validation_results(self) -> Dict[str, List[List[float]]]:
+    def get_validation_results(self) -> dict[str, list[list[float]]]:
         """
         Get the validation results logged. The results will be stored in a dictionary where each key is the metric name
         and the value is a list of lists of values. The first list is by epoch and the second list is by iteration
@@ -137,7 +137,7 @@ class LoggingCallback(Callback):
         """
         return self._logger.validation_results
 
-    def get_static_hyperparameters(self) -> Dict[str, PyTorchTypes.TrackableType]:
+    def get_static_hyperparameters(self) -> dict[str, PyTorchTypes.TrackableType]:
         """
         Get the static hyperparameters logged. The hyperparameters will be stored in a dictionary where each key is the
         hyperparameter name and the value is his logged value.
@@ -148,7 +148,7 @@ class LoggingCallback(Callback):
 
     def get_dynamic_hyperparameters(
         self,
-    ) -> Dict[str, List[PyTorchTypes.TrackableType]]:
+    ) -> dict[str, list[PyTorchTypes.TrackableType]]:
         """
         Get the dynamic hyperparameters logged. The hyperparameters will be stored in a dictionary where each key is the
         hyperparameter name and the value is a list of his logged values per epoch.
@@ -157,7 +157,7 @@ class LoggingCallback(Callback):
         """
         return self._logger.dynamic_hyperparameters
 
-    def get_summaries(self) -> Dict[str, List[float]]:
+    def get_summaries(self) -> dict[str, list[float]]:
         """
         Get the validation summaries of the metrics results. The summaries will be stored in a dictionary where each key
         is the metric names and the value is a list of all the summary values per epoch.
@@ -210,7 +210,7 @@ class LoggingCallback(Callback):
             self._add_auto_hyperparameters()
         # # Static hyperparameters:
         for name, value in self._static_hyperparameters_keys.items():
-            if isinstance(value, Tuple):
+            if isinstance(value, tuple):
                 # Its a parameter that needed to be extracted via key chain.
                 self._logger.log_static_hyperparameter(
                     parameter_name=name,
@@ -294,7 +294,7 @@ class LoggingCallback(Callback):
             self._logger.set_mode(mode=LoggingMode.EVALUATION)
 
     def on_validation_end(
-        self, loss_value: PyTorchTypes.MetricValueType, metric_values: List[float]
+        self, loss_value: PyTorchTypes.MetricValueType, metric_values: list[float]
     ):
         """
         Before the validation (in a training case it will be per epoch) ends, this method will be called to log the
@@ -372,7 +372,7 @@ class LoggingCallback(Callback):
             result=float(loss_value),
         )
 
-    def on_train_metrics_end(self, metric_values: List[PyTorchTypes.MetricValueType]):
+    def on_train_metrics_end(self, metric_values: list[PyTorchTypes.MetricValueType]):
         """
         After the training calculation of the metrics, this method will be called to log the metrics values.
 
@@ -389,7 +389,7 @@ class LoggingCallback(Callback):
             )
 
     def on_validation_metrics_end(
-        self, metric_values: List[PyTorchTypes.MetricValueType]
+        self, metric_values: list[PyTorchTypes.MetricValueType]
     ):
         """
         After the validating calculation of the metrics, this method will be called to log the metrics values.
@@ -456,7 +456,7 @@ class LoggingCallback(Callback):
         self,
         source: str,
         key_chain: Union[
-            List[Union[str, int]], Callable[[], PyTorchTypes.TrackableType]
+            list[Union[str, int]], Callable[[], PyTorchTypes.TrackableType]
         ],
     ) -> PyTorchTypes.TrackableType:
         """

mlrun/frameworks/pytorch/callbacks/mlrun_logging_callback.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-from typing import Callable, Dict, List, Tuple, Union
+from typing import Callable, Union
 
 import torch
 from torch import Tensor
@@ -53,20 +53,20 @@ class MLRunLoggingCallback(LoggingCallback):
         context: mlrun.MLClientCtx,
         model_handler: PyTorchModelHandler,
         log_model_tag: str = "",
-        log_model_labels: Dict[str, PyTorchTypes.TrackableType] = None,
-        log_model_parameters: Dict[str, PyTorchTypes.TrackableType] = None,
-        log_model_extra_data: Dict[
+        log_model_labels: dict[str, PyTorchTypes.TrackableType] = None,
+        log_model_parameters: dict[str, PyTorchTypes.TrackableType] = None,
+        log_model_extra_data: dict[
             str, Union[PyTorchTypes.TrackableType, Artifact]
         ] = None,
-        dynamic_hyperparameters: Dict[
+        dynamic_hyperparameters: dict[
             str,
-            Tuple[
+            tuple[
                 str,
-                Union[List[Union[str, int]], Callable[[], PyTorchTypes.TrackableType]],
+                Union[list[Union[str, int]], Callable[[], PyTorchTypes.TrackableType]],
             ],
         ] = None,
-        static_hyperparameters: Dict[
-            str, Union[PyTorchTypes.TrackableType, Tuple[str, List[Union[str, int]]]]
+        static_hyperparameters: dict[
+            str, Union[PyTorchTypes.TrackableType, tuple[str, list[Union[str, int]]]]
         ] = None,
         auto_log: bool = False,
     ):
@@ -107,7 +107,7 @@ class MLRunLoggingCallback(LoggingCallback):
         :param auto_log:                 Whether or not to enable auto logging for logging the context parameters and
                                          trying to track common static and dynamic hyperparameters.
         """
-        super(MLRunLoggingCallback, self).__init__(
+        super().__init__(
             dynamic_hyperparameters=dynamic_hyperparameters,
             static_hyperparameters=static_hyperparameters,
             auto_log=auto_log,
@@ -160,7 +160,7 @@ class MLRunLoggingCallback(LoggingCallback):
 
         :param epoch: The epoch that has just ended.
         """
-        super(MLRunLoggingCallback, self).on_epoch_end(epoch=epoch)
+        super().on_epoch_end(epoch=epoch)
 
         # Create child context to hold the current epoch's results:
         self._logger.log_epoch_to_context(epoch=epoch)