relib 1.3.5__py3-none-any.whl → 1.3.7__py3-none-any.whl

relib/dict_utils.py

@@ -1,5 +1,8 @@
 from typing import Any, Callable, Iterable, overload
 from .type_utils import as_any
+from .types import K1, K2, K3, K4, K5, K6, T1, T2, K, T, U
+
+sentinel = object()
 
 __all__ = [
   "deep_dict_pairs", "deepen_dict", "dict_by", "dict_firsts",
@@ -9,10 +12,11 @@ __all__ = [
   "map_dict", "merge_dicts",
   "omit",
   "pick",
+  "remap",
   "tuple_by",
 ]
 
-def merge_dicts[T, K](*dicts: dict[K, T]) -> dict[K, T]:
+def merge_dicts(*dicts: dict[K, T]) -> dict[K, T]:
   if len(dicts) == 1:
     return dicts[0]
   result = {}
@@ -20,29 +24,47 @@ def merge_dicts[T, K](*dicts: dict[K, T]) -> dict[K, T]:
     result |= d
   return result
 
-def omit[T, K](d: dict[K, T], keys: Iterable[K]) -> dict[K, T]:
+def omit(d: dict[K, T], keys: Iterable[K]) -> dict[K, T]:
   if keys:
     d = dict(d)
     for key in keys:
       del d[key]
   return d
 
-def pick[T, K](d: dict[K, T], keys: Iterable[K]) -> dict[K, T]:
+def pick(d: dict[K, T], keys: Iterable[K]) -> dict[K, T]:
   return {key: d[key] for key in keys}
 
-def dict_by[T, K](keys: Iterable[K], values: Iterable[T]) -> dict[K, T]:
+def dict_by(keys: Iterable[K], values: Iterable[T]) -> dict[K, T]:
   return dict(zip(keys, values))
 
-def tuple_by[T, K](d: dict[K, T], keys: Iterable[K]) -> tuple[T, ...]:
+def tuple_by(d: dict[K, T], keys: Iterable[K]) -> tuple[T, ...]:
   return tuple(d[key] for key in keys)
 
-def map_dict[T, U, K](fn: Callable[[T], U], d: dict[K, T]) -> dict[K, U]:
+def map_dict(fn: Callable[[T], T], d: dict[K, T]) -> dict[K, T]:
   return {key: fn(value) for key, value in d.items()}
 
-def key_of[T, U](dicts: Iterable[dict[T, U]], key: T) -> list[U]:
+@overload
+def remap(d: dict[K1, T1]) -> dict[K1, T1]: ...
+@overload
+def remap(d: dict[K1, T1], *, keys: dict[K1, K2] = {}) -> dict[K2, T1]: ...
+@overload
+def remap(d: dict[K1, T1], *, values: dict[T1, T2] = {}) -> dict[K1, T2]: ...
+@overload
+def remap(d: dict[K1, T1], *, keys: dict[K1, K2], values: dict[T1, T2]) -> dict[K2, T2]: ...
+def remap(d: dict, *, keys=sentinel, values=sentinel) -> dict:
+  match (keys, values):
+    case (dict(), dict()):
+      return {keys[key]: values[value] for key, value in d.items()}
+    case (dict(), _):
+      return {keys[key]: value for key, value in d.items()}
+    case (_, dict()):
+      return {key: values[value] for key, value in d.items()}
+  return d
+
+def key_of(dicts: Iterable[dict[T, U]], key: T) -> list[U]:
   return [d[key] for d in dicts]
 
-def get_at[T](d: dict, keys: Iterable[Any], default: T) -> T:
+def get_at(d: dict, keys: Iterable[Any], default: T) -> T:
   try:
     for key in keys:
       d = d[key]
@@ -50,13 +72,13 @@ def get_at[T](d: dict, keys: Iterable[Any], default: T) -> T:
     return default
   return as_any(d)
 
-def dict_firsts[T, K](pairs: Iterable[tuple[K, T]]) -> dict[K, T]:
+def dict_firsts(pairs: Iterable[tuple[K, T]]) -> dict[K, T]:
   result: dict[K, T] = {}
   for key, value in pairs:
     result.setdefault(key, value)
   return result
 
-def group[T, K](pairs: Iterable[tuple[K, T]]) -> dict[K, list[T]]:
+def group(pairs: Iterable[tuple[K, T]]) -> dict[K, list[T]]:
   values_by_key = {}
   for key, value in pairs:
     values_by_key.setdefault(key, []).append(value)
@@ -73,17 +95,17 @@ def flatten_dict(deep_dict: dict, prefix=()) -> dict:
   return dict(deep_dict_pairs(deep_dict, prefix))
 
 @overload
-def deepen_dict[K1, U](d: dict[tuple[K1], U]) -> dict[K1, U]: ...
+def deepen_dict(d: dict[tuple[K1], U]) -> dict[K1, U]: ...
 @overload
-def deepen_dict[K1, K2, U](d: dict[tuple[K1, K2], U]) -> dict[K1, dict[K2, U]]: ...
+def deepen_dict(d: dict[tuple[K1, K2], U]) -> dict[K1, dict[K2, U]]: ...
 @overload
-def deepen_dict[K1, K2, K3, U](d: dict[tuple[K1, K2, K3], U]) -> dict[K1, dict[K2, dict[K3, U]]]: ...
+def deepen_dict(d: dict[tuple[K1, K2, K3], U]) -> dict[K1, dict[K2, dict[K3, U]]]: ...
 @overload
-def deepen_dict[K1, K2, K3, K4, U](d: dict[tuple[K1, K2, K3, K4], U]) -> dict[K1, dict[K2, dict[K3, dict[K4, U]]]]: ...
+def deepen_dict(d: dict[tuple[K1, K2, K3, K4], U]) -> dict[K1, dict[K2, dict[K3, dict[K4, U]]]]: ...
 @overload
-def deepen_dict[K1, K2, K3, K4, K5, U](d: dict[tuple[K1, K2, K3, K4, K5], U]) -> dict[K1, dict[K2, dict[K3, dict[K4, dict[K5, U]]]]]: ...
+def deepen_dict(d: dict[tuple[K1, K2, K3, K4, K5], U]) -> dict[K1, dict[K2, dict[K3, dict[K4, dict[K5, U]]]]]: ...
 @overload
-def deepen_dict[K1, K2, K3, K4, K5, K6, U](d: dict[tuple[K1, K2, K3, K4, K5, K6], U]) -> dict[K1, dict[K2, dict[K3, dict[K4, dict[K5, dict[K6, U]]]]]]: ...
+def deepen_dict(d: dict[tuple[K1, K2, K3, K4, K5, K6], U]) -> dict[K1, dict[K2, dict[K3, dict[K4, dict[K5, dict[K6, U]]]]]]: ...
 def deepen_dict(d: dict[tuple[Any, ...], Any]) -> dict:
   output = {}
   if () in d:

relib/iter_utils.py

@@ -1,11 +1,12 @@
+from __future__ import annotations
 from contextlib import contextmanager
 from itertools import chain, islice
-from typing import Any, Iterable, Literal, Self, Sequence, overload
+from typing import Any, Generic, Iterable, Literal, Sequence, overload
 from .dict_utils import dict_firsts
+from .types import T1, T2, T3, T4, T5, T, U
 
 __all__ = [
-  "as_list",
-  "at",
+  "as_list", "at",
   "chunked",
   "distinct_by", "distinct", "drop_none",
   "first", "flatten",
@@ -18,52 +19,52 @@ __all__ = [
   "transpose",
 ]
 
-def as_list[T](iterable: Iterable[T]) -> list[T]:
+def as_list(iterable: Iterable[T]) -> list[T]:
   return iterable if isinstance(iterable, list) else list(iterable)
 
-def at[T, U](values: Sequence[T], index: int, default: U = None) -> T | U:
+def at(values: Sequence[T], index: int, default: U = None) -> T | U:
   try:
     return values[index]
   except IndexError:
     return default
 
-def first[T](iterable: Iterable[T]) -> T | None:
+def first(iterable: Iterable[T]) -> T | None:
   return next(iter(iterable), None)
 
-def drop_none[T](iterable: Iterable[T | None]) -> list[T]:
+def drop_none(iterable: Iterable[T | None]) -> list[T]:
   return [x for x in iterable if x is not None]
 
-def distinct[T](iterable: Iterable[T]) -> list[T]:
+def distinct(iterable: Iterable[T]) -> list[T]:
   return list(dict.fromkeys(iterable))
 
-def distinct_by[T](pairs: Iterable[tuple[object, T]]) -> list[T]:
+def distinct_by(pairs: Iterable[tuple[object, T]]) -> list[T]:
   return list(dict_firsts(pairs).values())
 
-def sort_by[T](pairs: Iterable[tuple[Any, T]], reverse=False) -> list[T]:
+def sort_by(pairs: Iterable[tuple[Any, T]], reverse=False) -> list[T]:
   pairs = sorted(pairs, key=lambda p: p[0], reverse=reverse)
   return [v for _, v in pairs]
 
-def move_value[T](iterable: Iterable[T], from_i: int, to_i: int) -> list[T]:
+def move_value(iterable: Iterable[T], from_i: int, to_i: int) -> list[T]:
   values = list(iterable)
   values.insert(to_i, values.pop(from_i))
   return values
 
-def reversed_enumerate[T](values: Sequence[T] | tuple[T, ...]) -> Iterable[tuple[int, T]]:
+def reversed_enumerate(values: Sequence[T] | tuple[T, ...]) -> Iterable[tuple[int, T]]:
   return zip(range(len(values))[::-1], reversed(values))
 
-def intersect[T](*iterables: Iterable[T]) -> list[T]:
+def intersect(*iterables: Iterable[T]) -> list[T]:
   return list(set.intersection(*map(set, iterables)))
 
-def interleave[T](*iterables: Iterable[T]) -> list[T]:
+def interleave(*iterables: Iterable[T]) -> list[T]:
   return flatten(zip(*iterables))
 
-def list_split[T](iterable: Iterable[T], sep: T) -> list[list[T]]:
+def list_split(iterable: Iterable[T], sep: T) -> list[list[T]]:
   values = [sep, *iterable, sep]
   split_at = [i for i, x in enumerate(values) if x is sep]
   ranges = list(zip(split_at[0:-1], split_at[1:]))
   return [values[start + 1:end] for start, end in ranges]
 
-def partition[T](iterable: Iterable[tuple[bool, T]]) -> tuple[list[T], list[T]]:
+def partition(iterable: Iterable[tuple[bool, T]]) -> tuple[list[T], list[T]]:
   true_values, false_values = [], []
   for predicate, value in iterable:
     if predicate:
@@ -72,7 +73,7 @@ def partition[T](iterable: Iterable[tuple[bool, T]]) -> tuple[list[T], list[T]]:
       false_values.append(value)
   return true_values, false_values
 
-class seekable[T]:
+class seekable(Generic[T]):
   def __init__(self, iterable: Iterable[T]):
     self.index = 0
     self.source = iter(iterable)
@@ -97,14 +98,14 @@ class seekable[T]:
     self.sink[:self.index] = []
     self.index = 0
 
-  def seek(self, index: int) -> Self:
+  def seek(self, index: int) -> seekable[T]:
     remainder = index - len(self.sink)
     if remainder > 0:
       next(islice(self, remainder, remainder), None)
     self.index = max(0, min(index, len(self.sink)))
     return self
 
-  def step(self, count: int) -> Self:
+  def step(self, count: int) -> seekable[T]:
     return self.seek(self.index + count)
 
   @contextmanager
@@ -123,9 +124,9 @@ class seekable[T]:
       return list(islice(self, count))
 
 @overload
-def chunked[T](values: Iterable[T], *, num_chunks: int, chunk_size=None) -> list[list[T]]: ...
+def chunked(values: Iterable[T], *, num_chunks: int, chunk_size=None) -> list[list[T]]: ...
 @overload
-def chunked[T](values: Iterable[T], *, num_chunks=None, chunk_size: int) -> list[list[T]]: ...
+def chunked(values: Iterable[T], *, num_chunks=None, chunk_size: int) -> list[list[T]]: ...
 def chunked(values, *, num_chunks=None, chunk_size=None):
   values = as_list(values)
   if isinstance(num_chunks, int):
@@ -136,15 +137,15 @@ def chunked(values, *, num_chunks=None, chunk_size=None):
   return [values[i * chunk_size:(i + 1) * chunk_size] for i in range(num_chunks)]
 
 @overload
-def flatten[T](iterable: Iterable[T], depth: Literal[0]) -> list[T]: ...
+def flatten(iterable: Iterable[T], depth: Literal[0]) -> list[T]: ...
 @overload
-def flatten[T](iterable: Iterable[Iterable[T]], depth: Literal[1] = 1) -> list[T]: ...
+def flatten(iterable: Iterable[Iterable[T]], depth: Literal[1] = 1) -> list[T]: ...
 @overload
-def flatten[T](iterable: Iterable[Iterable[Iterable[T]]], depth: Literal[2]) -> list[T]: ...
+def flatten(iterable: Iterable[Iterable[Iterable[T]]], depth: Literal[2]) -> list[T]: ...
 @overload
-def flatten[T](iterable: Iterable[Iterable[Iterable[Iterable[T]]]], depth: Literal[3]) -> list[T]: ...
+def flatten(iterable: Iterable[Iterable[Iterable[Iterable[T]]]], depth: Literal[3]) -> list[T]: ...
 @overload
-def flatten[T](iterable: Iterable[Iterable[Iterable[Iterable[Iterable[T]]]]], depth: Literal[4]) -> list[T]: ...
+def flatten(iterable: Iterable[Iterable[Iterable[Iterable[Iterable[T]]]]], depth: Literal[4]) -> list[T]: ...
 @overload
 def flatten(iterable: Iterable, depth: int) -> list: ...
 def flatten(iterable: Iterable, depth: int = 1) -> list:
@@ -153,15 +154,15 @@ def flatten(iterable: Iterable, depth: int = 1) -> list:
   return list(iterable)
 
 @overload
-def transpose[T1, T2](tuples: Iterable[tuple[T1, T2]], default_num_returns=0) -> tuple[list[T1], list[T2]]: ...
+def transpose(tuples: Iterable[tuple[T1, T2]], default_num_returns=0) -> tuple[list[T1], list[T2]]: ...
 @overload
-def transpose[T1, T2, T3](tuples: Iterable[tuple[T1, T2, T3]], default_num_returns=0) -> tuple[list[T1], list[T2], list[T3]]: ...
+def transpose(tuples: Iterable[tuple[T1, T2, T3]], default_num_returns=0) -> tuple[list[T1], list[T2], list[T3]]: ...
 @overload
-def transpose[T1, T2, T3, T4](tuples: Iterable[tuple[T1, T2, T3, T4]], default_num_returns=0) -> tuple[list[T1], list[T2], list[T3], list[T4]]: ...
+def transpose(tuples: Iterable[tuple[T1, T2, T3, T4]], default_num_returns=0) -> tuple[list[T1], list[T2], list[T3], list[T4]]: ...
 @overload
-def transpose[T1, T2, T3, T4, T5](tuples: Iterable[tuple[T1, T2, T3, T4, T5]], default_num_returns=0) -> tuple[list[T1], list[T2], list[T3], list[T4], list[T5]]: ...
+def transpose(tuples: Iterable[tuple[T1, T2, T3, T4, T5]], default_num_returns=0) -> tuple[list[T1], list[T2], list[T3], list[T4], list[T5]]: ...
 @overload
-def transpose[T](tuples: Iterable[tuple[T, ...]], default_num_returns=0) -> tuple[list[T], ...]: ...
+def transpose(tuples: Iterable[tuple[T, ...]], default_num_returns=0) -> tuple[list[T], ...]: ...
 def transpose(tuples: Iterable[tuple], default_num_returns=0) -> tuple[list, ...]:
   output = tuple(zip(*tuples))
   if not output:

relib/processing_utils.py

@@ -1,5 +1,6 @@
 import re
 from typing import Any, Callable, Iterable, overload
+from .types import T
 
 __all__ = [
   "clamp",
@@ -12,7 +13,7 @@ __all__ = [
 def noop() -> None:
   pass
 
-def for_each[T](func: Callable[[T], Any], iterable: Iterable[T]) -> None:
+def for_each(func: Callable[[T], Any], iterable: Iterable[T]) -> None:
   for item in iterable:
     func(item)
 

relib/runtime_tools.py

@@ -8,6 +8,7 @@ from time import time
 from typing import Callable, Coroutine, Iterable, ParamSpec, TypeVar
 from .iter_utils import as_list
 from .processing_utils import noop
+from .types import T
 
 __all__ = [
   "as_async", "async_limit",
@@ -34,13 +35,13 @@ def clear_console() -> None:
 def console_link(text: str, url: str) -> str:
   return f"\033]8;;{url}\033\\{text}\033]8;;\033\\"
 
-async def worker[T](task: Coro[T], semaphore: asyncio.Semaphore, update=noop) -> T:
+async def worker(task: Coro[T], semaphore: asyncio.Semaphore, update=noop) -> T:
   async with semaphore:
     result = await task
     update()
     return result
 
-async def roll_tasks[T](tasks: Iterable[Coro[T]], workers=default_workers, progress=False) -> list[T]:
+async def roll_tasks(tasks: Iterable[Coro[T]], workers=default_workers, progress=False) -> list[T]:
   semaphore = asyncio.Semaphore(workers)
   if not progress:
     return await asyncio.gather(*[worker(task, semaphore) for task in tasks])

relib/type_utils.py

@@ -1,4 +1,5 @@
 from typing import Any
+from .types import T
 
 __all__ = [
   "as_any",
@@ -9,9 +10,9 @@ __all__ = [
 def as_any(obj: Any) -> Any:
   return obj
 
-def non_none[T](obj: T | None) -> T:
+def non_none(obj: T | None) -> T:
   assert obj is not None
   return obj
 
-def ensure_tuple[T](value: T | tuple[T, ...]) -> tuple[T, ...]:
+def ensure_tuple(value: T | tuple[T, ...]) -> tuple[T, ...]:
   return value if isinstance(value, tuple) else (value,)

relib/types.py

@@ -0,0 +1,16 @@
+from typing import TypeVar
+
+T = TypeVar("T")
+U = TypeVar("U")
+K = TypeVar("K")
+T1 = TypeVar("T1")
+T2 = TypeVar("T2")
+T3 = TypeVar("T3")
+T4 = TypeVar("T4")
+T5 = TypeVar("T5")
+K1 = TypeVar("K1")
+K2 = TypeVar("K2")
+K3 = TypeVar("K3")
+K4 = TypeVar("K4")
+K5 = TypeVar("K5")
+K6 = TypeVar("K6")

{relib-1.3.5.dist-info → relib-1.3.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: relib
-Version: 1.3.5
+Version: 1.3.7
 Project-URL: Repository, https://github.com/Reddan/relib.git
 Author: Hampus Hallman
 License: Copyright 2018-2025 Hampus Hallman
@@ -11,4 +11,4 @@ License: Copyright 2018-2025 Hampus Hallman
         
         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 License-File: LICENSE
-Requires-Python: >=3.12
+Requires-Python: >=3.10

relib-1.3.7.dist-info/RECORD

@@ -0,0 +1,12 @@
+relib/__init__.py,sha256=WerjUaM_sNvudjXFudLRtXB7viZWEW1RSinkDjrh4nE,163
+relib/dict_utils.py,sha256=EUfZi8sw_30Z4xtfyJYFy1COtDXGl6H5cya9X4ZyifI,3592
+relib/io_utils.py,sha256=cUyUFhrMCUDfkINhYo32QPaVGz3chqDO3ElymSCoWEg,1086
+relib/iter_utils.py,sha256=V0Sq64JM6M_g5yJvUVGhhLZ-v0x9RY0X8JpyVb_Iuxo,5755
+relib/processing_utils.py,sha256=kFb4izrR8vec9BFWeGSb-TXR54bbA4X3dxAfIBZItuI,1911
+relib/runtime_tools.py,sha256=6HpRXmAHHLq4bNRj6fSiaLQeHR2h3OdxFZxaB93fXhI,2979
+relib/type_utils.py,sha256=68yEhEIBCIKfsIT1u647avHVA_JjVvDYSdtLD3nCrJs,338
+relib/types.py,sha256=JzSGDl2L6tUWizGSsUpuyCKf-VKgtgfK_n21azSSMLM,288
+relib-1.3.7.dist-info/METADATA,sha256=k2jncYQhiZXcQV12Bjev_1QmA148Cu6YP4iRIVhV0uo,1295
+relib-1.3.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+relib-1.3.7.dist-info/licenses/LICENSE,sha256=9xVsdtv_-uSyY9Xl9yujwAPm4-mjcCLeVy-ljwXEWbo,1059
+relib-1.3.7.dist-info/RECORD,,

relib-1.3.5.dist-info/RECORD

@@ -1,11 +0,0 @@
-relib/__init__.py,sha256=WerjUaM_sNvudjXFudLRtXB7viZWEW1RSinkDjrh4nE,163
-relib/dict_utils.py,sha256=zuUkPI1uiElWUgt3ETdajG7S2grP5mX1qM0t2Cc1zy4,2968
-relib/io_utils.py,sha256=cUyUFhrMCUDfkINhYo32QPaVGz3chqDO3ElymSCoWEg,1086
-relib/iter_utils.py,sha256=xQOyNwYCc9fyKScyd56vx4CVCzZBDDROKVfnJuaInCM,5774
-relib/processing_utils.py,sha256=eMzjlxsEmfvtKafDITBWSp9D5RwegSWsUsvj1FpmBM0,1893
-relib/runtime_tools.py,sha256=50zfIXZwXXU6tGKM-1iS3FEax82vthgp-KNmvmIGlqE,2964
-relib/type_utils.py,sha256=oY96cAAux1JwhXgWFFyqEv_f-wwyPc_Hm6I9Yeisu_M,323
-relib-1.3.5.dist-info/METADATA,sha256=adnaXzA56Yff2cXRK79hAopNMnPs_rfwBBKs95l3neY,1295
-relib-1.3.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-relib-1.3.5.dist-info/licenses/LICENSE,sha256=9xVsdtv_-uSyY9Xl9yujwAPm4-mjcCLeVy-ljwXEWbo,1059
-relib-1.3.5.dist-info/RECORD,,