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

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

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

{iker_python_common-1.0.66/resources/unittest/csv → iker_python_common-1.0.68/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.66/resources/unittest/csv → iker_python_common-1.0.68/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.66 → iker_python_common-1.0.68}/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.66/src/iker/common/utils/csv.py → iker_python_common-1.0.68/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.66 → iker_python_common-1.0.68}/src/iker/common/utils/retry.py

@@ -165,11 +165,11 @@ class RetryWrapper(object):
                 else:
                     return self.target(*args, **kwargs)
             except Exception as e:
-                logger.exception("Function target '%s' failed on attempt '%d'", self.target, 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))
 
-        raise RuntimeError(f"failed to execute function target '{self.target}' after '{attempt_number}' attempts")
+        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):

{iker_python_common-1.0.66 → iker_python_common-1.0.68}/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.66 → iker_python_common-1.0.68}/src/iker_python_common.egg-info/PKG-INFO

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

{iker_python_common-1.0.66 → iker_python_common-1.0.68}/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.66 → iker_python_common-1.0.68}/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.66/test/iker_tests/common/utils/csv_test.py → iker_python_common-1.0.68/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.66 → iker_python_common-1.0.68}/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.66 → iker_python_common-1.0.68}/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.66/test/iker_tests/__init__.py → iker_python_common-1.0.68/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.66/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)