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

mlrun/frameworks/_ml_common/plans/confusion_matrix_plan.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-from typing import Dict
 
 import numpy as np
 import pandas as pd
@@ -57,7 +56,7 @@ class ConfusionMatrixPlan(MLPlotPlan):
         self._normalize = normalize
 
         # Continue the initialization for the MLPlan:
-        super(ConfusionMatrixPlan, self).__init__()
+        super().__init__()
 
     def is_ready(self, stage: MLPlanStages, is_probabilities: bool) -> bool:
         """
@@ -79,7 +78,7 @@ class ConfusionMatrixPlan(MLPlotPlan):
         model: MLTypes.ModelType = None,
         x: MLTypes.DatasetType = None,
         **kwargs,
-    ) -> Dict[str, Artifact]:
+    ) -> dict[str, Artifact]:
         """
         Produce the confusion matrix according to the ground truth (y) and predictions (y_pred) values. If predictions
         are not available, the model and a dataset can be given to produce them.

mlrun/frameworks/_ml_common/plans/dataset_plan.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 #
 from enum import Enum
-from typing import Dict, Union
+from typing import Union
 
 import mlrun.errors
 from mlrun.artifacts import Artifact, DatasetArtifact
@@ -92,7 +92,7 @@ class DatasetPlan(MLPlan):
         self._plans = {}  # TODO: Implement DatasetPlansLibrary with dataset specific artifacts plans.
 
         # Continue initializing the plan:
-        super(DatasetPlan, self).__init__(need_probabilities=False)
+        super().__init__(need_probabilities=False)
 
     def is_ready(self, stage: MLPlanStages, is_probabilities: bool) -> bool:
         """
@@ -124,7 +124,7 @@ class DatasetPlan(MLPlan):
         y: MLTypes.DatasetType = None,
         target_columns_names: MLTypes.TargetColumnsNamesType = None,
         **kwargs,
-    ) -> Dict[str, Artifact]:
+    ) -> dict[str, Artifact]:
         """
         Produce the dataset artifact according to this plan.
 

mlrun/frameworks/_ml_common/plans/feature_importance_plan.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-from typing import Dict, Union
+from typing import Union
 
 import numpy as np
 import plotly.graph_objects as go
@@ -38,7 +38,7 @@ class FeatureImportancePlan(MLPlotPlan):
         An example of use can be seen at the Scikit-Learn docs here:
         https://scikit-learn.org/stable/auto_examples/ensemble/plot_forest_importances.html
         """
-        super(FeatureImportancePlan, self).__init__()
+        super().__init__()
 
     def is_ready(self, stage: MLPlanStages, is_probabilities: bool) -> bool:
         """
@@ -55,7 +55,7 @@ class FeatureImportancePlan(MLPlotPlan):
 
     def produce(
         self, model: MLTypes.ModelType, x: MLTypes.DatasetType, **kwargs
-    ) -> Dict[str, Artifact]:
+    ) -> dict[str, Artifact]:
         """
         Produce the feature importance according to the given model and dataset ('x').
 

mlrun/frameworks/_ml_common/plans/roc_curve_plan.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-from typing import Dict, List, Union
+from typing import Union
 
 import numpy as np
 import pandas as pd
@@ -41,7 +41,7 @@ class ROCCurvePlan(MLPlotPlan):
         average: str = "macro",
         max_fpr: float = None,
         multi_class: str = "raise",
-        labels: List[str] = None,
+        labels: list[str] = None,
     ):
         """
         Initialize a receiver operating characteristic plan with the given configuration.
@@ -75,7 +75,7 @@ class ROCCurvePlan(MLPlotPlan):
         self._labels = labels
 
         # Continue the initialization for the MLPlan:
-        super(ROCCurvePlan, self).__init__(need_probabilities=True)
+        super().__init__(need_probabilities=True)
 
     def is_ready(self, stage: MLPlanStages, is_probabilities: bool) -> bool:
         """
@@ -97,7 +97,7 @@ class ROCCurvePlan(MLPlotPlan):
         model: MLTypes.ModelType = None,
         x: MLTypes.DatasetType = None,
         **kwargs,
-    ) -> Dict[str, Artifact]:
+    ) -> dict[str, Artifact]:
         """
         Produce the roc curve according to the ground truth (y) and predictions (y_pred) values. If predictions are not
         available, the model and a dataset can be given to produce them.

mlrun/frameworks/_ml_common/utils.py

@@ -14,7 +14,7 @@
 #
 from abc import ABC
 from enum import Enum
-from typing import Callable, List, Tuple, Union
+from typing import Callable, Union
 
 import pandas as pd
 from sklearn.base import is_classifier, is_regressor
@@ -137,10 +137,10 @@ class MLTypes(CommonTypes, ABC):
     # of the function and the full module path to the function to import. Arguments to use when calling the metric can
     # be joined by wrapping it as a tuple:
     # TODO: will be moved to SKLearn's framework once LightGBM and XGBoost are fully supported.
-    MetricEntryType = Union[Tuple[Union[Callable, str], dict], Callable, str]
+    MetricEntryType = Union[tuple[Union[Callable, str], dict], Callable, str]
 
     # Type for the target column name - a list of indices or column names that are the ground truth (y) of a dataset.
-    TargetColumnsNamesType = Union[List[str], List[int]]
+    TargetColumnsNamesType = Union[list[str], list[int]]
 
 
 class MLUtils(CommonUtils, ABC):
@@ -154,7 +154,7 @@ class MLUtils(CommonUtils, ABC):
         y: CommonTypes.DatasetType = None,
         target_columns_names: MLTypes.TargetColumnsNamesType = None,
         default_target_column_prefix: str = "y_",
-    ) -> Tuple[pd.DataFrame, Union[MLTypes.TargetColumnsNamesType, None]]:
+    ) -> tuple[pd.DataFrame, Union[MLTypes.TargetColumnsNamesType, None]]:
         """
         Concatenating the provided x and y data into a single pd.DataFrame, casting from np.ndarray and renaming y's
         original columns if 'y_columns' was not provided. The concatenated dataset index level will be reset to 0

mlrun/frameworks/auto_mlrun/auto_mlrun.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 Callable, Dict, List, Tuple, Type, Union
+from typing import Callable, Union
 
 import mlrun
 from mlrun.artifacts import get_model
@@ -165,7 +165,7 @@ def get_framework_by_class_name(model: CommonTypes.ModelType) -> str:
     )
 
 
-def framework_to_model_handler(framework: str) -> Type[ModelHandler]:
+def framework_to_model_handler(framework: str) -> type[ModelHandler]:
     """
     Get the ModelHandler class of the given framework's name.
 
@@ -262,7 +262,7 @@ class AutoMLRun:
     @staticmethod
     def _get_framework(
         model: CommonTypes.ModelType = None, model_path: str = None
-    ) -> Union[Tuple[str, dict]]:
+    ) -> Union[tuple[str, dict]]:
         """
         Try to get the framework from the model or model path provided. The framework can be read from the model path
         only if the model path is of a logged model artifact (store object uri).
@@ -322,8 +322,8 @@ class AutoMLRun:
         model_path: str,
         model_name: str = None,
         context: mlrun.MLClientCtx = 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,
         framework: str = None,
         **kwargs,
@@ -363,7 +363,7 @@ class AutoMLRun:
 
                                              {
                                                  "/.../custom_model.py": "MyModel",
-                                                 "/.../custom_objects.py": ["object1", "object2"]
+                                                 "/.../custom_objects.py": ["object1", "object2"],
                                              }
 
                                          All the paths will be accessed from the given 'custom_objects_directory',
@@ -420,8 +420,8 @@ class AutoMLRun:
         model_name: str = None,
         tag: str = "",
         model_path: 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,
         context: mlrun.MLClientCtx = None,
         framework: str = None,
@@ -464,7 +464,7 @@ class AutoMLRun:
 
                                              {
                                                  "/.../custom_model.py": "MyModel",
-                                                 "/.../custom_objects.py": ["object1", "object2"]
+                                                 "/.../custom_objects.py": ["object1", "object2"],
                                              }
 
                                          All the paths will be accessed from the given 'custom_objects_directory',

mlrun/frameworks/huggingface/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
+from typing import Any
 
 import numpy as np
 import transformers
@@ -65,7 +65,7 @@ class HuggingFaceModelServer(V2ModelServer):
                                 framework of the `model`, or to PyTorch if no model is provided
         :param class_args:      -
         """
-        super(HuggingFaceModelServer, self).__init__(
+        super().__init__(
             context=context,
             name=name,
             model_path=model_path,
@@ -104,7 +104,7 @@ class HuggingFaceModelServer(V2ModelServer):
             framework=self.framework,
         )
 
-    def predict(self, request: Dict[str, Any]) -> List:
+    def predict(self, request: dict[str, Any]) -> list:
         """
         Generate model predictions from sample.
         :param request: The request to the model. The input to the model will be read from the "inputs" key.
@@ -135,7 +135,7 @@ class HuggingFaceModelServer(V2ModelServer):
 
         return result
 
-    def explain(self, request: Dict) -> str:
+    def explain(self, request: dict) -> str:
         """
         Return a string explaining what model is being served in this serving function and the function name.
         :param request: A given request.

mlrun/frameworks/lgbm/__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, Union
+from typing import Any, Union
 
 import lightgbm as lgb
 
@@ -37,20 +37,20 @@ LGBMArtifactsLibrary = MLArtifactsLibrary
 def _apply_mlrun_on_module(
     model_name: str = "model",
     tag: str = "",
-    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,
     context: mlrun.MLClientCtx = None,
     model_format: str = LGBMModelHandler.ModelFormats.PKL,
     sample_set: Union[LGBMTypes.DatasetType, mlrun.DataItem, str] = None,
-    y_columns: Union[List[str], List[int]] = None,
+    y_columns: Union[list[str], list[int]] = None,
     feature_vector: str = None,
-    feature_weights: List[float] = None,
-    labels: Dict[str, Union[str, int, float]] = None,
-    parameters: Dict[str, Union[str, int, float]] = None,
-    extra_data: Dict[str, LGBMTypes.ExtraDataType] = None,
+    feature_weights: list[float] = None,
+    labels: dict[str, Union[str, int, float]] = None,
+    parameters: dict[str, Union[str, int, float]] = None,
+    extra_data: dict[str, LGBMTypes.ExtraDataType] = None,
     auto_log: bool = True,
-    mlrun_logging_callback_kwargs: Dict[str, Any] = None,
+    mlrun_logging_callback_kwargs: dict[str, Any] = None,
 ):
     # Apply MLRun's interface on the LightGBM module:
     LGBMMLRunInterface.add_interface(obj=lgb)
@@ -85,26 +85,26 @@ def _apply_mlrun_on_model(
     model_name: str = "model",
     tag: str = "",
     model_path: 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,
     context: mlrun.MLClientCtx = None,
     model_format: str = LGBMModelHandler.ModelFormats.PKL,
-    artifacts: Union[List[MLPlan], List[str], Dict[str, dict]] = None,
+    artifacts: Union[list[MLPlan], list[str], dict[str, dict]] = None,
     metrics: Union[
-        List[Metric],
-        List[LGBMTypes.MetricEntryType],
-        Dict[str, LGBMTypes.MetricEntryType],
+        list[Metric],
+        list[LGBMTypes.MetricEntryType],
+        dict[str, LGBMTypes.MetricEntryType],
     ] = None,
     x_test: LGBMTypes.DatasetType = None,
     y_test: LGBMTypes.DatasetType = None,
     sample_set: Union[LGBMTypes.DatasetType, mlrun.DataItem, str] = None,
-    y_columns: Union[List[str], List[int]] = None,
+    y_columns: Union[list[str], list[int]] = None,
     feature_vector: str = None,
-    feature_weights: List[float] = None,
-    labels: Dict[str, Union[str, int, float]] = None,
-    parameters: Dict[str, Union[str, int, float]] = None,
-    extra_data: Dict[str, LGBMTypes.ExtraDataType] = None,
+    feature_weights: list[float] = None,
+    labels: dict[str, Union[str, int, float]] = None,
+    parameters: dict[str, Union[str, int, float]] = None,
+    extra_data: dict[str, LGBMTypes.ExtraDataType] = None,
     auto_log: bool = True,
     **kwargs,
 ):
@@ -183,28 +183,28 @@ def apply_mlrun(
     model_name: str = "model",
     tag: str = "",
     model_path: 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,
     context: mlrun.MLClientCtx = None,
     model_format: str = LGBMModelHandler.ModelFormats.PKL,
-    artifacts: Union[List[MLPlan], List[str], Dict[str, dict]] = None,
+    artifacts: Union[list[MLPlan], list[str], dict[str, dict]] = None,
     metrics: Union[
-        List[Metric],
-        List[LGBMTypes.MetricEntryType],
-        Dict[str, LGBMTypes.MetricEntryType],
+        list[Metric],
+        list[LGBMTypes.MetricEntryType],
+        dict[str, LGBMTypes.MetricEntryType],
     ] = None,
     x_test: LGBMTypes.DatasetType = None,
     y_test: LGBMTypes.DatasetType = None,
     sample_set: Union[LGBMTypes.DatasetType, mlrun.DataItem, str] = None,
-    y_columns: Union[List[str], List[int]] = None,
+    y_columns: Union[list[str], list[int]] = None,
     feature_vector: str = None,
-    feature_weights: List[float] = None,
-    labels: Dict[str, Union[str, int, float]] = None,
-    parameters: Dict[str, Union[str, int, float]] = None,
-    extra_data: Dict[str, LGBMTypes.ExtraDataType] = None,
+    feature_weights: list[float] = None,
+    labels: dict[str, Union[str, int, float]] = None,
+    parameters: dict[str, Union[str, int, float]] = None,
+    extra_data: dict[str, LGBMTypes.ExtraDataType] = None,
     auto_log: bool = True,
-    mlrun_logging_callback_kwargs: Dict[str, Any] = None,
+    mlrun_logging_callback_kwargs: dict[str, Any] = None,
     **kwargs,
 ) -> Union[LGBMModelHandler, None]:
     """
@@ -241,7 +241,7 @@ def apply_mlrun(
 
                                          {
                                              "/.../custom_model.py": "MyModel",
-                                             "/.../custom_objects.py": ["object1", "object2"]
+                                             "/.../custom_objects.py": ["object1", "object2"],
                                          }
 
                                      All the paths will be accessed from the given 'custom_objects_directory', meaning

mlrun/frameworks/lgbm/callbacks/callback.py

@@ -63,11 +63,9 @@ class Callback(ABC):
             def on_train_end(self):
                 print("{self.name}: Done training!")
 
+
         apply_mlrun()
-        lgb.train(
-            ...,
-            callbacks=[ExampleCallback(name="Example")]
-        )
+        lgb.train(..., callbacks=[ExampleCallback(name="Example")])
     """
 
     def __init__(self, order: int = 10, before_iteration: bool = False):

mlrun/frameworks/lgbm/callbacks/logging_callback.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-from typing import List
 
 from ..._ml_common.loggers import Logger
 from ..utils import LGBMTypes
@@ -26,8 +25,8 @@ class LoggingCallback(Callback):
 
     def __init__(
         self,
-        dynamic_hyperparameters: List[str] = None,
-        static_hyperparameters: List[str] = None,
+        dynamic_hyperparameters: list[str] = None,
+        static_hyperparameters: list[str] = None,
     ):
         """
         Initialize the logging callback with the given configuration. All the metrics data will be collected but the
@@ -41,7 +40,7 @@ class LoggingCallback(Callback):
                                         The parameter expects a list of all the hyperparameters names to track our of
                                         the `params` dictionary.
         """
-        super(LoggingCallback, self).__init__()
+        super().__init__()
         self._logger = Logger()
         self._dynamic_hyperparameters_keys = (
             dynamic_hyperparameters if dynamic_hyperparameters is not None else {}
@@ -76,7 +75,7 @@ class LoggingCallback(Callback):
         self._log_hyperparameters(parameters=env.params)
 
     def _log_results(
-        self, evaluation_result_list: List[LGBMTypes.EvaluationResultType]
+        self, evaluation_result_list: list[LGBMTypes.EvaluationResultType]
     ):
         """
         Log the callback environment results data into the logger.

mlrun/frameworks/lgbm/callbacks/mlrun_logging_callback.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-from typing import List
 
 import mlrun
 
@@ -34,8 +33,8 @@ class MLRunLoggingCallback(LoggingCallback):
     def __init__(
         self,
         context: mlrun.MLClientCtx,
-        dynamic_hyperparameters: List[str] = None,
-        static_hyperparameters: List[str] = None,
+        dynamic_hyperparameters: list[str] = None,
+        static_hyperparameters: list[str] = None,
         logging_frequency: int = 100,
     ):
         """
@@ -55,7 +54,7 @@ class MLRunLoggingCallback(LoggingCallback):
                                         them and the results to MLRun). Two low frequency may slow the training time.
                                         Default: 100.
         """
-        super(MLRunLoggingCallback, self).__init__(
+        super().__init__(
             dynamic_hyperparameters=dynamic_hyperparameters,
             static_hyperparameters=static_hyperparameters,
         )
@@ -75,7 +74,7 @@ class MLRunLoggingCallback(LoggingCallback):
                     information check the `Callback` doc string.
         """
         # Log the results and parameters:
-        super(MLRunLoggingCallback, self).__call__(env=env)
+        super().__call__(env=env)
 
         # Produce the artifacts (post iteration stage):
         if env.iteration % self._logging_frequency == 0:

mlrun/frameworks/lgbm/mlrun_interfaces/booster_mlrun_interface.py

@@ -43,6 +43,4 @@ class LGBMBoosterMLRunInterface(MLRunInterface, ABC):
         :param restoration: Restoration information tuple as returned from 'remove_interface' in order to add the
                             interface in a certain state.
         """
-        super(LGBMBoosterMLRunInterface, cls).add_interface(
-            obj=obj, restoration=restoration
-        )
+        super().add_interface(obj=obj, restoration=restoration)

mlrun/frameworks/lgbm/mlrun_interfaces/mlrun_interface.py

@@ -14,7 +14,7 @@
 #
 from abc import ABC
 from types import ModuleType
-from typing import Callable, List, Tuple, Union
+from typing import Callable, Union
 
 import lightgbm as lgb
 
@@ -88,7 +88,7 @@ class LGBMMLRunInterface(MLRunInterface, ABC):
                 globals().update({"lightgbm": lgb, "lgb": lgb})
 
         # Add the interface to the provided lightgbm module:
-        super(LGBMMLRunInterface, cls).add_interface(obj=obj, restoration=restoration)
+        super().add_interface(obj=obj, restoration=restoration)
 
     @staticmethod
     def mlrun_train(*args, **kwargs):
@@ -223,7 +223,7 @@ class LGBMMLRunInterface(MLRunInterface, ABC):
         pass
 
     @staticmethod
-    def _parse_callbacks(callbacks: List[Callable]):
+    def _parse_callbacks(callbacks: list[Callable]):
         """
         Parse the callbacks passed to the training API functions of LightGBM for adding logging and enabling the MLRun
         callbacks API.
@@ -259,9 +259,9 @@ class LGBMMLRunInterface(MLRunInterface, ABC):
     @staticmethod
     def _post_train(
         booster: lgb.Booster,
-        train_set: Tuple[MLTypes.DatasetType, Union[MLTypes.DatasetType, None]],
-        validation_sets: List[
-            Tuple[Tuple[MLTypes.DatasetType, Union[MLTypes.DatasetType, None]], str]
+        train_set: tuple[MLTypes.DatasetType, Union[MLTypes.DatasetType, None]],
+        validation_sets: list[
+            tuple[tuple[MLTypes.DatasetType, Union[MLTypes.DatasetType, None]], str]
         ],
     ):
         """

mlrun/frameworks/lgbm/model_handler.py

@@ -14,7 +14,7 @@
 #
 import os
 import pickle
-from typing import Dict, List, Union
+from typing import Union
 
 import cloudpickle
 import lightgbm as lgb
@@ -56,8 +56,8 @@ class LGBMModelHandler(MLModelHandler):
         model_name: str = None,
         model_path: str = None,
         model: LGBMTypes.ModelType = 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,
         context: mlrun.MLClientCtx = None,
         model_format: str = ModelFormats.PKL,
@@ -103,7 +103,7 @@ class LGBMModelHandler(MLModelHandler):
 
                                              {
                                                  "/.../custom_model.py": "MyModel",
-                                                 "/.../custom_objects.py": ["object1", "object2"]
+                                                 "/.../custom_objects.py": ["object1", "object2"],
                                              }
 
                                          All the paths will be accessed from the given 'custom_objects_directory',
@@ -139,7 +139,7 @@ class LGBMModelHandler(MLModelHandler):
         self._model_format = model_format
 
         # Set up the base handler class:
-        super(LGBMModelHandler, self).__init__(
+        super().__init__(
             model=model,
             model_path=model_path,
             model_name=model_name,
@@ -152,8 +152,8 @@ class LGBMModelHandler(MLModelHandler):
 
     def set_labels(
         self,
-        to_add: Dict[str, Union[str, int, float]] = None,
-        to_remove: List[str] = None,
+        to_add: dict[str, Union[str, int, float]] = None,
+        to_remove: list[str] = None,
     ):
         """
         Update the labels dictionary of this model artifact. There are required labels that cannot be edited or removed.
@@ -162,7 +162,7 @@ class LGBMModelHandler(MLModelHandler):
         :param to_remove: A list of labels keys to remove.
         """
         # Update the user's labels:
-        super(LGBMModelHandler, self).set_labels(to_add=to_add, to_remove=to_remove)
+        super().set_labels(to_add=to_add, to_remove=to_remove)
 
         # Set the required labels:
         self._labels[self._LabelKeys.MODEL_FORMAT] = self._model_format
@@ -193,7 +193,7 @@ class LGBMModelHandler(MLModelHandler):
 
         :return The saved model additional artifacts (if needed) dictionary if context is available and None otherwise.
         """
-        super(LGBMModelHandler, self).save(output_path=output_path)
+        super().save(output_path=output_path)
 
         if isinstance(self._model, lgb.LGBMModel):
             return self._save_lgbmmodel()
@@ -204,7 +204,7 @@ class LGBMModelHandler(MLModelHandler):
         Load the specified model in this handler. Additional parameters for the class initializer can be passed via the
         kwargs dictionary.
         """
-        super(LGBMModelHandler, self).load()
+        super().load()
 
         # ModelFormats.PKL - Load from a pkl file:
         if self._model_format == LGBMModelHandler.ModelFormats.PKL:

mlrun/frameworks/lgbm/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, Union
+from typing import Any, Union
 
 import numpy as np
 
@@ -37,8 +37,8 @@ class LGBMModelServer(V2ModelServer):
         model_path: LGBMTypes.PathType = None,
         model_name: str = None,
         model_format: str = LGBMModelHandler.ModelFormats.PKL,
-        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,
         to_list: bool = True,
         protocol: str = None,
@@ -100,7 +100,7 @@ class LGBMModelServer(V2ModelServer):
         :param protocol:                 -
         :param class_args:               -
         """
-        super(LGBMModelServer, self).__init__(
+        super().__init__(
             context=context,
             name=name,
             model_path=model_path,
@@ -139,7 +139,7 @@ class LGBMModelServer(V2ModelServer):
             self._model_handler.load()
         self.model = self._model_handler.model
 
-    def predict(self, request: Dict[str, Any]) -> Union[np.ndarray, list]:
+    def predict(self, request: dict[str, Any]) -> Union[np.ndarray, list]:
         """
         Infer the inputs through the model using MLRun's PyTorch interface and return its output. The inferred data will
         be read from the "inputs" key of the request.
@@ -158,7 +158,7 @@ class LGBMModelServer(V2ModelServer):
         # Return as list if required:
         return predictions if not self.to_list else predictions.tolist()
 
-    def explain(self, request: Dict[str, Any]) -> str:
+    def explain(self, request: dict[str, Any]) -> str:
         """
         Return a string explaining what model is being served in this serving function and the function name.
 

mlrun/frameworks/lgbm/utils.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-from typing import List, Tuple, Union
+from typing import Union
 
 import lightgbm as lgb
 import numpy as np
@@ -36,13 +36,13 @@ class LGBMTypes(MLTypes):
 
     # An evaluation result as packaged by the training in LightGBM:
     EvaluationResultType = Union[
-        Tuple[str, str, float, bool],  # As packaged in `lightgbm.train`
-        Tuple[str, str, float, bool, float],  # As packaged in `lightgbm.cv`
+        tuple[str, str, float, bool],  # As packaged in `lightgbm.train`
+        tuple[str, str, float, bool, float],  # As packaged in `lightgbm.cv`
     ]
 
     # Detailed type for the named tuple `CallbackEnv` passed during LightGBM's training for the callbacks:
-    CallbackEnvType = Tuple[
-        lgb.Booster, dict, int, int, int, List[EvaluationResultType]
+    CallbackEnvType = tuple[
+        lgb.Booster, dict, int, int, int, list[EvaluationResultType]
     ]