iker-python-common 1.0.1__tar.gz → 1.0.2__tar.gz

iker_python_common-1.0.2/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.1
+Name: iker-python-common
+Version: 1.0.2
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: <3.13,>=3.11
+Requires-Dist: boto3~=1.35
+Requires-Dist: docker~=7.1
+Requires-Dist: numpy~=1.26
+Requires-Dist: psycopg~=3.2
+Requires-Dist: pymysql~=1.1
+Requires-Dist: sqlalchemy~=2.0
+Provides-Extra: test
+Requires-Dist: ddt~=1.7; extra == "test"
+Requires-Dist: moto[all,ec2,s3]~=5.0; extra == "test"
+Requires-Dist: pytest-cov~=5.0; extra == "test"
+Requires-Dist: pytest-mock~=3.14; extra == "test"
+Requires-Dist: pytest-mysql~=3.0; extra == "test"
+Requires-Dist: pytest-order~=1.3; extra == "test"
+Requires-Dist: pytest-postgresql~=6.1; extra == "test"
+Requires-Dist: pytest~=8.3; extra == "test"

{iker_python_common-1.0.1 → iker_python_common-1.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [build-system]
 requires = [
-    "setuptools~=72.0",
+    "setuptools~=75.0",
     "setuptools-scm~=8.0",
     "iker-python-setup~=1.0",
 ]
@@ -16,40 +16,23 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
 ]
 dependencies = [
-    "boto3~=1.34",
-    "brotli~=1.0",
+    "boto3~=1.35",
     "docker~=7.1",
-    "jsonpath-ng~=1.6",
-    "jsonschema~=4.23",
-    "llvmlite~=0.43",
-    "lxml~=4.9",
-    "munch~=4.0",
-    "numpy~=2.1",
-    "pandas~=2.2",
-    "psycopg2-binary~=2.9",
-    "pygeodesy~=23.12",
+    "numpy~=1.26",
+    "psycopg~=3.2",
     "pymysql~=1.1",
-    "pyparsing~=3.1",
-    "pyquaternion~=0.9",
-    "pysocks~=1.7",
-    "python-dateutil~=2.8",
-    "pyyaml~=6.0",
-    "requests~=2.31",
-    "scipy~=1.14",
-    "shapely~=2.0",
     "sqlalchemy~=2.0",
-    "ujson~=5.10",
 ]
 
 [project.optional-dependencies]
 test = [
     "ddt~=1.7",
-    "moto[ec2,s3,all]~=4.2",
+    "moto[ec2,s3,all]~=5.0",
     "pytest-cov~=5.0",
     "pytest-mock~=3.14",
     "pytest-mysql~=3.0",
-    "pytest-order~=1.2",
-    "pytest-postgresql~=6.0",
+    "pytest-order~=1.3",
+    "pytest-postgresql~=6.1",
     "pytest~=8.3",
 ]
 

{iker_python_common-1.0.1 → iker_python_common-1.0.2}/src/iker/common/utils/dbutils.py

@@ -1,16 +1,14 @@
 import contextlib
 import dataclasses
-import datetime
 import urllib.parse
 from typing import Any, ContextManager, Type
 
-import psycopg2
-import psycopg2.extensions
+import psycopg
+import pymysql
 import sqlalchemy
 import sqlalchemy.ext.compiler
 import sqlalchemy.orm
 
-from iker.common.utils.funcutils import singleton
 from iker.common.utils.sequtils import head_or_none
 from iker.common.utils.strutils import is_blank
 
@@ -18,12 +16,6 @@ __all__ = [
     "DBAdapter",
     "orm_to_dict",
     "orm_clone",
-    "to_pg_date",
-    "to_pg_time",
-    "to_pg_ts",
-    "to_pg_ts",
-    "pg_date_max",
-    "pg_ts_max",
     "mysql_insert_ignore",
     "postgresql_insert_on_conflict_do_nothing",
 ]
@@ -35,8 +27,8 @@ class DBAdapter(object):
     """
 
     class Drivers:
-        Mysql = "mysql+mysqldb"
-        Postgresql = "postgresql+psycopg2"
+        Mysql = f"mysql+{pymysql.__name__}"
+        Postgresql = f"postgresql+{psycopg.__name__}"
 
     def __init__(
         self,
@@ -145,40 +137,6 @@ def orm_clone(orm: sqlalchemy.orm.DeclarativeBase, exclude: set[str] = None, no_
     return new_orm
 
 
-def to_pg_date(dt: datetime.datetime | datetime.date | int | float):
-    if isinstance(dt, (datetime.datetime, datetime.date)):
-        return psycopg2.extensions.DateFromPy(dt)
-    elif isinstance(dt, (int, float)):
-        return psycopg2.DateFromTicks(dt)
-    raise TypeError("should be one of 'datetime.datetime', 'datetime.date', 'int', 'float'")
-
-
-def to_pg_time(dt: datetime.time | int | float):
-    if isinstance(dt, datetime.time):
-        return psycopg2.extensions.TimeFromPy(dt)
-    elif isinstance(dt, (int, float)):
-        return psycopg2.TimeFromTicks(dt)
-    raise TypeError("should be one of 'datetime.time', 'int', 'float'")
-
-
-def to_pg_ts(dt: datetime.datetime | datetime.date | int | float):
-    if isinstance(dt, (datetime.datetime, datetime.date)):
-        return psycopg2.extensions.TimestampFromPy(dt)
-    elif isinstance(dt, (int, float)):
-        return psycopg2.TimestampFromTicks(dt)
-    raise TypeError("should be one of 'datetime.datetime', 'datetime.date', 'int', 'float'")
-
-
-@singleton
-def pg_date_max():
-    return psycopg2.Date(9999, 12, 31)
-
-
-@singleton
-def pg_ts_max():
-    return psycopg2.Timestamp(9999, 12, 31, 23, 59, 59.999, tzinfo=datetime.timezone.utc)
-
-
 def mysql_insert_ignore(enabled: bool = True):
     @sqlalchemy.ext.compiler.compiles(sqlalchemy.sql.Insert, "mysql")
     def dispatch(insert: sqlalchemy.sql.Insert, compiler: sqlalchemy.sql.compiler.SQLCompiler, **kwargs) -> str:

{iker_python_common-1.0.1 → iker_python_common-1.0.2}/src/iker/common/utils/logger.py

@@ -1,6 +1,3 @@
-"""
-Module-aware logging
-"""
 import inspect
 import logging
 

{iker_python_common-1.0.1 → iker_python_common-1.0.2}/src/iker/common/utils/s3utils.py

@@ -49,10 +49,11 @@ def s3_make_client(
     :param endpoint_url: AWS service endpoint url
     :return: context manager which wraps the AWS S3 client instance
     """
-    session = boto3.Session(aws_access_key_id=trim_to_none(access_key_id),
-                            aws_secret_access_key=trim_to_none(secret_access_key))
-    client = session.client("s3", region_name=trim_to_none(region_name), endpoint_url=trim_to_none(endpoint_url))
-
+    client = boto3.client("s3",
+                          region_name=trim_to_none(region_name),
+                          endpoint_url=trim_to_none(endpoint_url),
+                          aws_access_key_id=trim_to_none(access_key_id),
+                          aws_secret_access_key=trim_to_none(secret_access_key))
     return contextlib.closing(client)
 
 

iker_python_common-1.0.2/src/iker/common/utils/sequtils.py

@@ -0,0 +1,355 @@
+from __future__ import annotations
+
+import functools
+import itertools
+from typing import Callable, Generator, Generic, Iterable, Self, Sequence, TypeVar
+
+__all__ = [
+    "head",
+    "head_or_none",
+    "last",
+    "last_or_none",
+    "tail",
+    "init",
+    "grouped",
+    "deduped",
+    "batch_yield",
+    "chunk",
+    "chunk_between",
+    "chunk_with_key",
+    "merge_chunks",
+    "Seq",
+    "seq",
+]
+
+T = TypeVar("T")
+K = TypeVar("K")
+U = TypeVar("U")
+V = TypeVar("V")
+
+
+# See Haskell's list operations head, tail, init, and last
+# which is also provided in Scala list operations
+
+def head(ms: Sequence[T]) -> T:
+    return ms[0]
+
+
+def head_or_none(ms: Sequence[T]) -> T | None:
+    if len(ms) > 0:
+        return ms[0]
+    return None
+
+
+def last(ms: Sequence[T]) -> T:
+    return ms[-1]
+
+
+def last_or_none(ms: Sequence[T]) -> T | None:
+    if len(ms) > 0:
+        return ms[-1]
+    return None
+
+
+def tail(ms: Sequence[T]) -> Sequence[T]:
+    return ms[1:]
+
+
+def init(ms: Sequence[T]) -> Sequence[T]:
+    return ms[:-1]
+
+
+def grouped(
+    ms: Sequence[T],
+    key_func: Callable[[T], K],
+    keys_ordered: bool = False,
+    values_only: bool = False,
+) -> list[tuple[K, list[T]]] | list[list[T]]:
+    """
+    Groups the given list of elements according to key generator function
+
+    :param ms: list of elements
+    :param key_func: key generator function
+    :param keys_ordered: True if the return elements are sorted according to the keys
+    :param values_only: True if only return elements groups without corresponding keys
+    :return: grouped elements, with corresponding keys if `values_only` is set to False
+    """
+    if ms is None or len(ms) == 0:
+        return []
+    grouped_ms: dict[K, list[T]] = {}
+    for m in ms:
+        k = key_func(m)
+        grouped_ms.setdefault(k, []).append(m)
+    groups = sorted(grouped_ms.items()) if keys_ordered else grouped_ms.items()
+    return [d for _, d in groups] if values_only else [(k, d) for k, d in groups]
+
+
+def deduped(ms: Sequence[T], comp_func: Callable[[T, T], bool]) -> list[T]:
+    """
+    Dedupes the given list of elements
+
+    :param ms: list of elements
+    :param comp_func: comparator generator function
+    :return: deduped elements
+    """
+    if ms is None or len(ms) == 0:
+        return []
+    deduped_ms: list[T] = [head(ms)]
+    for m in tail(ms):
+        if not comp_func(last(deduped_ms), m):
+            deduped_ms.append(m)
+    return deduped_ms
+
+
+def batch_yield(ms: Iterable[T], batch_size: int) -> Generator[list[T]]:
+    """
+    Splits the given input sequence into batches according to the specific batch size
+
+    :param ms: sequence of elements
+    :param batch_size: batch size
+    :return: batches of sequences
+    """
+    if batch_size < 1:
+        raise ValueError("illegal batch size")
+    batch: list[T] = []
+    for m in ms:
+        batch.append(m)
+        if len(batch) == batch_size:
+            yield batch
+            batch = []
+    if len(batch) > 0:
+        yield batch
+
+
+def chunk(ms: Sequence[T], chunk_func: Callable[[Sequence[T], T], bool], exclusive_end: bool = False) -> list[list[T]]:
+    """
+    Chops the list of elements into chunks
+
+    :param ms: list of elements
+    :param chunk_func: chunk generator function with compares the current chunk and the next element from the list
+    :param exclusive_end: set to true to make each chunk (except the last one) carrying the first element of
+    the next chunk as an exclusive end
+    :return: list of element chunks
+    """
+    if ms is None or len(ms) == 0:
+        return []
+    chunks: list[list[T]] = [[head(ms)]]
+    for m in tail(ms):
+        if chunk_func(last(chunks), m):
+            if exclusive_end:
+                last(chunks).append(m)
+            chunks.append([m])
+        else:
+            last(chunks).append(m)
+    return chunks
+
+
+def chunk_between(ms: Sequence[T], chunk_func: Callable[[T, T], bool], exclusive_end: bool = False) -> list[list[T]]:
+    return chunk(ms, lambda x, y: chunk_func(last(x), y), exclusive_end)
+
+
+def chunk_with_key(ms: Sequence[T], key_func: Callable[[T], K], exclusive_end: bool = False) -> list[list[T]]:
+    return chunk_between(ms, lambda x, y: key_func(x) != key_func(y), exclusive_end)
+
+
+def merge_chunks(
+    chunks: Sequence[Sequence[T]],
+    merge_func: Callable[[Sequence[T], Sequence[T]], bool],
+    drop_exclusive_end: bool = False,
+) -> list[list[T]]:
+    """
+    Merges chunks according to the given merging criteria
+
+    :param chunks: chunks to be merged into larger ones
+    :param merge_func: merged chunk generator function
+    :param drop_exclusive_end: set to true if each of the given chunk (except the last one) as an exclusive end element,
+    and these exclusive end elements will be dropped while merging their chunks to the corresponding next chunks
+    :return: merged chunks
+    """
+    if chunks is None or len(chunks) == 0:
+        return []
+
+    merged_chunks: list[list[T]] = []
+
+    def stateful_reducer(a: Sequence[T], b: Sequence[T]) -> Sequence[T]:
+        if merge_func(a, b):
+            if drop_exclusive_end:
+                return list(itertools.chain(init(a), b))
+            return list(itertools.chain(a, b))
+        else:
+            merged_chunks.append(list(a))
+            return b
+
+    last_chunk = functools.reduce(stateful_reducer, chunks)
+    merged_chunks.append(list(last_chunk))
+    return merged_chunks
+
+
+class Seq(Generic[T]):
+    def __init__(self, data: Iterable[T] | Self):
+        if isinstance(data, Seq):
+            self.data = data.data
+        elif isinstance(data, Iterable):
+            self.data = list(data)
+        else:
+            raise ValueError("unsupported data type")
+
+    @property
+    def count(self) -> int:
+        return len(self.data)
+
+    @property
+    def empty(self) -> bool:
+        return self.count == 0
+
+    def __add__(self, other: Self) -> Self:
+        return self.concat(other)
+
+    def __getitem__(self, item):
+        if isinstance(item, slice):
+            return Seq(self.data[item])
+        elif isinstance(item, int):
+            return Seq([self.data[item]])
+        raise ValueError("unsupported index type")
+
+    def concat(self, other: Self) -> Self:
+        return Seq(self.data + other.data)
+
+    def take_left(self, n: int) -> Self:
+        return self[:n]
+
+    def take_right(self, n: int) -> Self:
+        return self[-n:]
+
+    take = take_left
+
+    def reverse(self) -> Self:
+        return Seq(reversed(self.data))
+
+    def distinct(self) -> Self:
+        return Seq(list(set(self.data)))
+
+    def scan_left(self, zero: U | None, func: Callable[[U, T], U]) -> "Seq[U]":
+        def scan():
+            accum = zero
+            for elem in self.data:
+                accum = func(accum, elem)
+                yield accum
+
+        return Seq(scan())
+
+    def scan_right(self, zero: U | None, func: Callable[[U, T], U]) -> "Seq[U]":
+        def scan():
+            accum = zero
+            for elem in reversed(self.data):
+                accum = func(accum, elem)
+                yield accum
+
+        return Seq(reversed(list(scan())))
+
+    scan = scan_left
+
+    def map(self, func: Callable[[T], U]) -> "Seq[U]":
+        return self.scan(None, lambda x, y: func(y))
+
+    def fold_left(self, zero: U | None, func: Callable[[U, T], U]) -> "Seq[U]":
+        if self.empty:
+            return Seq([]) if zero is None else Seq([zero])
+        data = self.data if zero is None else [zero] + self.data
+        accum = head(data)
+        for elem in tail(data):
+            accum = func(accum, elem)
+        return Seq([accum])
+
+    def fold_right(self, zero: U | None, func: Callable[[U, T], U]) -> "Seq[U]":
+        if self.empty:
+            return Seq([]) if zero is None else Seq([zero])
+        data = self.data if zero is None else self.data + [zero]
+        accum = last(data)
+        for elem in reversed(init(data)):
+            accum = func(accum, elem)
+        return Seq([accum])
+
+    fold = fold_left
+
+    def reduce(self, func: Callable[[T, T], T]) -> Self:
+        return self.fold(None, lambda x, y: func(x, y))
+
+    def max(self, func: Callable[[T, T], bool] = None) -> Self:
+        func = func or (lambda x, y: x > y)
+        return self.reduce(lambda x, y: x if func(x, y) else y)
+
+    def min(self, func: Callable[[T, T], bool] = None) -> Self:
+        func = func or (lambda x, y: x < y)
+        return self.reduce(lambda x, y: x if func(x, y) else y)
+
+    def group(self, func: Callable[[T], K]) -> "Seq[tuple[K, list[T]]]":
+        return Seq(grouped(self.data, key_func=func, keys_ordered=True))
+
+    def keys(self):
+        return Seq(key for key, _ in self.data)
+
+    def values(self):
+        return Seq(value for _, value in self.data)
+
+    def swap(self):
+        return Seq((value, key) for key, value in self.data)
+
+    def map_keys(self, func: Callable[[T], U]) -> Self:
+        return Seq((func(key), value) for key, value in self.data)
+
+    def map_values(self, func: Callable[[T], U]) -> Self:
+        return Seq((key, func(value)) for key, value in self.data)
+
+    def flatten(self):
+        data = []
+        for d in self.data:
+            data.extend(d)
+        return Seq(data)
+
+    def flat_map(self, func: Callable[[T], U]) -> "Seq[U]":
+        return self.flatten().map(func)
+
+    def group_map(self, group_func: Callable[[T], K], map_func: Callable[[T], U]) -> "Seq[tuple[K, list[U]]]":
+        return self.group(group_func).map_values(lambda x: list(map(map_func, x)))
+
+    def filter(self, func: Callable[[T], bool]) -> Self:
+        return Seq(filter(func, self.data))
+
+    def filter_not(self, func: Callable[[T], bool]) -> Self:
+        return self.filter(lambda x: not func(x))
+
+    def sort(self, func: Callable[[T], K]) -> Self:
+        return Seq(sorted(self.data, key=func))
+
+    def head(self) -> Self:
+        return Seq([head(self.data)])
+
+    def last(self) -> Self:
+        return Seq([last(self.data)])
+
+    def init(self) -> Self:
+        return Seq(init(self.data))
+
+    def tail(self) -> Self:
+        return Seq(tail(self.data))
+
+    def foreach(self, func: Callable[[T], None]) -> Self:
+        for elem in self.data:
+            func(elem)
+        return self
+
+    def exists(self, func: Callable[[T], bool]) -> "Seq[bool]":
+        return Seq([any(map(func, self.data))])
+
+    def forall(self, func: Callable[[T], bool]) -> "Seq[bool]":
+        return Seq([all(map(func, self.data))])
+
+    def union(self, other: Self) -> Self:
+        return Seq(list(set(self.data).union(set(other.data))))
+
+    def intersect(self, other: Self) -> Self:
+        return Seq(list(set(self.data).intersection(set(other.data))))
+
+
+seq = Seq