iker-python-common 1.0.65__tar.gz → 1.0.66__tar.gz

{iker_python_common-1.0.65 → iker_python_common-1.0.66}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iker-python-common
-Version: 1.0.65
+Version: 1.0.66
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13

{iker_python_common-1.0.65 → iker_python_common-1.0.66}/src/iker/common/utils/config.py

@@ -31,7 +31,7 @@ class Config(object):
             self.config_parser.read(self.config_path, encoding="utf-8")
             return True
         except IOError as e:
-            logger.exception("Failed to restore config from file <%s>", self.config_path)
+            logger.exception("Failed to restore config from file '%s'", self.config_path)
         return False
 
     def persist(self) -> bool:
@@ -42,7 +42,7 @@ class Config(object):
                 self.config_parser.write(fh)
             return True
         except IOError as e:
-            logger.exception("Failed to persist config to file <%s>", self.config_path)
+            logger.exception("Failed to persist config to file '%s'", self.config_path)
         return False
 
     def has_section(self, section: str) -> bool:

{iker_python_common-1.0.65 → iker_python_common-1.0.66}/src/iker/common/utils/retry.py

@@ -1,9 +1,11 @@
 import abc
-import random
 import time
+from collections.abc import Callable
+from typing import Any
 
 from iker.common.utils import logger
 from iker.common.utils.dtutils import dt_utc_now
+from iker.common.utils.randutils import randomizer
 
 __all__ = [
     "Attempt",
@@ -68,12 +70,9 @@ class Retry(abc.ABC):
 class RetryWrapper(object):
     def __init__(
         self,
-        cls,
+        target: Callable[..., Any] | Retry,
         wait: int = None,
-        wait_exponent_init: int = None,
-        wait_exponent_max: int = None,
-        wait_random_min: int = None,
-        wait_random_max: int = None,
+        wait_func: Callable[[int], int] = None,
         retrials: int = None,
         timeout: int = None,
     ):
@@ -81,21 +80,15 @@ class RetryWrapper(object):
         Retry executor that wraps a callable or ``Retry`` instance, providing flexible retry strategies including fixed,
         exponential, and random waits.
 
-        :param cls: The target callable or ``Retry`` instance to execute.
+        :param target: The target callable or ``Retry`` instance to execute.
         :param wait: Fixed wait time (in seconds) between retrials.
-        :param wait_exponent_init: Initial wait time for exponential backoff.
-        :param wait_exponent_max: Maximum wait time for exponential backoff.
-        :param wait_random_min: Minimum wait time for random backoff.
-        :param wait_random_max: Maximum wait time for random backoff.
+        :param wait_func: Function to determine wait time based on attempt number.
         :param retrials: Maximum number of retrials (``None`` for unlimited).
         :param timeout: Maximum total time (in seconds) allowed for all attempts (``None`` for unlimited).
         """
-        self.__wrapped = cls
+        self.target = target
         self.wait = wait
-        self.wait_exponent_init = wait_exponent_init
-        self.wait_exponent_max = wait_exponent_max
-        self.wait_random_min = wait_random_min
-        self.wait_random_max = wait_random_max
+        self.wait_func = wait_func
         self.retrials = retrials
         self.timeout = timeout
 
@@ -107,9 +100,9 @@ class RetryWrapper(object):
         :param kwargs: Keyword arguments for the operation.
         :return: The result of the operation.
         """
-        return self.__run(*args, **kwargs)
+        return self.run(*args, **kwargs)
 
-    def __next_wait(self, attempt_number: int):
+    def next_wait(self, attempt_number: int):
         """
         Determines the wait time before the next retry attempt based on the configured strategy.
 
@@ -118,16 +111,13 @@ class RetryWrapper(object):
         """
         if attempt_number <= 0:
             return None
-        elif self.wait is not None:
+        if self.wait is not None:
             return self.wait
-        elif self.wait_exponent_init is not None and self.wait_exponent_max is not None:
-            return min(self.wait_exponent_init * (2 ** (attempt_number - 1)), self.wait_exponent_max)
-        elif self.wait_random_min is not None and self.wait_random_max is not None:
-            return random.randint(self.wait_random_min, self.wait_random_max)
-        else:
-            return 0
+        if self.wait_func is not None:
+            return self.wait_func(attempt_number)
+        return 0
 
-    def __check_timeout(self, start_ts: float) -> tuple[bool, float]:
+    def check_timeout(self, start_ts: float) -> tuple[bool, float]:
         """
         Checks if the retry operation has exceeded the configured timeout.
 
@@ -139,7 +129,7 @@ class RetryWrapper(object):
             return True, current_ts
         return current_ts < start_ts + self.timeout, current_ts
 
-    def __run(self, *args, **kwargs):
+    def run(self, *args, **kwargs):
         """
         Runs the retry loop, invoking the wrapped callable or ``Retry`` instance until success, retrials exhausted, or
         timeout reached.
@@ -156,31 +146,30 @@ class RetryWrapper(object):
         while self.retrials is None or attempt_number <= self.retrials:
             attempt_number += 1
 
-            check_result, check_ts = self.__check_timeout(start_ts)
+            check_result, check_ts = self.check_timeout(start_ts)
             if not check_result:
                 break
 
             attempt = Attempt(
                 attempt_number,
-                self.__next_wait(attempt_number - 1),
-                self.__next_wait(attempt_number),
+                self.next_wait(attempt_number - 1),
+                self.next_wait(attempt_number),
                 start_ts,
                 check_ts,
                 last_exception,
             )
             try:
-                if isinstance(self.__wrapped, Retry):
-                    self.__wrapped.on_attempt(attempt)
-                    return self.__wrapped.execute(*args, **kwargs)
+                if isinstance(self.target, Retry):
+                    self.target.on_attempt(attempt)
+                    return self.target.execute(*args, **kwargs)
                 else:
-                    return self.__wrapped(*args, **kwargs)
+                    return self.target(*args, **kwargs)
             except Exception as e:
-                logger.exception("Function target <%s> failed on attempt <%d>", self.__wrapped, attempt_number)
+                logger.exception("Function target '%s' failed on attempt '%d'", self.target, attempt_number)
                 last_exception = e
-                time.sleep(self.__next_wait(attempt_number))
+                time.sleep(self.next_wait(attempt_number))
 
-        raise RuntimeError(
-            "failed to execute function target <%s> after <%d> attempts" % (self.__wrapped, attempt_number))
+        raise RuntimeError(f"failed to execute function target '{self.target}' after '{attempt_number}' attempts")
 
 
 def retry(wait: int = None, retrials: int = None, timeout: int = None):
@@ -199,12 +188,12 @@ def retry(wait: int = None, retrials: int = None, timeout: int = None):
     return wrapper
 
 
-def retry_exponent(wait_exponent_init: int, wait_exponent_max: int, retrials: int = None, timeout: int = None):
+def retry_exponent(wait_init: int, wait_max: int, retrials: int = None, timeout: int = None):
     """
     Decorator to apply exponential backoff retry logic to a function or callable.
 
-    :param wait_exponent_init: Initial wait time for exponential backoff.
-    :param wait_exponent_max: Maximum wait time for exponential backoff.
+    :param wait_init: Initial wait time for exponential backoff.
+    :param wait_max: Maximum wait time for exponential backoff.
     :param retrials: Maximum number of retrials (``None`` for unlimited).
     :param timeout: Maximum total time (in seconds) allowed for all attempts (``None`` for unlimited).
     :return: A decorated function with retry logic.
@@ -213,8 +202,7 @@ def retry_exponent(wait_exponent_init: int, wait_exponent_max: int, retrials: in
     def wrapper(target):
         return RetryWrapper(
             target,
-            wait_exponent_init=wait_exponent_init,
-            wait_exponent_max=wait_exponent_max,
+            wait_func=lambda x: min(wait_init * (2 ** (x - 1)), wait_max),
             retrials=retrials,
             timeout=timeout,
         )
@@ -222,12 +210,12 @@ def retry_exponent(wait_exponent_init: int, wait_exponent_max: int, retrials: in
     return wrapper
 
 
-def retry_random(wait_random_min: int, wait_random_max: int, retrials: int = None, timeout: int = None):
+def retry_random(wait_min: int, wait_max: int, retrials: int = None, timeout: int = None):
     """
     Decorator to apply random wait retry logic to a function or callable.
 
-    :param wait_random_min: Minimum wait time for random backoff.
-    :param wait_random_max: Maximum wait time for random backoff.
+    :param wait_min: Minimum wait time for random backoff.
+    :param wait_max: Maximum wait time for random backoff.
     :param retrials: Maximum number of retrials (``None`` for unlimited).
     :param timeout: Maximum total time (in seconds) allowed for all attempts (``None`` for unlimited).
     :return: A decorated function with retry logic.
@@ -236,8 +224,7 @@ def retry_random(wait_random_min: int, wait_random_max: int, retrials: int = Non
     def wrapper(target):
         return RetryWrapper(
             target,
-            wait_random_min=wait_random_min,
-            wait_random_max=wait_random_max,
+            wait_func=lambda x: randomizer().next_int(wait_min, wait_max),
             retrials=retrials,
             timeout=timeout,
         )

{iker_python_common-1.0.65 → iker_python_common-1.0.66}/src/iker/common/utils/shutils.py

@@ -3,7 +3,6 @@ import os
 import shutil
 from typing import Protocol
 
-from iker.common.utils import logger
 from iker.common.utils.iterutils import last, last_or_none, tail_iter
 from iker.common.utils.strutils import is_empty
 
@@ -212,7 +211,6 @@ def run(cmd: str) -> bool:
     :param cmd: Command to run.
     :return: ``True`` if the command has been successfully run, ``False`` otherwise.
     """
-    logger.debug("Running command: %s", cmd)
     return os.system(cmd) == 0
 
 
@@ -224,7 +222,6 @@ def execute(cmd: str, strip: bool = True) -> str:
     :param strip: If ``True``, the contents will be stripped.
     :return: The content from standard output.
     """
-    logger.debug("Executing command: %s", cmd)
     if strip:
         return os.popen(cmd).read().strip()
     return os.popen(cmd).read()

{iker_python_common-1.0.65 → iker_python_common-1.0.66}/src/iker_python_common.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iker-python-common
-Version: 1.0.65
+Version: 1.0.66
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13

{iker_python_common-1.0.65 → iker_python_common-1.0.66}/test/iker_tests/common/utils/retry_test.py

@@ -125,11 +125,10 @@ class RetryTest(unittest.TestCase):
 
     @ddt.idata(data_retry_exponent)
     @ddt.unpack
-    def test_retry_exponent(self, content, wait_exponent_init, wait_exponent_max, retrials):
+    def test_retry_exponent(self, content, wait_init, wait_max, retrials):
         result = []
 
-        @retry.retry_exponent(wait_exponent_init=wait_exponent_init, wait_exponent_max=wait_exponent_max,
-                              retrials=retrials)
+        @retry.retry_exponent(wait_init=wait_init, wait_max=wait_max, retrials=retrials)
         def callee(text):
             result.append(text)
             raise ValueError("dummy value error")
@@ -147,7 +146,7 @@ class RetryTest(unittest.TestCase):
 
     @ddt.idata(data_retry_exponent__on_retry_instance)
     @ddt.unpack
-    def test_retry_exponent__on_retry_instance(self, content, wait_exponent_init, wait_exponent_max, retrials):
+    def test_retry_exponent__on_retry_instance(self, content, wait_init, wait_max, retrials):
         result = []
 
         class Callee(retry.Retry):
@@ -164,11 +163,10 @@ class RetryTest(unittest.TestCase):
         callee = Callee()
 
         with self.assertRaises(RuntimeError):
-            retry.retry_exponent(wait_exponent_init, wait_exponent_max, retrials)(callee)(content)
+            retry.retry_exponent(wait_init, wait_max, retrials)(callee)(content)
 
         self.assertEqual([content for _ in range(retrials + 1)], result)
-        self.assertTrue(all(
-            a.next_wait == min(wait_exponent_init * (2 ** (a.number - 1)), wait_exponent_max) for a in callee.attempts))
+        self.assertTrue(all(a.next_wait == min(wait_init * (2 ** (a.number - 1)), wait_max) for a in callee.attempts))
 
     data_retry_random = [
         ("dummy-content", 1, 4, 3),
@@ -178,10 +176,10 @@ class RetryTest(unittest.TestCase):
 
     @ddt.idata(data_retry_random)
     @ddt.unpack
-    def test_retry_random(self, content, wait_random_min, wait_random_max, retrials):
+    def test_retry_random(self, content, wait_min, wait_max, retrials):
         result = []
 
-        @retry.retry_random(wait_random_min=wait_random_min, wait_random_max=wait_random_max, retrials=retrials)
+        @retry.retry_random(wait_min=wait_min, wait_max=wait_max, retrials=retrials)
         def callee(text):
             result.append(text)
             raise ValueError("dummy value error")
@@ -199,7 +197,7 @@ class RetryTest(unittest.TestCase):
 
     @ddt.idata(data_retry_random__on_retry_instance)
     @ddt.unpack
-    def test_retry_random__on_retry_instance(self, content, wait_random_min, wait_random_max, retrials):
+    def test_retry_random__on_retry_instance(self, content, wait_min, wait_max, retrials):
         result = []
 
         class Callee(retry.Retry):
@@ -216,7 +214,7 @@ class RetryTest(unittest.TestCase):
         callee = Callee()
 
         with self.assertRaises(RuntimeError):
-            retry.retry_random(wait_random_min, wait_random_max, retrials)(callee)(content)
+            retry.retry_random(wait_min, wait_max, retrials)(callee)(content)
 
         self.assertEqual([content for _ in range(retrials + 1)], result)
-        self.assertTrue(all(wait_random_min <= a.next_wait <= wait_random_max for a in callee.attempts))
+        self.assertTrue(all(wait_min <= a.next_wait <= wait_max for a in callee.attempts))