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

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

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

{iker_python_common-1.0.65/resources/unittest/csv → iker_python_common-1.0.67/resources/unittest/csvutils}/data.csv

@@ -1,6 +1,6 @@
 dummy_str,dummy_bool,dummy_int,dummy_float,dummy_datetime,dummy_params
 foo,True,1,1.0,2020-01-01T00:00:00,
-bar,False,-1,-1.0,2020-01-01T00:00:00,key_1=value_1;key_2;!key_3
+bar,False,-1,-1.0,2020-01-01T00:00:00,"key_1=value_1,key_2,!key_3"
 baz,\N,100,inf,2020-01-01T00:00:00,\N
 ,\N,-100,-inf,2020-01-01T00:00:00,
 \N,\N,0,nan,2020-01-01T00:00:00,\N

{iker_python_common-1.0.65/resources/unittest/csv → iker_python_common-1.0.67/resources/unittest/csvutils}/data.tsv

@@ -1,6 +1,6 @@
 dummy_str	dummy_bool	dummy_int	dummy_float	dummy_datetime	dummy_params
 foo	True	1	1.0	2020-01-01T00:00:00	
-bar	False	-1	-1.0	2020-01-01T00:00:00	key_1:value_1#key_2#-key_3
+bar	False	-1	-1.0	2020-01-01T00:00:00	key_1:value_1;key_2;-key_3
 baz	<null>	100	inf	2020-01-01T00:00:00	<null>
 	<null>	-100	-inf	2020-01-01T00:00:00	
 <null>	<null>	0	nan	2020-01-01T00:00:00	<null>

{iker_python_common-1.0.65 → iker_python_common-1.0.67}/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/src/iker/common/utils/csv.py → iker_python_common-1.0.67/src/iker/common/utils/csvutils.py

@@ -1,3 +1,4 @@
+import csv
 import os
 from collections.abc import Callable, Generator, Iterable, Mapping, Sequence
 from typing import Any
@@ -41,19 +42,31 @@ class CSVView(object):
     files, with options for headers and dictionary or list output.
 
     :param schema: The sequence of ``CSVColumn`` objects defining the schema.
-    :param row_delim: The delimiter for rows (default is ``'\n'``).
-    :param col_delim: The delimiter for columns (default is ``','``).
+    :param column_delimiter: The delimiter used to separate columns in the CSV (default: ",").
+    :param line_terminator: The string used to terminate lines in the CSV (default: "\n").
+    :param quote_char: The character used to quote fields in the CSV (default: '"').
+    :param strict: Whether to raise an error on malformed CSV (default: ``True``).
     """
 
-    def __init__(self, schema: Sequence[CSVColumn], *, row_delim: str = "\n", col_delim: str = ","):
+    def __init__(
+        self,
+        schema: Sequence[CSVColumn],
+        *,
+        column_delimiter: str = ",",
+        line_terminator: str = "\n",
+        quote_char: str = '"',
+        strict: bool = True,
+    ):
         self.schema = schema
-        self.row_delim = row_delim
-        self.col_delim = col_delim
+        self.column_delimiter = column_delimiter
+        self.line_terminator = line_terminator
+        self.quote_char = quote_char
+        self.strict = strict
 
     @overload
     def load_lines(
         self,
-        lines: Iterable[str],
+        lines: Iterable[Sequence[str]],
         has_header: bool,
         ret_dict: False = False,
     ) -> Generator[list[Any], None, None]:
@@ -62,7 +75,7 @@ class CSVView(object):
     @overload
     def load_lines(
         self,
-        lines: Iterable[str],
+        lines: Iterable[Sequence[str]],
         ret_dict: False = False,
     ) -> Generator[list[Any], None, None]:
         ...
@@ -70,7 +83,7 @@ class CSVView(object):
     @overload
     def load_lines(
         self,
-        lines: Iterable[str],
+        lines: Iterable[Sequence[str]],
         has_header: bool,
         ret_dict: True = True,
     ) -> Generator[dict[str, Any], None, None]:
@@ -79,14 +92,14 @@ class CSVView(object):
     @overload
     def load_lines(
         self,
-        lines: Iterable[str],
+        lines: Iterable[Sequence[str]],
         ret_dict: True = True,
     ) -> Generator[dict[str, Any], None, None]:
         ...
 
     def load_lines(
         self,
-        lines: Iterable[str],
+        lines: Iterable[Sequence[str]],
         has_header: bool = True,
         ret_dict: bool = False,
     ) -> Generator[list[Any] | dict[str, Any], None, None]:
@@ -101,15 +114,13 @@ class CSVView(object):
         """
         rows_iter = iter(lines)
         if has_header:
-            header_row = next(rows_iter)
-            header_cols = header_row.split(self.col_delim)
+            header_cols = next(rows_iter)
             if len(self.schema) != len(header_cols):
                 raise ValueError("size of the schema is not identical to size of the columns")
             for c, header_col in zip(self.schema, header_cols):
                 if c.name != header_col:
                     raise ValueError("name of the schema is not equal to the name of the columns")
-        for row in rows_iter:
-            cols = row.split(self.col_delim)
+        for cols in rows_iter:
             if len(self.schema) != len(cols):
                 continue
             if ret_dict:
@@ -121,7 +132,7 @@ class CSVView(object):
         self,
         data: Iterable[Sequence[Any] | Mapping[str, Any]],
         has_header: bool = True,
-    ) -> Generator[str, None, None]:
+    ) -> Generator[list[str], None, None]:
         """
         Dumps data to CSV lines according to the schema, optionally including a header row.
 
@@ -130,16 +141,14 @@ class CSVView(object):
         :return: A generator yielding CSV lines as strings.
         """
         if has_header:
-            yield self.col_delim.join(c.name for c in self.schema)
+            yield list(c.name for c in self.schema)
         for cols in data:
             if isinstance(cols, Sequence):
                 if len(self.schema) != len(cols):
                     raise ValueError("size of the schema is not identical to size of the columns")
-                yield self.col_delim.join(c.null_str if col is None else c.dumper(col)
-                                          for c, col in zip(self.schema, cols))
+                yield list(c.null_str if col is None else c.dumper(col) for c, col in zip(self.schema, cols))
             if isinstance(cols, Mapping):
-                yield self.col_delim.join(c.null_str if cols.get(c.name) is None else c.dumper(cols.get(c.name))
-                                          for c in self.schema)
+                yield list(c.null_str if cols.get(c.name) is None else c.dumper(cols.get(c.name)) for c in self.schema)
 
     @overload
     def load_file(
@@ -196,8 +205,12 @@ class CSVView(object):
         :return: A generator yielding each row as a list or dictionary.
         """
         with open(file_path, mode="r", **kwargs) as fh:
-            lines = fh.read().split(self.row_delim)
-            yield from self.load_lines(lines, has_header, ret_dict)
+            reader = csv.reader(fh,
+                                delimiter=self.column_delimiter,
+                                lineterminator=self.line_terminator,
+                                quotechar=self.quote_char,
+                                strict=self.strict)
+            yield from self.load_lines(reader, has_header, ret_dict)
 
     def dump_file(
         self,
@@ -215,9 +228,13 @@ class CSVView(object):
         :param kwargs: Additional keyword arguments for file opening.
         """
         with open(file_path, mode="w", **kwargs) as fh:
+            writer = csv.writer(fh,
+                                delimiter=self.column_delimiter,
+                                lineterminator=self.line_terminator,
+                                quotechar=self.quote_char,
+                                strict=self.strict)
             for line in self.dump_lines(data, has_header):
-                fh.write(line)
-                fh.write(self.row_delim)
+                writer.writerow(line)
 
 
 column = CSVColumn

{iker_python_common-1.0.65 → iker_python_common-1.0.67}/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.67}/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.67}/src/iker/common/utils/span.py

@@ -1,9 +1,13 @@
 import enum
 import itertools
-from collections.abc import Sequence
+from collections.abc import Iterator, Sequence
+from typing import Protocol, Self
 
 __all__ = [
     "SpanRelation",
+    "SpanEndpoint",
+    "Span",
+    "span",
     "span_relation",
     "spans_union",
     "spans_intersect",
@@ -40,7 +44,39 @@ class SpanRelation(enum.IntEnum):
     RightDetach = LeftRightOut | RightRightOut
 
 
-def span_relation(a: tuple[float, float], b: tuple[float, float]) -> int:
+class SpanEndpoint(Protocol):
+    def __lt__(self, other: Self) -> bool: ...
+
+    def __sub__(self, other: Self) -> Self: ...
+
+
+class Span[T: SpanEndpoint]:
+    def __init__(self, lo: T, hi: T):
+        self.lo = lo
+        self.hi = hi
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Span):
+            return NotImplemented
+        return self.lo == other.lo and self.hi == other.hi
+
+    def __lt__(self, other: Self) -> bool:
+        if not isinstance(other, Span):
+            return NotImplemented
+        if self.lo == other.lo:
+            return self.hi < other.hi
+        return self.lo < other.lo
+
+    def __iter__(self) -> Iterator[T]:
+        yield self.lo
+        yield self.hi
+
+    @property
+    def distance(self) -> T:
+        return self.hi - self.lo
+
+
+def span_relation[T: SpanEndpoint](a: Span[T], b: Span[T]) -> int:
     (a0, a1), (b0, b1) = a, b
     rel = 0
     if a0 < b0:
@@ -66,7 +102,10 @@ def span_relation(a: tuple[float, float], b: tuple[float, float]) -> int:
     return rel
 
 
-def spans_union[T](a: Sequence[tuple[T, T]], *bs: Sequence[tuple[T, T]]) -> list[tuple[T, T]]:
+span = Span
+
+
+def spans_union[T: SpanEndpoint](a: Sequence[Span[T]], *bs: Sequence[Span[T]]) -> list[Span[T]]:
     """
     Computes the union of the given span lists. The spans in each of the lists must be sorted and must not
     mutually overlap.
@@ -76,11 +115,11 @@ def spans_union[T](a: Sequence[tuple[T, T]], *bs: Sequence[tuple[T, T]]) -> list
     :return: The union of the span lists, with spans sorted and merged where possible.
     """
 
-    def union(xs: Sequence[tuple[T, T]], ys: Sequence[tuple[T, T]]) -> list[tuple[T, T]]:
+    def union(xs: Sequence[Span[T]], ys: Sequence[Span[T]]) -> list[Span[T]]:
         if not xs or not ys:
             return list(itertools.chain(xs, ys))
 
-        result: list[tuple[T, T]] = []
+        result: list[Span[T]] = []
 
         i, j = 0, 0
         x0_lo, _ = xs[i]
@@ -106,12 +145,12 @@ def spans_union[T](a: Sequence[tuple[T, T]], *bs: Sequence[tuple[T, T]]) -> list
             curr_lo, curr_hi = curr
 
             if hi < curr_lo:
-                result.append((lo, hi))
+                result.append(Span(lo, hi))
                 lo, hi = curr
             else:
                 hi = max(hi, curr_hi)
 
-        result.append((lo, hi))
+        result.append(Span(lo, hi))
 
         return result
 
@@ -120,7 +159,7 @@ def spans_union[T](a: Sequence[tuple[T, T]], *bs: Sequence[tuple[T, T]]) -> list
     return a
 
 
-def spans_intersect[T](a: Sequence[tuple[T, T]], *bs: Sequence[tuple[T, T]]) -> list[tuple[T, T]]:
+def spans_intersect[T: SpanEndpoint](a: Sequence[Span[T]], *bs: Sequence[Span[T]]) -> list[Span[T]]:
     """
     Computes the intersection of the given span lists. The spans in each of the lists must be sorted and must not
     mutually overlap.
@@ -130,11 +169,11 @@ def spans_intersect[T](a: Sequence[tuple[T, T]], *bs: Sequence[tuple[T, T]]) ->
     :return: The intersection of the span lists, with spans sorted.
     """
 
-    def intersect(xs: Sequence[tuple[T, T]], ys: Sequence[tuple[T, T]]) -> list[tuple[T, T]]:
+    def intersect(xs: Sequence[Span[T]], ys: Sequence[Span[T]]) -> list[Span[T]]:
         if not xs or not ys:
             return []
 
-        result: list[tuple[T, T]] = []
+        result: list[Span[T]] = []
 
         i, j = 0, 0
         while i < len(xs) and j < len(ys):
@@ -144,7 +183,7 @@ def spans_intersect[T](a: Sequence[tuple[T, T]], *bs: Sequence[tuple[T, T]]) ->
             hi = min(x_hi, y_hi)
 
             if not hi < lo:
-                result.append((lo, hi))
+                result.append(Span(lo, hi))
 
             if x_hi < y_hi:
                 i += 1
@@ -158,7 +197,7 @@ def spans_intersect[T](a: Sequence[tuple[T, T]], *bs: Sequence[tuple[T, T]]) ->
     return a
 
 
-def spans_subtract[T](a: Sequence[tuple[T, T]], *bs: Sequence[tuple[T, T]]) -> list[tuple[T, T]]:
+def spans_subtract[T: SpanEndpoint](a: Sequence[Span[T]], *bs: Sequence[Span[T]]) -> list[Span[T]]:
     """
     Computes the subtraction on the first span list by the remaining span lists. The spans in each of the lists must be
     sorted and must not mutually overlap.
@@ -168,11 +207,11 @@ def spans_subtract[T](a: Sequence[tuple[T, T]], *bs: Sequence[tuple[T, T]]) -> l
     :return: The subtraction of the first span list by the remaining span lists, with spans sorted.
     """
 
-    def subtract(xs: Sequence[tuple[T, T]], ys: Sequence[tuple[T, T]]) -> list[tuple[T, T]]:
+    def subtract(xs: Sequence[Span[T]], ys: Sequence[Span[T]]) -> list[Span[T]]:
         if not xs or not ys:
             return list(xs)
 
-        result: list[tuple[T, T]] = []
+        result: list[Span[T]] = []
 
         i, j = 0, 0
         curr = xs[i]
@@ -184,9 +223,9 @@ def spans_subtract[T](a: Sequence[tuple[T, T]], *bs: Sequence[tuple[T, T]]) -> l
 
             if not lo > hi:
                 if curr_lo < lo:
-                    result.append((curr_lo, lo))
+                    result.append(Span(curr_lo, lo))
                 if hi < curr_hi:
-                    curr = hi, curr_hi
+                    curr = Span(hi, curr_hi)
                 else:
                     curr = None
             elif curr_hi < y_lo:

{iker_python_common-1.0.65 → iker_python_common-1.0.67}/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.67
 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.67}/src/iker_python_common.egg-info/SOURCES.txt

@@ -8,8 +8,8 @@ setup.py
 .github/workflows/pr.yml
 .github/workflows/push.yml
 resources/unittest/config/config.cfg
-resources/unittest/csv/data.csv
-resources/unittest/csv/data.tsv
+resources/unittest/csvutils/data.csv
+resources/unittest/csvutils/data.tsv
 resources/unittest/shutils/dir.baz/file.bar.baz
 resources/unittest/shutils/dir.baz/file.foo.bar
 resources/unittest/shutils/dir.baz/file.foo.baz
@@ -24,7 +24,7 @@ src/iker/common/__init__.py
 src/iker/common/utils/__init__.py
 src/iker/common/utils/argutils.py
 src/iker/common/utils/config.py
-src/iker/common/utils/csv.py
+src/iker/common/utils/csvutils.py
 src/iker/common/utils/dbutils.py
 src/iker/common/utils/dtutils.py
 src/iker/common/utils/funcutils.py
@@ -45,11 +45,13 @@ src/iker_python_common.egg-info/dependency_links.txt
 src/iker_python_common.egg-info/not-zip-safe
 src/iker_python_common.egg-info/requires.txt
 src/iker_python_common.egg-info/top_level.txt
-test/iker_test.py
+test/testenv.py
 test/iker_tests/__init__.py
+test/iker_tests/common/__init__.py
+test/iker_tests/common/utils/__init__.py
 test/iker_tests/common/utils/argutils_test.py
 test/iker_tests/common/utils/config_test.py
-test/iker_tests/common/utils/csv_test.py
+test/iker_tests/common/utils/csvutils_test.py
 test/iker_tests/common/utils/dbutils_test.py
 test/iker_tests/common/utils/dtutils_test.py
 test/iker_tests/common/utils/funcutils_test.py

{iker_python_common-1.0.65 → iker_python_common-1.0.67}/test/iker_tests/common/utils/config_test.py

@@ -4,7 +4,7 @@ import unittest
 import ddt
 
 from iker.common.utils.config import Config, ConfigVisitor
-from iker_tests import resources_directory
+from testenv import resources_directory
 
 
 @ddt.ddt

iker_python_common-1.0.65/test/iker_tests/common/utils/csv_test.py → iker_python_common-1.0.67/test/iker_tests/common/utils/csvutils_test.py

@@ -1,4 +1,3 @@
-import datetime
 import itertools
 import math
 import os.path
@@ -6,12 +5,12 @@ import unittest
 
 import ddt
 
-from iker.common.utils import csv
-from iker.common.utils.dtutils import dt_format_iso, dt_parse_iso
+from iker.common.utils import csvutils as csv
+from iker.common.utils.dtutils import dt_format_iso, dt_from_ts, dt_parse_iso, dt_to_ts
 from iker.common.utils.jsonutils import json_compare
 from iker.common.utils.strutils import make_params_string, parse_params_string
 from iker.common.utils.strutils import parse_bool
-from iker_tests import resources_directory
+from testenv import resources_directory
 
 
 @ddt.ddt
@@ -25,8 +24,8 @@ class CSVTest(unittest.TestCase):
                 csv.column("dummy_int", loader=int, dumper=str, null_str=r"\N"),
                 csv.column("dummy_float", loader=float, dumper=str, null_str=r"\N"),
                 csv.column("dummy_datetime",
-                           loader=lambda x: dt_parse_iso(x).timestamp(),
-                           dumper=lambda x: dt_format_iso(datetime.datetime.fromtimestamp(x, tz=datetime.timezone.utc)),
+                           loader=lambda x: dt_to_ts(dt_parse_iso(x)),
+                           dumper=lambda x: dt_format_iso(dt_from_ts(x)),
                            null_str=r"\N"),
                 csv.column("dummy_params",
                            loader=lambda x: parse_params_string(x, delim=";", kv_delim="=", neg_prefix="!"),
@@ -36,22 +35,22 @@ class CSVTest(unittest.TestCase):
         )
 
         lines = [
-            r"dummy_str,dummy_bool,dummy_int,dummy_float,dummy_datetime,dummy_params",
-            r"foo,True,1,1.0,2020-01-01T00:00:00,",
-            r"bar,False,-1,-1.0,2020-01-01T00:00:00,key_1=value_1;key_2;!key_3",
-            r"baz,\N,100,inf,2020-01-01T00:00:00,\N",
-            r",\N,-100,-inf,2020-01-01T00:00:00,",
-            r"\N,\N,0,nan,2020-01-01T00:00:00,\N",
-            r"\N,\N,\N,\N,\N,\N",
+            ["dummy_str", "dummy_bool", "dummy_int", "dummy_float", "dummy_datetime", "dummy_params"],
+            ["foo", "True", "1", "1.0", "2020-01-01T00:00:00", ""],
+            ["bar", "False", "-1", "-1.0", "2020-01-01T00:00:00", "key_1=value_1;key_2;!key_3"],
+            ["baz", r"\N", "100", "inf", "2020-01-01T00:00:00", r"\N"],
+            ["", r"\N", "-100", "-inf", "2020-01-01T00:00:00", ""],
+            [r"\N", r"\N", "0", "nan", "2020-01-01T00:00:00", r"\N"],
+            [r"\N", r"\N", r"\N", r"\N", r"\N", r"\N"],
         ]
 
         lines_no_header = [
-            r"foo,True,1,1.0,2020-01-01T00:00:00,",
-            r"bar,False,-1,-1.0,2020-01-01T00:00:00,key_1=value_1;key_2;!key_3",
-            r"baz,\N,100,inf,2020-01-01T00:00:00,\N",
-            r",\N,-100,-inf,2020-01-01T00:00:00,",
-            r"\N,\N,0,nan,2020-01-01T00:00:00,\N",
-            r"\N,\N,\N,\N,\N,\N",
+            ["foo", "True", "1", "1.0", "2020-01-01T00:00:00", ""],
+            ["bar", "False", "-1", "-1.0", "2020-01-01T00:00:00", "key_1=value_1;key_2;!key_3"],
+            ["baz", r"\N", "100", "inf", "2020-01-01T00:00:00", r"\N"],
+            ["", r"\N", "-100", "-inf", "2020-01-01T00:00:00", ""],
+            [r"\N", r"\N", "0", "nan", "2020-01-01T00:00:00", r"\N"],
+            [r"\N", r"\N", r"\N", r"\N", r"\N", r"\N"],
         ]
 
         time = dt_parse_iso("2020-01-01T00:00:00").timestamp()
@@ -189,12 +188,12 @@ class CSVTest(unittest.TestCase):
                 csv.column("dummy_int", loader=int, dumper=str, null_str=r"\N"),
                 csv.column("dummy_float", loader=float, dumper=str, null_str=r"\N"),
                 csv.column("dummy_datetime",
-                           loader=lambda x: dt_parse_iso(x).timestamp(),
-                           dumper=lambda x: dt_format_iso(datetime.datetime.fromtimestamp(x, tz=datetime.timezone.utc)),
+                           loader=lambda x: dt_to_ts(dt_parse_iso(x)),
+                           dumper=lambda x: dt_format_iso(dt_from_ts(x)),
                            null_str=r"\N"),
                 csv.column("dummy_params",
-                           loader=lambda x: parse_params_string(x, delim=";", kv_delim="=", neg_prefix="!"),
-                           dumper=lambda x: make_params_string(x, delim=";", kv_delim="=", neg_prefix="!"),
+                           loader=lambda x: parse_params_string(x, delim=",", kv_delim="=", neg_prefix="!"),
+                           dumper=lambda x: make_params_string(x, delim=",", kv_delim="=", neg_prefix="!"),
                            null_str=r"\N"),
             ],
         )
@@ -206,15 +205,15 @@ class CSVTest(unittest.TestCase):
                 csv.column("dummy_int", loader=int, dumper=str, null_str=r"<null>"),
                 csv.column("dummy_float", loader=float, dumper=str, null_str=r"<null>"),
                 csv.column("dummy_datetime",
-                           loader=lambda x: dt_parse_iso(x).timestamp(),
-                           dumper=lambda x: dt_format_iso(datetime.datetime.fromtimestamp(x, tz=datetime.timezone.utc)),
+                           loader=lambda x: dt_to_ts(dt_parse_iso(x)),
+                           dumper=lambda x: dt_format_iso(dt_from_ts(x)),
                            null_str=r"<null>"),
                 csv.column("dummy_params",
-                           loader=lambda x: parse_params_string(x, delim="#", kv_delim=":", neg_prefix="-"),
-                           dumper=lambda x: make_params_string(x, delim="#", kv_delim=":", neg_prefix="-"),
+                           loader=lambda x: parse_params_string(x, delim=";", kv_delim=":", neg_prefix="-"),
+                           dumper=lambda x: make_params_string(x, delim=";", kv_delim=":", neg_prefix="-"),
                            null_str=r"<null>"),
             ],
-            col_delim="\t",
+            column_delimiter="\t",
         )
 
         time = dt_parse_iso("2020-01-01T00:00:00").timestamp()
@@ -228,10 +227,10 @@ class CSVTest(unittest.TestCase):
             [None, None, None, None, None, None],
         ]
 
-        for c, t, d in zip(view_csv.load_file(os.path.join(resources_directory, "unittest/csv/data.csv"),
+        for c, t, d in zip(view_csv.load_file(os.path.join(resources_directory, "unittest/csvutils/data.csv"),
                                               has_header=True,
                                               encoding="utf-8"),
-                           view_tsv.load_file(os.path.join(resources_directory, "unittest/csv/data.tsv"),
+                           view_tsv.load_file(os.path.join(resources_directory, "unittest/csvutils/data.tsv"),
                                               has_header=True,
                                               encoding="utf-8"),
                            data):

{iker_python_common-1.0.65 → iker_python_common-1.0.67}/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))

{iker_python_common-1.0.65 → iker_python_common-1.0.67}/test/iker_tests/common/utils/shutils_test.py

@@ -10,7 +10,7 @@ from iker.common.utils.shutils import expanded_path, path_depth
 from iker.common.utils.shutils import extension, extensions, stem
 from iker.common.utils.shutils import glob_match
 from iker.common.utils.testutils import norm_path
-from iker_tests import resources_directory
+from testenv import resources_directory
 
 work_dir = pathlib.Path.cwd
 home_dir = pathlib.Path.home

{iker_python_common-1.0.65 → iker_python_common-1.0.67}/test/iker_tests/common/utils/span_test.py

@@ -4,7 +4,7 @@ import unittest
 import ddt
 
 from iker.common.utils.iterutils import last
-from iker.common.utils.span import SpanRelation
+from iker.common.utils.span import Span, SpanRelation
 from iker.common.utils.span import span_relation, spans_intersect, spans_subtract, spans_union
 
 
@@ -42,7 +42,7 @@ class SpanTest(unittest.TestCase):
     @ddt.idata(data_span_relation)
     @ddt.unpack
     def test_span_relation(self, b, a, expect):
-        self.assertEqual(expect, span_relation(a, b))
+        self.assertEqual(expect, span_relation(Span(*a), Span(*b)))
 
     data_spans_union = [
         ([], [], []),
@@ -102,6 +102,10 @@ class SpanTest(unittest.TestCase):
     @ddt.idata(data_spans_union)
     @ddt.unpack
     def test_spans_union(self, xs, ys, expect):
+        xs = list(Span(*x) for x in xs)
+        ys = list(Span(*y) for y in ys)
+        expect = list(Span(*e) for e in expect)
+
         self.assertEqual(expect, spans_union(xs, ys))
         self.assertEqual(expect, spans_union(ys, xs))
         self.assertEqual(expect, spans_union(xs, *[[y] for y in ys]))
@@ -165,6 +169,10 @@ class SpanTest(unittest.TestCase):
     @ddt.idata(data_spans_intersect)
     @ddt.unpack
     def test_spans_intersect(self, xs, ys, expect):
+        xs = list(Span(*x) for x in xs)
+        ys = list(Span(*y) for y in ys)
+        expect = list(Span(*e) for e in expect)
+
         self.assertEqual(expect, spans_intersect(xs, ys))
         self.assertEqual(expect, spans_intersect(ys, xs))
         self.assertEqual(expect,
@@ -280,6 +288,10 @@ class SpanTest(unittest.TestCase):
     @ddt.idata(data_spans_subtract)
     @ddt.unpack
     def test_spans_subtract(self, xs, ys, expect):
+        xs = list(Span(*x) for x in xs)
+        ys = list(Span(*y) for y in ys)
+        expect = list(Span(*e) for e in expect)
+
         self.assertEqual(expect, spans_subtract(xs, ys))
         self.assertEqual(expect, spans_subtract(xs, *[[y] for y in ys]))
         self.assertEqual(expect, spans_subtract(xs, spans_intersect(xs, ys)))
@@ -292,7 +304,7 @@ class SpanTest(unittest.TestCase):
             vs = [float(random.randrange(lo, hi))]
             for _ in range(size * 2):
                 vs.append(last(vs) + float(random.randrange(lo, hi)))
-            return [(vs[2 * i], vs[2 * i + 1]) for i in range(size)]
+            return [Span(vs[2 * i], vs[2 * i + 1]) for i in range(size)]
 
         xs = make_spans(200, 2, 10)
         ys = make_spans(200, 2, 10)

iker_python_common-1.0.65/test/iker_tests/__init__.py → iker_python_common-1.0.67/test/testenv.py

@@ -8,7 +8,7 @@ __all__ = [
     "temporary_directory",
 ]
 
-module_directory: str = os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
+module_directory: str = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
 source_directory: str = os.path.abspath(os.path.join(module_directory, "src"))
 test_directory: str = os.path.abspath(os.path.join(module_directory, "test"))
 resources_directory: str = os.path.abspath(os.path.join(module_directory, "resources"))

iker_python_common-1.0.65/test/iker_test.py

@@ -1,13 +0,0 @@
-import unittest
-
-from iker_tests import *
-
-
-class Test(unittest.TestCase):
-
-    def test(self):
-        self.assertIsNotNone(module_directory)
-        self.assertIsNotNone(source_directory)
-        self.assertIsNotNone(test_directory)
-        self.assertIsNotNone(resources_directory)
-        self.assertIsNotNone(temporary_directory)