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

mlrun/frameworks/tf_keras/callbacks/tensorboard_logging_callback.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 #
 from datetime import datetime
-from typing import Callable, Dict, List, Union
+from typing import Callable, Union
 
 import tensorflow as tf
 from packaging import version
@@ -38,7 +38,7 @@ class _TFKerasTensorboardLogger(TensorboardLogger):
 
     def __init__(
         self,
-        statistics_functions: List[Callable[[Union[Variable]], Union[float, Variable]]],
+        statistics_functions: list[Callable[[Union[Variable]], Union[float, Variable]]],
         context: mlrun.MLClientCtx = None,
         tensorboard_directory: str = None,
         run_name: str = None,
@@ -67,7 +67,7 @@ class _TFKerasTensorboardLogger(TensorboardLogger):
                                       update. Notice that writing to tensorboard too frequently may cause the training
                                       to be slower. Default: 'epoch'.
         """
-        super(_TFKerasTensorboardLogger, self).__init__(
+        super().__init__(
             statistics_functions=statistics_functions,
             context=context,
             tensorboard_directory=tensorboard_directory,
@@ -255,15 +255,15 @@ class TensorboardLoggingCallback(LoggingCallback):
         context: mlrun.MLClientCtx = None,
         tensorboard_directory: str = None,
         run_name: str = None,
-        weights: Union[bool, List[str]] = False,
-        statistics_functions: List[
+        weights: Union[bool, list[str]] = False,
+        statistics_functions: list[
             Callable[[Union[Variable, Tensor]], Union[float, Tensor]]
         ] = None,
-        dynamic_hyperparameters: Dict[
-            str, Union[List[Union[str, int]], Callable[[], TFKerasTypes.TrackableType]]
+        dynamic_hyperparameters: dict[
+            str, Union[list[Union[str, int]], Callable[[], TFKerasTypes.TrackableType]]
         ] = None,
-        static_hyperparameters: Dict[
-            str, Union[TFKerasTypes.TrackableType, List[Union[str, int]]]
+        static_hyperparameters: dict[
+            str, Union[TFKerasTypes.TrackableType, list[Union[str, int]]]
         ] = None,
         update_frequency: Union[int, str] = "epoch",
         auto_log: bool = False,
@@ -325,7 +325,7 @@ class TensorboardLoggingCallback(LoggingCallback):
         :raise MLRunInvalidArgumentError: In case both 'context' and 'tensorboard_directory' parameters were not given
                                           or the 'update_frequency' was incorrect.
         """
-        super(TensorboardLoggingCallback, self).__init__(
+        super().__init__(
             dynamic_hyperparameters=dynamic_hyperparameters,
             static_hyperparameters=static_hyperparameters,
             auto_log=auto_log,
@@ -352,7 +352,7 @@ class TensorboardLoggingCallback(LoggingCallback):
         self._logged_model = False
         self._logged_hyperparameters = False
 
-    def get_weights(self) -> Dict[str, Variable]:
+    def get_weights(self) -> dict[str, Variable]:
         """
         Get the weights tensors tracked. The weights will be stored in a dictionary where each key is the weight's name
         and the value is the weight's parameter (tensor).
@@ -361,7 +361,7 @@ class TensorboardLoggingCallback(LoggingCallback):
         """
         return self._logger.weights
 
-    def get_weights_statistics(self) -> Dict[str, Dict[str, List[float]]]:
+    def get_weights_statistics(self) -> dict[str, dict[str, list[float]]]:
         """
         Get the weights mean results logged. The results will be stored in a dictionary where each key is the weight's
         name and the value is a list of mean values per epoch.
@@ -408,7 +408,7 @@ class TensorboardLoggingCallback(LoggingCallback):
         :param logs: Currently the output of the last call to `on_epoch_end()` is passed to this argument for this
                      method but that may change in the future.
         """
-        super(TensorboardLoggingCallback, self).on_train_end()
+        super().on_train_end()
 
         # Write the final run summary:
         self._logger.write_final_summary_text()
@@ -453,7 +453,7 @@ class TensorboardLoggingCallback(LoggingCallback):
         :param logs: Currently no data is passed to this argument for this method but that may change in the
                      future.
         """
-        super(TensorboardLoggingCallback, self).on_test_end(logs=logs)
+        super().on_test_end(logs=logs)
 
         # Check if needed to end the run (in case of evaluation and not training):
         if not self._is_training:
@@ -477,7 +477,7 @@ class TensorboardLoggingCallback(LoggingCallback):
                       `Model`'s metrics are returned. Example : `{'loss': 0.2, 'acc': 0.7}`.
         """
         # Update the dynamic hyperparameters
-        super(TensorboardLoggingCallback, self).on_epoch_end(epoch=epoch)
+        super().on_epoch_end(epoch=epoch)
 
         # Log the weights statistics:
         self._logger.log_weights_statistics()
@@ -515,9 +515,7 @@ class TensorboardLoggingCallback(LoggingCallback):
         :param logs:  Aggregated metric results up until this batch.
         """
         # Log the batch's results:
-        super(TensorboardLoggingCallback, self).on_train_batch_end(
-            batch=batch, logs=logs
-        )
+        super().on_train_batch_end(batch=batch, logs=logs)
 
         # Write the batch loss and metrics results to their graphs:
         self._logger.write_training_results()
@@ -540,9 +538,7 @@ class TensorboardLoggingCallback(LoggingCallback):
         :param logs:  Aggregated metric results up until this batch.
         """
         # Log the batch's results:
-        super(TensorboardLoggingCallback, self).on_test_batch_end(
-            batch=batch, logs=logs
-        )
+        super().on_test_batch_end(batch=batch, logs=logs)
 
         # Write the batch loss and metrics results to their graphs:
         self._logger.write_validation_results()
@@ -555,7 +551,7 @@ class TensorboardLoggingCallback(LoggingCallback):
 
     @staticmethod
     def get_default_weight_statistics_list() -> (
-        List[Callable[[Union[Variable, Tensor]], Union[float, Tensor]]]
+        list[Callable[[Union[Variable, Tensor]], Union[float, Tensor]]]
     ):
         """
         Get the default list of statistics functions being applied on the tracked weights each epoch.
@@ -569,7 +565,7 @@ class TensorboardLoggingCallback(LoggingCallback):
         After the trainer / evaluator run begins, this method will be called to setup the results, hyperparameters
         and weights dictionaries for logging.
         """
-        super(TensorboardLoggingCallback, self)._setup_run()
+        super()._setup_run()
 
         # Check if needed to track weights:
         if self._tracked_weights is False:

mlrun/frameworks/tf_keras/mlrun_interface.py

@@ -15,11 +15,12 @@
 import importlib
 import os
 from abc import ABC
-from typing import List, Tuple, Union
+from typing import Union
 
 import tensorflow as tf
 from tensorflow import keras
-from tensorflow.keras.callbacks import (
+from tensorflow.keras.optimizers import Optimizer
+from tensorflow.python.keras.callbacks import (
     BaseLogger,
     Callback,
     CSVLogger,
@@ -27,7 +28,6 @@ from tensorflow.keras.callbacks import (
     ProgbarLogger,
     TensorBoard,
 )
-from tensorflow.keras.optimizers import Optimizer
 
 import mlrun
 
@@ -88,9 +88,7 @@ class TFKerasMLRunInterface(MLRunInterface, ABC):
         :param restoration: Restoration information tuple as returned from 'remove_interface' in order to
                                         add the interface in a certain state.
         """
-        super(TFKerasMLRunInterface, cls).add_interface(
-            obj=obj, restoration=restoration
-        )
+        super().add_interface(obj=obj, restoration=restoration)
 
     def mlrun_compile(self, *args, **kwargs):
         """
@@ -237,7 +235,7 @@ class TFKerasMLRunInterface(MLRunInterface, ABC):
         """
         self._RANK_0_ONLY_CALLBACKS.add(callback_name)
 
-    def _pre_compile(self, optimizer: Optimizer) -> Tuple[Optimizer, Union[bool, None]]:
+    def _pre_compile(self, optimizer: Optimizer) -> tuple[Optimizer, Union[bool, None]]:
         """
         Method to call before calling 'compile' to setup the run and inputs for using horovod.
 
@@ -295,11 +293,11 @@ class TFKerasMLRunInterface(MLRunInterface, ABC):
 
     def _pre_fit(
         self,
-        callbacks: List[Callback],
+        callbacks: list[Callback],
         verbose: int,
         steps_per_epoch: Union[int, None],
         validation_steps: Union[int, None],
-    ) -> Tuple[List[Callback], int, Union[int, None], Union[int, None]]:
+    ) -> tuple[list[Callback], int, Union[int, None], Union[int, None]]:
         """
         Method to call before calling 'fit' to setup the run and inputs for using horovod.
 
@@ -366,9 +364,9 @@ class TFKerasMLRunInterface(MLRunInterface, ABC):
 
     def _pre_evaluate(
         self,
-        callbacks: List[Callback],
+        callbacks: list[Callback],
         steps: Union[int, None],
-    ) -> Tuple[List[Callback], Union[int, None]]:
+    ) -> tuple[list[Callback], Union[int, None]]:
         """
         Method to call before calling 'evaluate' to setup the run and inputs for using horovod.
 

mlrun/frameworks/tf_keras/model_handler.py

@@ -15,7 +15,7 @@
 import os
 import shutil
 import zipfile
-from typing import Dict, List, Union
+from typing import Union
 
 import numpy as np
 import tensorflow as tf
@@ -67,8 +67,8 @@ class TFKerasModelHandler(DLModelHandler):
         model_name: str = None,
         model_format: str = ModelFormats.SAVED_MODEL,
         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,
         save_traces: bool = False,
         **kwargs,
@@ -174,7 +174,7 @@ class TFKerasModelHandler(DLModelHandler):
         self._weights_file = None  # type: str
 
         # Setup the base handler class:
-        super(TFKerasModelHandler, self).__init__(
+        super().__init__(
             model=model,
             model_path=model_path,
             model_name=model_name,
@@ -190,8 +190,8 @@ class TFKerasModelHandler(DLModelHandler):
 
     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.
@@ -200,7 +200,7 @@ class TFKerasModelHandler(DLModelHandler):
         :param to_remove: A list of labels keys to remove.
         """
         # Update the user's labels:
-        super(TFKerasModelHandler, 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
@@ -211,7 +211,7 @@ class TFKerasModelHandler(DLModelHandler):
     @without_mlrun_interface(interface=TFKerasMLRunInterface)
     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.
@@ -221,7 +221,7 @@ class TFKerasModelHandler(DLModelHandler):
 
         :return The saved model additional artifacts (if needed) dictionary if context is available and None otherwise.
         """
-        super(TFKerasModelHandler, self).save(output_path=output_path)
+        super().save(output_path=output_path)
 
         # Setup the returning model artifacts list:
         artifacts = {}  # type: Dict[str, Artifact]
@@ -291,7 +291,7 @@ class TFKerasModelHandler(DLModelHandler):
                 "Loading a model using checkpoint is not yet implemented."
             )
 
-        super(TFKerasModelHandler, self).load()
+        super().load()
 
         # ModelFormats.H5 - Load from a h5 file:
         if self._model_format == TFKerasModelHandler.ModelFormats.H5:
@@ -308,7 +308,7 @@ class TFKerasModelHandler(DLModelHandler):
         # ModelFormats.JSON_ARCHITECTURE_H5_WEIGHTS - Load from a json architecture file and a h5 weights file:
         else:
             # Load the model architecture (json):
-            with open(self._model_file, "r") as json_file:
+            with open(self._model_file) as json_file:
                 model_architecture = json_file.read()
             self._model = keras.models.model_from_json(
                 model_architecture, custom_objects=self._custom_objects
@@ -321,7 +321,7 @@ class TFKerasModelHandler(DLModelHandler):
         model_name: str = None,
         optimize: bool = True,
         input_signature: Union[
-            List[tf.TensorSpec], List[np.ndarray], tf.TensorSpec, np.ndarray
+            list[tf.TensorSpec], list[np.ndarray], tf.TensorSpec, np.ndarray
         ] = None,
         output_path: str = None,
         log: bool = None,
@@ -487,7 +487,7 @@ class TFKerasModelHandler(DLModelHandler):
             ].local()
 
         # Continue collecting from abstract class:
-        super(TFKerasModelHandler, self)._collect_files_from_store_object()
+        super()._collect_files_from_store_object()
 
     def _collect_files_from_local_path(self):
         """
@@ -554,7 +554,7 @@ class TFKerasModelHandler(DLModelHandler):
         """
         # Supported types:
         if isinstance(sample, np.ndarray):
-            return super(TFKerasModelHandler, self)._read_sample(sample=sample)
+            return super()._read_sample(sample=sample)
         elif isinstance(sample, tf.TensorSpec):
             return Feature(
                 name=sample.name,

mlrun/frameworks/tf_keras/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
 from tensorflow import keras
@@ -36,8 +36,8 @@ class TFKerasModelServer(V2ModelServer):
         model: keras.Model = None,
         model_path: str = None,
         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,
         model_format: str = TFKerasModelHandler.ModelFormats.SAVED_MODEL,
         to_list: bool = False,
@@ -103,7 +103,7 @@ class TFKerasModelServer(V2ModelServer):
         :param protocol:                 -
         :param class_args:               -
         """
-        super(TFKerasModelServer, self).__init__(
+        super().__init__(
             context=context,
             name=name,
             model_path=model_path,
@@ -146,7 +146,7 @@ class TFKerasModelServer(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 'keras.Model.predict' and return its output. The inferred data will be
         read from the "inputs" key of the request.
@@ -165,7 +165,7 @@ class TFKerasModelServer(V2ModelServer):
         # Return as list if required:
         return prediction if not self.to_list else prediction.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 serve in this serving function and the function name.
 

mlrun/frameworks/xgboost/__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 Dict, List, Union
+from typing import Union
 
 import xgboost as xgb
 
@@ -35,25 +35,25 @@ 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,
-    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[XGBoostTypes.MetricEntryType],
-        Dict[str, XGBoostTypes.MetricEntryType],
+        list[Metric],
+        list[XGBoostTypes.MetricEntryType],
+        dict[str, XGBoostTypes.MetricEntryType],
     ] = None,
     x_test: XGBoostTypes.DatasetType = None,
     y_test: XGBoostTypes.DatasetType = None,
     sample_set: Union[XGBoostTypes.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, XGBoostTypes.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, XGBoostTypes.ExtraDataType] = None,
     auto_log: bool = True,
     **kwargs,
 ) -> XGBoostModelHandler:
@@ -90,7 +90,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/xgboost/model_handler.py

@@ -14,7 +14,7 @@
 #
 import os
 import pickle
-from typing import Dict, List, Union
+from typing import Union
 
 import cloudpickle
 
@@ -47,8 +47,8 @@ class XGBoostModelHandler(MLModelHandler):
         model: XGBoostTypes.ModelType = None,
         model_path: str = None,
         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,
         context: mlrun.MLClientCtx = None,
         model_format: str = ModelFormats.PKL,
@@ -124,7 +124,7 @@ class XGBoostModelHandler(MLModelHandler):
         # Store the configuration:
         self._model_format = model_format
 
-        super(XGBoostModelHandler, self).__init__(
+        super().__init__(
             model=model,
             model_path=model_path,
             model_name=model_name,
@@ -162,7 +162,7 @@ class XGBoostModelHandler(MLModelHandler):
 
         :return The saved model additional artifacts (if needed) dictionary if context is available and None otherwise.
         """
-        super(XGBoostModelHandler, self).save(output_path=output_path)
+        super().save(output_path=output_path)
 
         # ModelFormats.PICKLE - Save from a pkl file:
         if self._model_format == XGBoostModelHandler.ModelFormats.PKL:
@@ -177,7 +177,7 @@ class XGBoostModelHandler(MLModelHandler):
         Load the specified model in this handler. Additional parameters for the class initializer can be passed via the
         kwargs dictionary.
         """
-        super(XGBoostModelHandler, self).load()
+        super().load()
 
         # ModelFormats.PICKLE - Load from a pkl file:
         if self._model_format == XGBoostModelHandler.ModelFormats.PKL:

mlrun/k8s_utils.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import re
-import typing
 
 import kubernetes.client
 
@@ -38,7 +37,7 @@ def is_running_inside_kubernetes_cluster():
 
 def generate_preemptible_node_selector_requirements(
     node_selector_operator: str,
-) -> typing.List[kubernetes.client.V1NodeSelectorRequirement]:
+) -> list[kubernetes.client.V1NodeSelectorRequirement]:
     """
     Generate node selector requirements based on the pre-configured node selector of the preemptible nodes.
     node selector operator represents a key's relationship to a set of values.
@@ -62,7 +61,7 @@ def generate_preemptible_node_selector_requirements(
 
 
 def generate_preemptible_nodes_anti_affinity_terms() -> (
-    typing.List[kubernetes.client.V1NodeSelectorTerm]
+    list[kubernetes.client.V1NodeSelectorTerm]
 ):
     """
     Generate node selector term containing anti-affinity expressions based on the
@@ -84,7 +83,7 @@ def generate_preemptible_nodes_anti_affinity_terms() -> (
 
 
 def generate_preemptible_nodes_affinity_terms() -> (
-    typing.List[kubernetes.client.V1NodeSelectorTerm]
+    list[kubernetes.client.V1NodeSelectorTerm]
 ):
     """
     Use for purpose of scheduling on node having at least one of the node selectors.
@@ -105,7 +104,7 @@ def generate_preemptible_nodes_affinity_terms() -> (
     return node_selector_terms
 
 
-def generate_preemptible_tolerations() -> typing.List[kubernetes.client.V1Toleration]:
+def generate_preemptible_tolerations() -> list[kubernetes.client.V1Toleration]:
     tolerations = mlconfig.get_preemptible_tolerations()
 
     toleration_objects = []
@@ -142,17 +141,6 @@ def verify_label_key(key: str):
     if not key:
         raise mlrun.errors.MLRunInvalidArgumentError("label key cannot be empty")
 
-    mlrun.utils.helpers.verify_field_regex(
-        f"project.metadata.labels.'{key}'",
-        key,
-        mlrun.utils.regex.k8s_character_limit,
-    )
-
-    if key.startswith("k8s.io/") or key.startswith("kubernetes.io/"):
-        raise mlrun.errors.MLRunInvalidArgumentError(
-            "Labels cannot start with 'k8s.io/' or 'kubernetes.io/'"
-        )
-
     parts = key.split("/")
     if len(parts) == 1:
         name = parts[0]
@@ -174,12 +162,22 @@ def verify_label_key(key: str):
             "Label key can only contain one '/'"
         )
 
+    mlrun.utils.helpers.verify_field_regex(
+        f"project.metadata.labels.'{key}'",
+        name,
+        mlrun.utils.regex.k8s_character_limit,
+    )
     mlrun.utils.helpers.verify_field_regex(
         f"project.metadata.labels.'{key}'",
         name,
         mlrun.utils.regex.qualified_name,
     )
 
+    if key.startswith("k8s.io/") or key.startswith("kubernetes.io/"):
+        raise mlrun.errors.MLRunInvalidArgumentError(
+            "Labels cannot start with 'k8s.io/' or 'kubernetes.io/'"
+        )
+
 
 def verify_label_value(value, label_key):
     mlrun.utils.helpers.verify_field_regex(

mlrun/launcher/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2023 MLRun Authors
+# Copyright 2023 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

mlrun/launcher/base.py

@@ -1,4 +1,4 @@
-# Copyright 2023 MLRun Authors
+# Copyright 2023 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -16,12 +16,13 @@ import ast
 import copy
 import os
 import uuid
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Optional, Union
+
+import mlrun_pipelines.common.ops
 
 import mlrun.common.schemas
 import mlrun.config
 import mlrun.errors
-import mlrun.kfpops
 import mlrun.lists
 import mlrun.model
 import mlrun.runtimes
@@ -53,7 +54,7 @@ class BaseLauncher(abc.ABC):
         name: Optional[str] = "",
         project: Optional[str] = "",
         params: Optional[dict] = None,
-        inputs: Optional[Dict[str, str]] = None,
+        inputs: Optional[dict[str, str]] = None,
         out_path: Optional[str] = "",
         workdir: Optional[str] = "",
         artifact_path: Optional[str] = "",
@@ -61,16 +62,16 @@ class BaseLauncher(abc.ABC):
         schedule: Optional[
             Union[str, mlrun.common.schemas.schedule.ScheduleCronTrigger]
         ] = None,
-        hyperparams: Dict[str, list] = None,
+        hyperparams: dict[str, list] = None,
         hyper_param_options: Optional[mlrun.model.HyperParamOptions] = None,
         verbose: Optional[bool] = None,
         scrape_metrics: Optional[bool] = None,
         local_code_path: Optional[str] = None,
         auto_build: Optional[bool] = None,
-        param_file_secrets: Optional[Dict[str, str]] = None,
-        notifications: Optional[List[mlrun.model.Notification]] = None,
-        returns: Optional[List[Union[str, Dict[str, str]]]] = None,
-        state_thresholds: Optional[Dict[str, int]] = None,
+        param_file_secrets: Optional[dict[str, str]] = None,
+        notifications: Optional[list[mlrun.model.Notification]] = None,
+        returns: Optional[list[Union[str, dict[str, str]]]] = None,
+        state_thresholds: Optional[dict[str, int]] = None,
     ) -> "mlrun.run.RunObject":
         """run the function from the server/client[local/remote]"""
         pass
@@ -175,7 +176,7 @@ class BaseLauncher(abc.ABC):
             if message:
                 logger.warning(message, output_path=run.spec.output_path)
 
-    def _validate_run_params(self, parameters: Dict[str, Any]):
+    def _validate_run_params(self, parameters: dict[str, Any]):
         for param_name, param_value in parameters.items():
             if isinstance(param_value, dict):
                 # if the parameter is a dict, we might have some nested parameters,
@@ -237,8 +238,8 @@ class BaseLauncher(abc.ABC):
         out_path=None,
         artifact_path=None,
         workdir=None,
-        notifications: List[mlrun.model.Notification] = None,
-        state_thresholds: Optional[Dict[str, int]] = None,
+        notifications: list[mlrun.model.Notification] = None,
+        state_thresholds: Optional[dict[str, int]] = None,
     ):
         run.spec.handler = (
             handler or run.spec.handler or runtime.spec.default_handler or ""
@@ -353,7 +354,7 @@ class BaseLauncher(abc.ABC):
             or {}
         )
         state_thresholds = (
-            mlrun.config.config.function.spec.state_thresholds.default.to_dict()
+            mlrun.mlconf.function.spec.state_thresholds.default.to_dict()
             | state_thresholds
         )
         run.spec.state_thresholds = state_thresholds or run.spec.state_thresholds
@@ -390,7 +391,7 @@ class BaseLauncher(abc.ABC):
             return
 
         if result and runtime.kfp and err is None:
-            mlrun.kfpops.write_kfpmeta(result)
+            mlrun_pipelines.common.ops.write_kfpmeta(result)
 
         self._log_track_results(runtime.is_child, result, run)
 
@@ -403,7 +404,7 @@ class BaseLauncher(abc.ABC):
             )
             if (
                 run.status.state
-                in mlrun.runtimes.constants.RunStates.error_and_abortion_states()
+                in mlrun.common.runtimes.constants.RunStates.error_and_abortion_states()
             ):
                 if runtime._is_remote and not runtime.is_child:
                     logger.error(