mlrun 1.10.0rc40__py3-none-any.whl → 1.11.0rc16__py3-none-any.whl

mlrun/serving/steps.py

@@ -45,7 +45,7 @@ class ChoiceByField(storey.Choice):
             )
 
         # Case 3: Invalid type
-        if not isinstance(outlet, (str, list, tuple)):
+        if not isinstance(outlet, str | list | tuple):
             raise mlrun.errors.MLRunInvalidArgumentTypeError(
                 f"Field '{self.field_name}' must be a string or list of strings "
                 f"but is instead of type '{type(outlet).__name__}'."

mlrun/serving/system_steps.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import random
+import typing
 from copy import copy
 from datetime import timedelta
 from typing import Any, Optional, Union
@@ -70,10 +71,14 @@ class MonitoringPreProcessor(storey.MapClass):
             output_schema=output_schema,
             input_schema=input_schema,
         )
-
-        outputs, new_output_schema = self.get_listed_data(
-            event.body.get(model, event.body), result_path, output_schema
-        )
+        if event.body and isinstance(event.body, list):
+            outputs, new_output_schema = self.get_listed_data(
+                event.body, result_path, output_schema
+            )
+        else:
+            outputs, new_output_schema = self.get_listed_data(
+                event.body.get(model, event.body), result_path, output_schema
+            )
         inputs, new_input_schema = self.get_listed_data(
             event._metadata.get("inputs", {}), input_path, input_schema
         )
@@ -112,7 +117,7 @@ class MonitoringPreProcessor(storey.MapClass):
 
     def get_listed_data(
         self,
-        raw_data: dict,
+        raw_data: typing.Union[dict, list],
         data_path: Optional[Union[list[str], str]] = None,
         schema: Optional[list[str]] = None,
     ):
@@ -193,8 +198,8 @@ class MonitoringPreProcessor(storey.MapClass):
             )
 
         # Detect if all are scalars ie: int,float,str
-        all_scalars = all(not isinstance(v, (list, tuple, np.ndarray)) for v in values)
-        all_lists = all(isinstance(v, (list, tuple, np.ndarray)) for v in values)
+        all_scalars = all(not isinstance(v, list | tuple | np.ndarray) for v in values)
+        all_lists = all(isinstance(v, list | tuple | np.ndarray) for v in values)
 
         if not (all_scalars or all_lists):
             raise ValueError(
@@ -242,6 +247,21 @@ class MonitoringPreProcessor(storey.MapClass):
                         when = event._metadata.get(model, {}).get(
                             mm_schemas.StreamProcessingEvent.WHEN
                         )
+                    #  if the body is not a dict, use empty labels, error and metrics
+                    if isinstance(event.body[model], dict):
+                        body_by_model = event.body[model]
+                        labels = body_by_model.get("labels") or {}
+                        error = body_by_model.get(
+                            mm_schemas.StreamProcessingEvent.ERROR
+                        )
+                        metrics = body_by_model.get(
+                            mm_schemas.StreamProcessingEvent.METRICS
+                        )
+                    else:
+                        labels = {}
+                        error = None
+                        metrics = None
+
                     monitoring_event_list.append(
                         {
                             mm_schemas.StreamProcessingEvent.MODEL: model,
@@ -257,27 +277,14 @@ class MonitoringPreProcessor(storey.MapClass):
                             ].get(
                                 mlrun.common.schemas.MonitoringData.MODEL_ENDPOINT_UID
                             ),
-                            mm_schemas.StreamProcessingEvent.LABELS: event.body[
-                                model
-                            ].get("labels")
-                            or {},
+                            mm_schemas.StreamProcessingEvent.LABELS: labels,
                             mm_schemas.StreamProcessingEvent.FUNCTION_URI: self.server.function_uri
                             if self.server
                             else None,
                             mm_schemas.StreamProcessingEvent.REQUEST: request,
                             mm_schemas.StreamProcessingEvent.RESPONSE: resp,
-                            mm_schemas.StreamProcessingEvent.ERROR: event.body[model][
-                                mm_schemas.StreamProcessingEvent.ERROR
-                            ]
-                            if mm_schemas.StreamProcessingEvent.ERROR
-                            in event.body[model]
-                            else None,
-                            mm_schemas.StreamProcessingEvent.METRICS: event.body[model][
-                                mm_schemas.StreamProcessingEvent.METRICS
-                            ]
-                            if mm_schemas.StreamProcessingEvent.METRICS
-                            in event.body[model]
-                            else None,
+                            mm_schemas.StreamProcessingEvent.ERROR: error,
+                            mm_schemas.StreamProcessingEvent.METRICS: metrics,
                         }
                     )
         elif monitoring_data:
@@ -289,6 +296,15 @@ class MonitoringPreProcessor(storey.MapClass):
                 when = event._original_timestamp
             else:
                 when = event._metadata.get(mm_schemas.StreamProcessingEvent.WHEN)
+            #  if the body is not a dict, use empty labels, error and metrics
+            if isinstance(event.body, dict):
+                labels = event.body.get("labels") or {}
+                error = event.body.get(mm_schemas.StreamProcessingEvent.ERROR)
+                metrics = event.body.get(mm_schemas.StreamProcessingEvent.METRICS)
+            else:
+                labels = {}
+                error = None
+                metrics = None
             monitoring_event_list.append(
                 {
                     mm_schemas.StreamProcessingEvent.MODEL: model,
@@ -302,21 +318,14 @@ class MonitoringPreProcessor(storey.MapClass):
                     mm_schemas.StreamProcessingEvent.ENDPOINT_ID: monitoring_data[
                         model
                     ].get(mlrun.common.schemas.MonitoringData.MODEL_ENDPOINT_UID),
-                    mm_schemas.StreamProcessingEvent.LABELS: event.body.get("labels")
-                    or {},
+                    mm_schemas.StreamProcessingEvent.LABELS: labels,
                     mm_schemas.StreamProcessingEvent.FUNCTION_URI: self.server.function_uri
                     if self.server
                     else None,
                     mm_schemas.StreamProcessingEvent.REQUEST: request,
                     mm_schemas.StreamProcessingEvent.RESPONSE: resp,
-                    mm_schemas.StreamProcessingEvent.ERROR: event.body.get(
-                        mm_schemas.StreamProcessingEvent.ERROR
-                    ),
-                    mm_schemas.StreamProcessingEvent.METRICS: event.body[
-                        mm_schemas.StreamProcessingEvent.METRICS
-                    ]
-                    if mm_schemas.StreamProcessingEvent.METRICS in event.body
-                    else None,
+                    mm_schemas.StreamProcessingEvent.ERROR: error,
+                    mm_schemas.StreamProcessingEvent.METRICS: metrics,
                 }
             )
         event.body = monitoring_event_list

mlrun/track/trackers/mlflow_tracker.py

@@ -217,7 +217,7 @@ class MLFlowTracker(Tracker):
             handler=handler,
             run_name=run.info.run_name,
             project_name=project.name,
-            uid=run.info.run_uuid,
+            uid=run.info.run_id,
         )
 
         # Create a context from the run object:
@@ -373,7 +373,7 @@ class MLFlowTracker(Tracker):
             # Import the MLFlow run's artifacts to MLRun (model are logged after the rest of artifacts
             # so the artifacts can be registered as extra data in the models):
             artifacts = {}
-            model_paths = []
+            model_uris = []
             for artifact in client.list_artifacts(run_id=run.info.run_id):
                 # Get the artifact's local path (MLFlow suggests that if the artifact is already in the local filesystem
                 # its local path will be returned:
@@ -381,29 +381,29 @@ class MLFlowTracker(Tracker):
                     run_id=run.info.run_id,
                     artifact_path=artifact.path,
                 )
-                # Check if the artifact is a model (will be logged after the artifacts):
-                if artifact.is_dir and os.path.exists(
-                    os.path.join(
-                        artifact_local_path, "MLmodel"
-                    )  # Add tag to show model dir
-                ):
-                    model_paths.append(artifact_local_path)
-                else:
-                    # Log the artifact:
-                    artifact = MLFlowTracker._log_artifact(
-                        context=context,
-                        key=pathlib.Path(artifact.path).name.replace(".", "_"),
-                        # Mlflow has the same name for files but with different extensions, so we add extension to name
-                        local_path=artifact_local_path,
-                        tmp_path=tmp_dir,
-                    )
-                    artifacts[artifact.key] = artifact
+                # Log the artifact:
+                artifact = MLFlowTracker._log_artifact(
+                    context=context,
+                    key=pathlib.Path(artifact.path).name.replace(".", "_"),
+                    # Mlflow has the same name for files but with different extensions, so we add extension to name
+                    local_path=artifact_local_path,
+                    tmp_path=tmp_dir,
+                )
+                artifacts[artifact.key] = artifact
+
+            # get all run model's uri's (artifact_location in mlflow 3.0.0).
+            logged_models = mlflow.search_logged_models(
+                filter_string=f"source_run_id = '{run.info.run_id}'",
+                output_format="list",
+            )
+            for logged_model in logged_models:
+                model_uris.append(logged_model.artifact_location)
 
-            for model_path in model_paths:
+            for model_uri in model_uris:
                 MLFlowTracker._log_model(
                     context=context,
-                    model_uri=model_path,
-                    key=pathlib.Path(model_path).stem,
+                    model_uri=model_uri,
+                    key=pathlib.Path(model_uri).stem,
                     metrics=results,
                     extra_data=artifacts,
                     tmp_path=tmp_dir,
@@ -439,20 +439,18 @@ class MLFlowTracker(Tracker):
 
         # Get the model info from MLFlow:
         model_info = mlflow.models.get_model_info(model_uri=model_uri)
+        # Download the model and set the path to local path:
+        local_model_path = mlflow.artifacts.download_artifacts(
+            artifact_uri=str(model_uri)
+        )
+        model_path = pathlib.Path(local_model_path)
 
         # Prepare the archive path:
-        model_uri = pathlib.Path(model_uri)
-        archive_path = pathlib.Path(tmp_path) / f"{model_uri.stem}.zip"
-        if not os.path.exists(model_uri):
-            local_path = mlflow.artifacts.download_artifacts(
-                artifact_uri=str(model_uri)
-            )
-            model_uri = pathlib.Path(local_path)
-
+        archive_path = pathlib.Path(tmp_path) / f"{model_path.name}.zip"
         # TODO add progress bar for the case of large files
         # Zip the artifact:
         with zipfile.ZipFile(archive_path, "w") as zip_file:
-            for path in model_uri.rglob("*"):
+            for path in model_path.rglob("*"):
                 zip_file.write(filename=path, arcname=path.relative_to(model_uri))
 
         # Get inputs and outputs info:

mlrun/utils/helpers.py

@@ -11,10 +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 asyncio
 import base64
 import enum
+import functools
 import gzip
 import hashlib
 import inspect
@@ -30,7 +30,7 @@ import typing
 import uuid
 import warnings
 from copy import deepcopy
-from datetime import datetime, timedelta, timezone
+from datetime import UTC, datetime, timedelta, timezone
 from importlib import import_module, reload
 from os import path
 from types import ModuleType
@@ -462,7 +462,7 @@ def get_pretty_types_names(types):
     return types[0].__name__
 
 
-def now_date(tz: timezone = timezone.utc) -> datetime:
+def now_date(tz: timezone = UTC) -> datetime:
     return datetime.now(tz=tz)
 
 
@@ -477,7 +477,7 @@ def datetime_to_mysql_ts(datetime_object: datetime) -> datetime:
     :return: A MySQL-compatible timestamp string with millisecond precision.
     """
     if not datetime_object.tzinfo:
-        datetime_object = datetime_object.replace(tzinfo=timezone.utc)
+        datetime_object = datetime_object.replace(tzinfo=UTC)
 
     # Round to the nearest millisecond
     ms = round(datetime_object.microsecond / 1000) * 1000
@@ -488,7 +488,7 @@ def datetime_to_mysql_ts(datetime_object: datetime) -> datetime:
     return datetime_object.replace(microsecond=ms)
 
 
-def datetime_min(tz: timezone = timezone.utc) -> datetime:
+def datetime_min(tz: timezone = UTC) -> datetime:
     return datetime(1970, 1, 1, tzinfo=tz)
 
 
@@ -773,11 +773,11 @@ def dict_to_yaml(struct) -> str:
 # solve numpy json serialization
 class MyEncoder(json.JSONEncoder):
     def default(self, obj):
-        if isinstance(obj, (int, str, float, list, dict)):
+        if isinstance(obj, int | str | float | list | dict):
             return obj
-        elif isinstance(obj, (np.integer, np.int64)):
+        elif isinstance(obj, np.integer | np.int64):
             return int(obj)
-        elif isinstance(obj, (np.floating, np.float64)):
+        elif isinstance(obj, np.floating | np.float64):
             return float(obj)
         elif isinstance(obj, np.ndarray):
             return obj.tolist()
@@ -1025,8 +1025,10 @@ def enrich_image_url(
         # use the tag from image URL if available, else fallback to the given tag
         tag = image_tag or tag
         if tag:
+            # Remove '-pyXY' suffix if present, since the compatibility check expects a valid semver string
+            tag_for_compatibility = re.sub(r"-py\d+$", "", tag)
             if mlrun.utils.helpers.validate_component_version_compatibility(
-                "mlrun-client", "1.10.0-rc0", mlrun_client_version=tag
+                "mlrun-client", "1.10.0-rc0", mlrun_client_version=tag_for_compatibility
             ):
                 warnings.warn(
                     "'mlrun/ml-base' image is deprecated in 1.10.0 and will be removed in 1.12.0, "
@@ -1531,9 +1533,9 @@ def datetime_from_iso(time_str: str) -> Optional[datetime]:
         return
     dt = parser.isoparse(time_str)
     if dt.tzinfo is None:
-        dt = dt.replace(tzinfo=timezone.utc)
+        dt = dt.replace(tzinfo=UTC)
     # ensure the datetime is in UTC, converting if necessary
-    return dt.astimezone(timezone.utc)
+    return dt.astimezone(UTC)
 
 
 def datetime_to_iso(time_obj: Optional[datetime]) -> Optional[str]:
@@ -1547,7 +1549,7 @@ def enrich_datetime_with_tz_info(timestamp_string) -> Optional[datetime]:
         return timestamp_string
 
     if timestamp_string and not mlrun.utils.helpers.has_timezone(timestamp_string):
-        timestamp_string += datetime.now(timezone.utc).astimezone().strftime("%z")
+        timestamp_string += datetime.now(UTC).astimezone().strftime("%z")
 
     for _format in [
         # e.g: 2021-08-25 12:00:00.000Z
@@ -1578,7 +1580,7 @@ def format_datetime(dt: datetime, fmt: Optional[str] = None) -> str:
 
     # If the datetime is naive
     if dt.tzinfo is None:
-        dt = dt.replace(tzinfo=timezone.utc)
+        dt = dt.replace(tzinfo=UTC)
 
     # TODO: Once Python 3.12 is the minimal version, use %:z to format the timezone offset with a colon
     formatted_time = dt.strftime(fmt or "%Y-%m-%d %H:%M:%S.%f%z")
@@ -1740,7 +1742,7 @@ def format_run(run: PipelineRun, with_project=False) -> dict:
     for key, value in run.items():
         if (
             key in time_keys
-            and isinstance(value, (str, datetime))
+            and isinstance(value, str | datetime)
             and parser.parse(str(value)).year == 1970
         ):
             run[key] = None
@@ -2147,7 +2149,7 @@ def validate_single_def_handler(function_kind: str, code: str):
     # it would override MLRun's wrapper
     if function_kind == "mlrun":
         # Find all lines that start with "def handler("
-        pattern = re.compile(r"^def handler\(", re.MULTILINE)
+        pattern = re.compile(r"^(?:async\s+)?def handler\(", re.MULTILINE)
         matches = pattern.findall(code)
 
         # Only MLRun's wrapper handler (footer) can be in the code
@@ -2454,7 +2456,30 @@ def split_path(path: str) -> typing.Union[str, list[str], None]:
     return path
 
 
-def get_data_from_path(path: typing.Union[str, list[str], None], data: dict) -> Any:
+def get_data_from_path(
+    path: typing.Union[str, list[str], None], data: typing.Union[dict, list]
+) -> Any:
+    if data and isinstance(data, list):
+        output_data = []
+        for item in data:
+            if isinstance(item, dict):
+                output_data.append(get_data_from_dict(path, item))
+            elif path is None:
+                output_data = data
+            else:
+                raise mlrun.errors.MLRunInvalidArgumentError(
+                    "If data is a list of non-dict values, path must be None"
+                )
+        return output_data
+    elif isinstance(data, dict):
+        return get_data_from_dict(path, data)
+    else:
+        raise mlrun.errors.MLRunInvalidArgumentError(
+            "Expected data be of type dict or list"
+        )
+
+
+def get_data_from_dict(path: typing.Union[str, list[str], None], data: dict) -> Any:
     if isinstance(path, str):
         output_data = data.get(path)
     elif isinstance(path, list):
@@ -2552,3 +2577,51 @@ def get_relative_module_name_from_path(
         working_dir_path_object
     )
     return ".".join(relative_path_to_source_file.with_suffix("").parts)
+
+
+def iguazio_v4_only(function):
+    @functools.wraps(function)
+    def wrapper(*args, **kwargs):
+        if not config.is_iguazio_v4_mode():
+            raise mlrun.errors.MLRunRuntimeError(
+                "This method is only supported in an Iguazio V4 system."
+            )
+        return function(*args, **kwargs)
+
+    return wrapper
+
+
+def raise_or_log_error(message: str, raise_on_error: bool = True):
+    """
+    Handle errors by either raising an exception or logging a warning.
+
+    :param message: The error message.
+    :param raise_on_error: If True, raises an exception. Otherwise, logs a warning.
+    """
+    if raise_on_error:
+        raise mlrun.errors.MLRunRuntimeError(message)
+    logger.warning(message)
+
+
+def is_running_in_runtime() -> bool:
+    """
+    Check if the code is running inside an MLRun runtime environment.
+    :return: True if running inside an MLRun runtime, False otherwise.
+    """
+    # Check for the presence of the MLRUN_RUNTIME_KIND environment variable
+    return True if os.getenv("MLRUN_RUNTIME_KIND") else False
+
+
+def is_async_serving_graph(function_spec) -> bool:
+    """Check if the serving graph contains any async nodes."""
+    if not function_spec:
+        return False
+
+    if (
+        hasattr(function_spec, "graph")
+        and hasattr(function_spec.graph, "engine")
+        and function_spec.graph.engine == "async"
+    ):
+        return True
+
+    return False

mlrun/utils/http.py

@@ -68,6 +68,7 @@ class HTTPSessionWithRetry(requests.Session):
         retry_on_exception=True,
         retry_on_status=True,
         retry_on_post=False,
+        retry_on_put=True,
         verbose=False,
     ):
         """
@@ -77,6 +78,8 @@ class HTTPSessionWithRetry(requests.Session):
         :param retry_on_exception:      Retry on the HTTP_RETRYABLE_EXCEPTIONS. defaults to True.
         :param retry_on_status:         Retry on error status codes. defaults to True.
         :param retry_on_post:           Retry on POST requests. defaults to False.
+        :param retry_on_put:            Whether to allow retries on PUT requests. Actual behavior may exclude specific
+                                        paths from retrying. defaults to True.
         :param verbose:                 Print debug messages.
         """
         super().__init__()
@@ -86,7 +89,7 @@ class HTTPSessionWithRetry(requests.Session):
         self.retry_on_exception = retry_on_exception
         self.verbose = verbose
         self._logger = logger.get_child("http-client")
-        self._retry_methods = self._resolve_retry_methods(retry_on_post)
+        self._retry_methods = self._resolve_retry_methods(retry_on_post, retry_on_put)
 
         if retry_on_status:
             self._http_adapter = requests.adapters.HTTPAdapter(
@@ -200,9 +203,13 @@ class HTTPSessionWithRetry(requests.Session):
     def _method_retryable(self, method: str):
         return method in self._retry_methods
 
-    def _resolve_retry_methods(self, retry_on_post: bool = False) -> frozenset[str]:
+    def _resolve_retry_methods(
+        self, retry_on_post: bool = False, retry_on_put: bool = True
+    ) -> frozenset[str]:
         methods = urllib3.util.retry.Retry.DEFAULT_ALLOWED_METHODS
         methods = methods.union({"PATCH"})
+        if not retry_on_put:
+            methods = methods.difference({"PUT"})
         if retry_on_post:
             methods = methods.union({"POST"})
         return frozenset(methods)

mlrun/utils/notifications/notification/git.py

@@ -142,7 +142,7 @@ class GitNotification(NotificationBase):
                     issue = event["number"]
             headers = {
                 "Accept": "application/vnd.github.v3+json",
-                "Authorization": f"token {token}",
+                mlrun.common.schemas.HeaderNames.authorization: f"token {token}",
             }
             url = f"https://{server}/repos/{repo}/issues/{issue}/comments"
 

mlrun/utils/notifications/notification/mail.py

@@ -34,17 +34,18 @@ class MailNotification(base.NotificationBase):
 
     boolean_params = ["use_tls", "start_tls", "validate_certs"]
 
+    optional_auth_params = ["username", "password"]
+
     required_params = [
         "server_host",
         "server_port",
         "sender_address",
-        "username",
-        "password",
         "email_addresses",
     ] + boolean_params
 
     @classmethod
     def validate_params(cls, params):
+        cls._enrich_params(params)
         for required_param in cls.required_params:
             if required_param not in params:
                 raise ValueError(
@@ -57,6 +58,13 @@ class MailNotification(base.NotificationBase):
                     f"Parameter '{boolean_param}' must be a boolean for MailNotification"
                 )
 
+        # Allow no auth, username only, or username + password
+        # Some SMTP servers allow username without password
+        if params["password"] and not params["username"]:
+            raise ValueError(
+                "Parameter 'username' is required when 'password' is provided for MailNotification"
+            )
+
         cls._validate_emails(params)
 
     async def push(
@@ -78,6 +86,8 @@ class MailNotification(base.NotificationBase):
         )
         self.params["body"] = runs_html
 
+        self._enrich_params(self.params)
+
         if message_body_override:
             self.params["body"] = message_body_override.replace(
                 "{{ runs }}", runs_html
@@ -122,7 +132,7 @@ class MailNotification(base.NotificationBase):
     def _validate_emails(cls, params):
         cls._validate_email_address(params["sender_address"])
 
-        if not isinstance(params["email_addresses"], (str, list)):
+        if not isinstance(params["email_addresses"], str | list):
             raise ValueError(
                 "Parameter 'email_addresses' must be a string or a list of strings"
             )
@@ -147,8 +157,8 @@ class MailNotification(base.NotificationBase):
         sender_address: str,
         server_host: str,
         server_port: int,
-        username: str,
-        password: str,
+        username: typing.Optional[str],
+        password: typing.Optional[str],
         use_tls: bool,
         start_tls: bool,
         validate_certs: bool,
@@ -163,14 +173,27 @@ class MailNotification(base.NotificationBase):
         message["Subject"] = subject
         message.attach(MIMEText(body, "html"))
 
-        # Send the email
-        await aiosmtplib.send(
-            message,
-            hostname=server_host,
-            port=server_port,
-            username=username,
-            password=password,
-            use_tls=use_tls,
-            validate_certs=validate_certs,
-            start_tls=start_tls,
-        )
+        send_kwargs = {
+            "hostname": server_host,
+            "port": server_port,
+            "use_tls": use_tls,
+            "validate_certs": validate_certs,
+            "start_tls": start_tls,
+        }
+
+        # Only include auth parameters when provided to avoid forcing SMTP AUTH
+        if username is not None:
+            send_kwargs["username"] = username
+        if password is not None:
+            send_kwargs["password"] = password
+
+        await aiosmtplib.send(message, **send_kwargs)
+
+    @staticmethod
+    def _enrich_params(params):
+        # if username/password are not provided or empty strings, set them to None.
+        # this ensures consistent behavior in _send_email and avoids
+        # forcing SMTP auth when the server does not require authentication.
+        for param in ["username", "password"]:
+            if param not in params or not params[param]:
+                params[param] = None

mlrun/utils/notifications/notification_pusher.py

@@ -347,7 +347,7 @@ class NotificationPusher(_NotificationPusherBase):
                 run_uid=run.metadata.uid,
             )
             update_notification_status_kwargs["sent_time"] = datetime.datetime.now(
-                tz=datetime.timezone.utc
+                tz=datetime.UTC
             )
         except Exception as exc:
             logger.warning(
@@ -397,7 +397,7 @@ class NotificationPusher(_NotificationPusherBase):
                 run_uid=run.metadata.uid,
             )
             update_notification_status_kwargs["sent_time"] = datetime.datetime.now(
-                tz=datetime.timezone.utc
+                tz=datetime.UTC
             )
 
         except Exception as exc:

mlrun/utils/version/version.json

@@ -1,4 +1,4 @@
 {
-  "git_commit": "3bb8c631304e89739430fbb6e6299e190fe6738a",
-  "version": "1.10.0-rc40"
+  "git_commit": "160a94f1532940f8a7d039ed5488912c27098edf",
+  "version": "1.11.0-rc16"
 }

mlrun/utils/version/version.py

@@ -14,7 +14,7 @@
 
 import json
 import sys
-from importlib.resources import read_text
+from importlib.resources import files
 
 import mlrun.utils
 from mlrun.utils.singleton import Singleton
@@ -37,9 +37,8 @@ class Version(metaclass=Singleton):
         self.version_info = {"git_commit": "unknown", "version": "0.0.0+unstable"}
         self.python_version = self._resolve_python_version()
         try:
-            self.version_info = json.loads(
-                read_text("mlrun.utils.version", "version.json")
-            )
+            with (files("mlrun.utils.version") / "version.json").open("r") as read_text:
+                self.version_info = json.loads(read_text.read())
         except Exception:
             mlrun.utils.logger.warning(
                 "Failed resolving version info. Ignoring and using defaults"