klaatu-python 2.2.0__py3-none-any.whl → 2.4.0__py3-none-any.whl

klaatu_python/__init__.py

@@ -1 +0,0 @@
-__version__ = "2.2.0"

klaatu_python/case.py

@@ -5,19 +5,19 @@ from abc import abstractmethod
 class CaseType:
     @staticmethod
     @abstractmethod
-    def split(value: str) -> list[str]:
-        ...
+    def split(value: str) -> list[str]: ...
 
     @staticmethod
     @abstractmethod
-    def join(parts: list[str]) -> str:
-        ...
+    def join(parts: list[str]) -> str: ...
 
 
 class CamelCase(CaseType):
+    """camelCase"""
+
     @staticmethod
     def split(value: str) -> list[str]:
-        return [m.group() for m in re.finditer(r"(^[a-z]*)|([A-Z][a-z]*)", value)]
+        return [m.group() for m in re.finditer(r"(^[a-z]+)|([A-Z][a-z]*)", value)]
 
     @staticmethod
     def join(parts: list[str]) -> str:
@@ -27,6 +27,8 @@ class CamelCase(CaseType):
 
 
 class ConstantCase(CaseType):
+    """CONSTANT_CASE"""
+
     @staticmethod
     def split(value: str) -> list[str]:
         return value.split("_")
@@ -37,6 +39,8 @@ class ConstantCase(CaseType):
 
 
 class KebabCase(CaseType):
+    """kebab-case"""
+
     @staticmethod
     def split(value: str) -> list[str]:
         return value.split("-")
@@ -47,9 +51,11 @@ class KebabCase(CaseType):
 
 
 class PascalCase(CaseType):
+    """PascalCase"""
+
     @staticmethod
     def split(value: str) -> list[str]:
-        return [m.group() for m in re.finditer(r"(^[a-z]*)|([A-Z][a-z]*)", value)]
+        return [m.group() for m in re.finditer(r"(^[a-z]+)|([A-Z][a-z]*)", value)]
 
     @staticmethod
     def join(parts: list[str]) -> str:
@@ -57,6 +63,8 @@ class PascalCase(CaseType):
 
 
 class SnakeCase(CaseType):
+    """snake_case"""
+
     @staticmethod
     def split(value: str) -> list[str]:
         return value.split("_")

klaatu_python/lock.py

@@ -2,12 +2,12 @@ import functools
 import os
 
 
-class LockException(Exception):
-    ...
+class LockException(Exception): ...
 
 
 class Lock:
     """Does the same as `lock`, but as a context manager."""
+
     def __init__(self, lockfile: str):
         self.lockfile = lockfile
 
@@ -26,6 +26,7 @@ class Lock:
 
 def lock(lockfile: str):
     """Primitive mechanism to avoid concurrent execution of a function."""
+
     def decorator(func):
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
@@ -44,5 +45,7 @@ def lock(lockfile: str):
                 remote_attempts += 1
 
             return result
+
         return wrapper
+
     return decorator

klaatu_python/utils.py

@@ -1,15 +1,20 @@
+import itertools
 import re
+from collections.abc import Callable, Hashable, Iterable, Iterator, Sequence
 from datetime import date, timedelta
+from locale import format_string, localeconv
 from math import ceil, floor, log10
-from typing import Any, Callable, Iterable, Iterator, Literal, Sequence, TypeVar, overload
+from pathlib import Path
+from typing import Any, Literal, TypeVar, overload
 from urllib.parse import parse_qs, urlencode, urlsplit, urlunsplit
 
 
 _T = TypeVar("_T")
 _NT = TypeVar("_NT", int, float)
+_HashableT = TypeVar("_HashableT", bound=Hashable)
 
 
-def append_query_to_url(url: str, params: dict, conditional_params: dict | None = None, safe: str = '') -> str:
+def append_query_to_url(url: str, params: dict, conditional_params: dict | None = None, safe: str = "") -> str:
     """
     Adds GET query from `params` to `url`, or appends it if there already is
     one.
@@ -65,10 +70,49 @@ def daterange(start_date: date, end_date: date) -> Iterator[date]:
         yield start_date + timedelta(days=n)
 
 
+def deepest_common_path(path1: Path, *paths: Path) -> Path:
+    """
+    Finds and returns the deepest (as in "deep in the directory structure")
+    path that all parameters have in common.
+
+    Example:
+    >>> deepest_common_path(Path("/usr/local/bin/"), Path("/usr/share/"))
+    PosixPath('/usr')
+    """
+    path1 = path1.resolve()
+    paths = tuple(p.resolve() for p in paths)
+
+    # Returned iterator will contain None unless all paths are identical:
+    if all(itertools.accumulate([path1, *paths], lambda p1, p2: p1 if p1 == p2 else None)):
+        return path1
+
+    paths_parts = [[p, *p.parents] for p in paths]
+
+    for part in [path1, *path1.parents]:
+        if all(part in parts for parts in paths_parts):
+            return part
+
+    raise ValueError("No common paths")
+
+
 def filter_values_not_null(d: dict) -> dict:
     return {k: v for k, v in d.items() if v is not None}
 
 
+def first_not_null(*values: _T | None) -> _T:
+    ret = first_not_null_or_null(*values)
+    if ret is None:
+        raise TypeError("All values are None")
+    return ret
+
+
+def first_not_null_or_null(*values: _T | None) -> _T | None:
+    for value in values:
+        if value is not None:
+            return value
+    return None
+
+
 def getitem_nullable(seq: Iterable[_T], idx: int, cond: Callable[[_T], bool] | None = None) -> _T | None:
     """
     If `seq` has an item at position `idx`, return that item. Otherwise return
@@ -211,9 +255,8 @@ def int_to_string(value: int | None, locale: str, nbsp: bool = False) -> str:
     # 5. Re-reverse the digits in each group & join them with separator string
     # 6. Re-reverse the order of the groups
     # 7. Add minus sign if value was negative
-    return (
-        ("-" if value < 0 else "") +
-        separator.join([v[::-1] for v in re.split(r"(\d{3})", str(abs(value))[::-1]) if v][::-1])
+    return ("-" if value < 0 else "") + separator.join(
+        [v[::-1] for v in re.split(r"(\d{3})", str(abs(value))[::-1]) if v][::-1]
     )
 
 
@@ -227,6 +270,56 @@ def is_truthy(value: Any) -> bool:
     return bool(value)
 
 
+def localize_float(
+    value: float,
+    grouping: bool = True,
+    min_decimals: int | None = None,
+    max_decimals: int | None = None,
+) -> str:
+    if max_decimals is None:
+        max_decimals = 15
+
+    if min_decimals is not None and min_decimals > max_decimals:
+        raise ValueError("min_decimals must be <= max_decimals")
+    if 15 < (min_decimals or 0) < 0:
+        raise ValueError("min_decimals must be >= 0 and <= 15")
+    if 15 < (max_decimals or 0) < 0:
+        raise ValueError("max_decimals must be >= 0 and <= 15")
+
+    decimal_separator = localeconv()["decimal_point"]
+    ret = format_string("%.*f", (max_decimals, value), grouping=grouping)
+
+    if decimal_separator in ret:
+        base, decimals = ret.split(decimal_separator)
+        decimals = decimals.rstrip("0").ljust(min_decimals or 0, "0")
+        if not decimals:
+            return base
+        return base + decimal_separator + decimals
+
+    return ret
+
+
+def most_common(values: Iterable[_HashableT]) -> tuple[_HashableT | None, int]:
+    """
+    Given a non-empty iterable, this will return a 2-tuple with the most
+    commonly occurring value in said iterable, and the number of such
+    occurances.
+
+    Given an _empty_ iterable, it will return `(None, 0)`.
+    """
+    occurrences: dict[_HashableT, int] = {}
+
+    for value in values:
+        if value not in occurrences:
+            occurrences[value] = 0
+        occurrences[value] += 1
+
+    if not occurrences:
+        return None, 0
+
+    return max(occurrences.items(), key=lambda tup: tup[1])
+
+
 def nonulls(items: Iterable[_T | None]) -> list[_T]:
     """Just filters away None values from `items`."""
     return [item for item in items if item is not None]
@@ -236,7 +329,7 @@ def partition(items: Sequence[_T], length: int) -> Iterator[Sequence[_T]]:
     """Simply splits `items` into subsequences of max `length` items."""
     offset = 0
     while offset == 0 or offset < len(items):
-        yield items[offset:offset + length]
+        yield items[offset : offset + length]
         offset += length
 
 
@@ -246,6 +339,37 @@ def percent_rounded(part: int | float, whole: int | float) -> int:
     return round(part / whole * 100)
 
 
+def roman(n: int):
+    if n % 1:
+        raise ValueError("roman(): fractions not allowed")
+    if n >= 4000 or n < 0:
+        raise ValueError("roman(): value must be >= 0 and < 4000")
+
+    m = {
+        1000: "M",
+        900: "CM",
+        500: "D",
+        400: "CD",
+        100: "C",
+        90: "XC",
+        50: "L",
+        40: "XL",
+        10: "X",
+        9: "IX",
+        5: "V",
+        4: "IV",
+        1: "I",
+    }
+    r = ""
+
+    for k, v in m.items():
+        while n >= k:
+            r += v
+            n -= k
+
+    return r
+
+
 def round_to_n(x: int | float, n: int) -> int | float:
     """
     Rounds x to n significant digits. If the result is a whole number, it is
@@ -278,7 +402,7 @@ def rounded_percentage(part: int | float, whole: int | float, digits=3) -> int |
 def strip_url_query(url: str) -> str:
     """Just returns `url` stripped of any GET parameters."""
     parts = urlsplit(url)
-    return urlunsplit((parts.scheme, parts.netloc, parts.path, '', parts.fragment))
+    return urlunsplit((parts.scheme, parts.netloc, parts.path, "", parts.fragment))
 
 
 def to_int(value: Any, default: int | None = None) -> int | None:
@@ -297,7 +421,7 @@ def zip_dicts(*dicts: dict) -> dict:
     return {k: v for d in dicts for k, v in d.items()}
 
 
-def zip_dict_lists(dict_lists: Sequence[Sequence[dict]]) -> Iterator[dict]:
+def zip_dict_lists(dict_lists: Sequence[Sequence[dict]], strict: bool = False) -> Iterator[dict]:
     """
     Zips a list of dict lists and combines them into single dicts.
     I.e. given dict_lists = [
@@ -308,5 +432,5 @@ def zip_dict_lists(dict_lists: Sequence[Sequence[dict]]) -> Iterator[dict]:
     {a1: 1, a2: 2, a3: 5, a4: 6}
     {b1: 3, b2: 4, b3: 7, b4: 8}
     """
-    for dicts in zip(*dict_lists):
+    for dicts in zip(*dict_lists, strict=strict):
         yield zip_dicts(*dicts)

{klaatu_python-2.2.0.dist-info → klaatu_python-2.4.0.dist-info}/METADATA

@@ -1,20 +1,15 @@
 Metadata-Version: 2.4
 Name: klaatu-python
-Version: 2.2.0
+Version: 2.4.0
+Author: Robert Huselius
 Author-email: Robert Huselius <robert@huseli.us>
 License-Expression: GPL-3.0-only
+License-File: LICENSE
+Requires-Python: >=3.10
 Project-URL: Homepage, https://github.com/Eboreg/klaatu-python
-Project-URL: Source, https://github.com/Eboreg/klaatu-python
 Project-URL: Issues, https://github.com/Eboreg/klaatu-python/issues
-Requires-Python: >=3.7
+Project-URL: Source, https://github.com/Eboreg/klaatu-python
 Description-Content-Type: text/markdown
-License-File: LICENSE
-Provides-Extra: dev
-Requires-Dist: ipython; extra == "dev"
-Requires-Dist: ipdb; extra == "dev"
-Requires-Dist: isort; extra == "dev"
-Requires-Dist: pylint; extra == "dev"
-Dynamic: license-file
 
 # klaatu-python
 
@@ -34,7 +29,7 @@ In `pyproject.toml`:
 ```
 [project]
 dependencies = [
-    "klaatu_python @ git+https://git@github.com/Eboreg/klaatu-python.git",
+    "klaatu-python",
     ...
 ]
 ```

klaatu_python-2.4.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+klaatu_python/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+klaatu_python/case.py,sha256=VEpFpufLMoOAl0ElDwvyF6M11z7hMbKml6JzQfkztKk,1788
+klaatu_python/lock.py,sha256=D--5HjqAgtflOtNjp0klF8C_gXUjOrrT9YpKx4vFWn8,1393
+klaatu_python/utils.py,sha256=CNQyB3uUQe1c85JH3ictz8gfDUCQfPiC9j0Kbw9X7Hc,13189
+klaatu_python-2.4.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+klaatu_python-2.4.0.dist-info/WHEEL,sha256=5w2T7AS2mz1-rW9CNagNYWRCaB0iQqBMYLwKdlgiR4Q,78
+klaatu_python-2.4.0.dist-info/METADATA,sha256=s_5Vr1eVv4hyPQ0p66RO73Ka8RbiQNEmgTIGKo0USRY,761
+klaatu_python-2.4.0.dist-info/RECORD,,

klaatu_python-2.4.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.9.7
+Root-Is-Purelib: true
+Tag: py3-none-any

klaatu_python-2.2.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-klaatu_python/__init__.py,sha256=DKk-1b-rZsJFxFi1JoJ7TmEvIEQ0rf-C9HAZWwvjuM0,22
-klaatu_python/case.py,sha256=2Tya4dlBrqkwhQZu9PTLEA0SiWSIoKw12Ar2UJZssd4,1692
-klaatu_python/lock.py,sha256=STJpYdpYxHJDges9DFv08kC4hGa1IPtHMNxanrQlioM,1393
-klaatu_python/utils.py,sha256=SffgWZV0AbMe63VfK0REz7bjzWutPCLdin3vBb3xc6o,9779
-klaatu_python-2.2.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-klaatu_python-2.2.0.dist-info/METADATA,sha256=eSqjgxZZ4301cxMuweJJFHWr2nWzvzsGxUwBJvzcdVg,982
-klaatu_python-2.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-klaatu_python-2.2.0.dist-info/top_level.txt,sha256=JxX5CCI_SC5L4jbAG7acjKwIPVWmCl46ofDZNZtnV1o,14
-klaatu_python-2.2.0.dist-info/RECORD,,

klaatu_python-2.2.0.dist-info/WHEEL

@@ -1,5 +0,0 @@
-Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
-Root-Is-Purelib: true
-Tag: py3-none-any
-

klaatu_python-2.2.0.dist-info/top_level.txt

@@ -1 +0,0 @@
-klaatu_python