mlrun 1.6.0rc35__py3-none-any.whl → 1.7.0rc2__py3-none-any.whl

mlrun/utils/retryer.py

@@ -0,0 +1,207 @@
+# 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.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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 time
+
+import mlrun.errors
+
+
+def create_linear_backoff(base=2, coefficient=2, stop_value=120):
+    """
+    Create a generator of linear backoff. Check out usage example in test_helpers.py
+    """
+    x = 0
+    comparison = min if coefficient >= 0 else max
+
+    while True:
+        next_value = comparison(base + x * coefficient, stop_value)
+        yield next_value
+        x += 1
+
+
+def create_step_backoff(steps=None):
+    """
+    Create a generator of steps backoff.
+    Example: steps = [[2, 5], [20, 10], [120, None]] will produce a generator in which the first 5
+    values will be 2, the next 10 values will be 20 and the rest will be 120.
+    :param steps: a list of lists [step_value, number_of_iteration_in_this_step]
+    """
+    steps = steps if steps is not None else [[2, 10], [10, 10], [120, None]]
+    steps = iter(steps)
+
+    # Get first step
+    step = next(steps)
+    while True:
+        current_step_value, current_step_remain = step
+        if current_step_remain == 0:
+            # No more in this step, moving on
+            step = next(steps)
+        elif current_step_remain is None:
+            # We are in the last step, staying here forever
+            yield current_step_value
+        elif current_step_remain > 0:
+            # Still more remains in this step, just reduce the remaining number
+            step[1] -= 1
+            yield current_step_value
+
+
+def create_exponential_backoff(base=2, max_value=120, scale_factor=1):
+    """
+    Create a generator of exponential backoff. Check out usage example in test_helpers.py
+    :param base: exponent base
+    :param max_value: max limit on the result
+    :param scale_factor: factor to be used as linear scaling coefficient
+    """
+    exponent = 1
+    while True:
+        # This "complex" implementation (unlike the one in linear backoff) is to avoid exponent growing too fast and
+        # risking going behind max_int
+        next_value = scale_factor * (base**exponent)
+        if next_value < max_value:
+            exponent += 1
+            yield next_value
+        else:
+            yield max_value
+
+
+class Retryer:
+    def __init__(self, backoff, timeout, logger, verbose, function, *args, **kwargs):
+        """
+        Initialize function retryer with given *args and **kwargs.
+        Tries to run it until success or timeout reached (timeout is optional)
+        :param backoff: can either be a:
+                - number (int / float) that will be used as interval.
+                - generator of waiting intervals. (support next())
+        :param timeout: pass None if timeout is not wanted, number of seconds if it is
+        :param logger: a logger so we can log the failures
+        :param verbose: whether to log the failure on each retry
+        :param _function: function to run
+        :param args: functions args
+        :param kwargs: functions kwargs
+        """
+        self.backoff = backoff
+        self.timeout = timeout
+        self.logger = logger
+        self.verbose = verbose
+        self.function = function
+        self.args = args
+        self.kwargs = kwargs
+        self.start_time = None
+        self.last_exception = None
+        self.first_interval = None
+
+    def run(self):
+        self._prepare()
+        while not self._timeout_exceeded():
+            next_interval = self.first_interval or next(self.backoff)
+            result, exc, retry = self._perform_call(next_interval)
+            if retry:
+                time.sleep(next_interval)
+            elif not exc:
+                return result
+            else:
+                break
+
+        self._raise_last_exception()
+
+    def _prepare(self):
+        self.start_time = time.time()
+        self.last_exception = None
+
+        # Check if backoff is just a simple interval
+        if isinstance(self.backoff, int) or isinstance(self.backoff, float):
+            self.backoff = create_linear_backoff(base=self.backoff, coefficient=0)
+
+        self.first_interval = next(self.backoff)
+        if self.timeout and self.timeout <= self.first_interval:
+            self.logger.warning(
+                f"Timeout ({self.timeout}) must be higher than backoff ({self.first_interval})."
+                f" Set timeout to be higher than backoff."
+            )
+
+    def _perform_call(self, next_interval):
+        try:
+            result = self.function(*self.args, **self.kwargs)
+            return result, None, False
+        except mlrun.errors.MLRunFatalFailureError as exc:
+            raise exc.original_exception
+        except Exception as exc:
+            return (
+                None,
+                self.last_exception,
+                self._assert_failure_timeout(next_interval, exc),
+            )
+
+    def _assert_failure_timeout(self, next_interval, exc):
+        self.last_exception = exc
+
+        # If next interval is within allowed time period - wait on interval, abort otherwise
+        if not self._timeout_exceeded(next_interval):
+            if self.logger is not None and self.verbose:
+                self.logger.debug(
+                    f"Operation not yet successful, Retrying in {next_interval} seconds."
+                    f" exc: {mlrun.errors.err_to_str(exc)}"
+                )
+            return True
+        else:
+            return False
+
+    def _raise_last_exception(self):
+        if self.logger is not None:
+            self.logger.warning(
+                f"Operation did not complete on time. last exception: {self.last_exception}"
+            )
+
+        raise mlrun.errors.MLRunRetryExhaustedError(
+            f"Failed to execute command by the given deadline."
+            f" last_exception: {self.last_exception},"
+            f" function_name: {self.function.__name__},"
+            f" timeout: {self.timeout}"
+        ) from self.last_exception
+
+    def _timeout_exceeded(self, next_interval=None):
+        now = time.time()
+        if next_interval:
+            now = now + next_interval
+        return self.timeout is not None and now >= self.start_time + self.timeout
+
+
+class AsyncRetryer(Retryer):
+    async def run(self):
+        self._prepare()
+        while not self._timeout_exceeded():
+            next_interval = self.first_interval or next(self.backoff)
+            result, exc, retry = await self._perform_call(next_interval)
+            if retry:
+                await asyncio.sleep(next_interval)
+            elif not exc:
+                return result
+            else:
+                break
+
+        self._raise_last_exception()
+
+    async def _perform_call(self, next_interval):
+        try:
+            result = await self.function(*self.args, **self.kwargs)
+            return result, None, False
+        except mlrun.errors.MLRunFatalFailureError as exc:
+            raise exc.original_exception
+        except Exception as exc:
+            return (
+                None,
+                self.last_exception,
+                self._assert_failure_timeout(next_interval, exc),
+            )

mlrun/utils/singleton.py

@@ -20,7 +20,7 @@ class Singleton(type):
 
     def __call__(cls, *args, **kwargs):
         if cls not in cls._instances:
-            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
+            cls._instances[cls] = super().__call__(*args, **kwargs)
         return cls._instances[cls]
 
 

mlrun/utils/v3io_clients.py

@@ -12,14 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-from typing import Dict, FrozenSet
 
 from v3io.dataplane import Client as V3IOClient
 from v3io_frames import Client as get_client
 from v3io_frames.client import ClientBase
 
-_v3io_clients: Dict[FrozenSet, V3IOClient] = {}
-_frames_clients: Dict[FrozenSet, ClientBase] = {}
+_v3io_clients: dict[frozenset, V3IOClient] = {}
+_frames_clients: dict[frozenset, ClientBase] = {}
 
 
 def get_frames_client(**kwargs) -> ClientBase:

mlrun/utils/version/version.json

@@ -1,4 +1,4 @@
 {
-  "git_commit": "b8188f94dc3e0bfc4bb74ab4296bec213b019e67",
-  "version": "1.6.0-rc35"
+  "git_commit": "523bdf379b1183bee50b5b0ebe61ddeae9d7ca1c",
+  "version": "1.7.0-rc2"
 }

mlrun/utils/version/version.py

@@ -14,15 +14,11 @@
 #
 import json
 import sys
+from importlib.resources import read_text
 
 import mlrun.utils
 from mlrun.utils.singleton import Singleton
 
-if sys.version_info >= (3, 7):
-    from importlib.resources import read_text
-else:
-    from importlib_resources import read_text
-
 
 class _VersionInfo:
     def __init__(self, major, minor, patch):
@@ -56,5 +52,5 @@ class Version(metaclass=Singleton):
         return self.python_version
 
     @staticmethod
-    def _resolve_python_version() -> sys.version_info:
+    def _resolve_python_version() -> _VersionInfo:
         return _VersionInfo(*sys.version_info[:3])

{mlrun-1.6.0rc35.dist-info → mlrun-1.7.0rc2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mlrun
-Version: 1.6.0rc35
+Version: 1.7.0rc2
 Summary: Tracking and config of machine learning runs
 Home-page: https://github.com/mlrun/mlrun
 Author: Yaron Haviv
@@ -29,14 +29,14 @@ Requires-Dist: click ~=8.1
 Requires-Dist: kfp ~=1.8
 Requires-Dist: nest-asyncio ~=1.0
 Requires-Dist: ipython ~=8.10
-Requires-Dist: nuclio-jupyter ~=0.9.15
+Requires-Dist: nuclio-jupyter ~=0.9.16
 Requires-Dist: numpy <1.27.0,>=1.16.5
 Requires-Dist: pandas <2.2,>=1.2
 Requires-Dist: pyarrow <15,>=10.0
 Requires-Dist: pyyaml ~=5.1
 Requires-Dist: requests ~=2.31
 Requires-Dist: tabulate ~=0.8.6
-Requires-Dist: v3io ~=0.5.21
+Requires-Dist: v3io ~=0.6.2
 Requires-Dist: pydantic >=1.10.8,~=1.10
 Requires-Dist: mergedeep ~=1.3
 Requires-Dist: v3io-frames ~=0.10.12
@@ -44,7 +44,7 @@ Requires-Dist: semver ~=3.0
 Requires-Dist: dependency-injector ~=4.41
 Requires-Dist: fsspec ==2023.9.2
 Requires-Dist: v3iofs ~=0.1.17
-Requires-Dist: storey ~=1.6.18
+Requires-Dist: storey ~=1.7.3
 Requires-Dist: inflection ~=0.5.0
 Requires-Dist: python-dotenv ~=0.17.0
 Requires-Dist: setuptools ~=68.2
@@ -222,7 +222,7 @@ In MLRun the assets, metadata, and services (data, functions, jobs, artifacts, m
 Projects can be imported/exported as a whole, mapped to git repositories or IDE projects (in PyCharm, VSCode, etc.), which enables versioning, collaboration, and CI/CD. 
 Project access can be restricted to a set of users and roles. 
 
-See: **Docs:** [Projects and Automation](https://docs.mlrun.org/en/latest/projects/project.html), [CI/CD Integration](https://docs.mlrun.org/en/latest/projects/ci-integration.html), **Tutorials:** [Quick start](https://docs.mlrun.org/en/latest/tutorials/01-mlrun-basics.html), [Automated ML Pipeline](https://docs.mlrun.org/en/latest/tutorials/04-pipeline.html), **Video:** [quick start](https://youtu.be/xI8KVGLlj7Q).
+See: **Docs:** [Projects and Automation](https://docs.mlrun.org/en/latest/projects/project.html), [CI/CD Integration](https://docs.mlrun.org/en/latest/projects/ci-integration.html), **Tutorials:** [Quick start](https://docs.mlrun.org/en/latest/tutorials/01-mlrun-basics.html), [Automated ML Pipeline](https://docs.mlrun.org/en/latest/tutorials/04-pipeline.html), **Video:** [Quick start](https://youtu.be/xI8KVGLlj7Q).
 
 ### Ingest and process data
 
@@ -235,13 +235,13 @@ See: **Docs:** [Ingest and process data](https://docs.mlrun.org/en/latest/data-p
 
 MLRun allows you to easily build ML pipelines that take data from various sources or the Feature Store and process it, train models at scale with multiple parameters, test models, tracks each experiments, register, version and deploy models, etc. MLRun provides scalable built-in or custom model training services, integrate with any framework and can work with 3rd party training/auto-ML services. You can also bring your own pre-trained model and use it in the pipeline.
 
-See: **Docs:** [Develop and train models](https://docs.mlrun.org/en/latest/development/index.html), [Model Training and Tracking](https://docs.mlrun.org/en/latest/development/model-training-tracking.html), [Batch Runs and Workflows](https://docs.mlrun.org/en/latest/concepts/runs-workflows.html); **Tutorials:** [Train & Eval Models](https://docs.mlrun.org/en/latest/tutorials/02-model-training.html), [Automated ML Pipeline](https://docs.mlrun.org/en/latest/tutorials/04-pipeline.html); **Video:** [Training models](https://youtu.be/bZgBsmLMdQo).
+See: **Docs:** [Develop and train models](https://docs.mlrun.org/en/latest/development/index.html), [Model Training and Tracking](https://docs.mlrun.org/en/latest/development/model-training-tracking.html), [Batch Runs and Workflows](https://docs.mlrun.org/en/latest/concepts/runs-workflows.html); **Tutorials:** [Train, compare, and register models](https://docs.mlrun.org/en/latest/tutorials/02-model-training.html), [Automated ML Pipeline](https://docs.mlrun.org/en/latest/tutorials/04-pipeline.html); **Video:** [Train and compare models](https://youtu.be/bZgBsmLMdQo).
 
 ### Deploy models and applications
 
 MLRun rapidly deploys and manages production-grade real-time or batch application pipelines using elastic and resilient serverless functions. MLRun addresses the entire ML application: intercepting application/user requests, running data processing tasks, inferencing using one or more models, driving actions, and integrating with the application logic.
 
-See: **Docs:** [Deploy models and applications](https://docs.mlrun.org/en/latest/deployment/index.html), [Realtime Pipelines](https://docs.mlrun.org/en/latest/serving/serving-graph.html), [Batch Inference](https://docs.mlrun.org/en/latest/concepts/TBD.html), **Tutorials:** [Realtime Serving](https://docs.mlrun.org/en/latest/tutorials/03-model-serving.html), [Batch Inference](https://docs.mlrun.org/en/latest/tutorials/07-batch-infer.html), [Advanced Pipeline](https://docs.mlrun.org/en/latest/tutorials/07-batch-infer.html); **Video:** [Serving models](https://youtu.be/OUjOus4dZfw).
+See: **Docs:** [Deploy models and applications](https://docs.mlrun.org/en/latest/deployment/index.html), [Realtime Pipelines](https://docs.mlrun.org/en/latest/serving/serving-graph.html), [Batch Inference](https://docs.mlrun.org/en/latest/deployment/batch_inference.html), **Tutorials:** [Realtime Serving](https://docs.mlrun.org/en/latest/tutorials/03-model-serving.html), [Batch Inference](https://docs.mlrun.org/en/latest/tutorials/07-batch-infer.html), [Advanced Pipeline](https://docs.mlrun.org/en/latest/tutorials/07-batch-infer.html); **Video:** [Serving pre-trained models](https://youtu.be/OUjOus4dZfw).
 
 ### Monitor and alert
 
@@ -259,9 +259,9 @@ MLRun includes the following major components:
 
 [**Project Management:**](https://docs.mlrun.org/en/latest/projects/project.html) A service (API, SDK, DB, UI) that manages the different project assets (data, functions, jobs, workflows, secrets, etc.) and provides central control and metadata layer.  
 
-[**Serverless Functions:**](https://docs.mlrun.org/en/latest/runtimes/functions.html) automatically deployed software package with one or more methods and runtime-specific attributes (such as image, libraries, command, arguments, resources, etc.).
+[**Functions:**](https://docs.mlrun.org/en/latest/runtimes/functions.html) automatically deployed software package with one or more methods and runtime-specific attributes (such as image, libraries, command, arguments, resources, etc.).
 
-[**Data & Artifacts:**](https://docs.mlrun.org/en/latest/concepts/data-feature-store.html) Glueless connectivity to various data sources, metadata management, catalog, and versioning for structures/unstructured artifacts.
+[**Data & Artifacts:**](https://docs.mlrun.org/en/latest/concepts/data.html) Glueless connectivity to various data sources, metadata management, catalog, and versioning for structures/unstructured artifacts.
 
 [**Feature Store:**](https://docs.mlrun.org/en/latest/feature-store/feature-store.html) automatically collects, prepares, catalogs, and serves production data features for development (offline) and real-time (online) deployment using minimal engineering effort.