relib 1.3.0__tar.gz → 1.3.2__tar.gz

{relib-1.3.0 → relib-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: relib
-Version: 1.3.0
+Version: 1.3.2
 Project-URL: Repository, https://github.com/Reddan/relib.git
 Author: Hampus Hallman
 License: Copyright 2018-2025 Hampus Hallman

{relib-1.3.0 → relib-1.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "relib"
-version = "1.3.0"
+version = "1.3.2"
 requires-python = ">=3.12"
 dependencies = []
 authors = [

{relib-1.3.0 → relib-1.3.2}/relib/dict_utils.py

@@ -52,9 +52,8 @@ def get_at[T](d: dict, keys: Iterable[Any], default: T) -> T:
 
 def dict_firsts[T, K](pairs: Iterable[tuple[K, T]]) -> dict[K, T]:
   result: dict[K, T] = {}
-  for key, item in pairs:
-    if key not in result:
-      result[key] = item
+  for key, value in pairs:
+    result.setdefault(key, value)
   return result
 
 def group[T, K](pairs: Iterable[tuple[K, T]]) -> dict[K, list[T]]:
@@ -63,6 +62,16 @@ def group[T, K](pairs: Iterable[tuple[K, T]]) -> dict[K, list[T]]:
     values_by_key.setdefault(key, []).append(value)
   return values_by_key
 
+def flatten_dict_inner(d, prefix=()):
+  for key, value in d.items():
+    if not isinstance(value, dict) or value == {}:
+      yield prefix + (key,), value
+    else:
+      yield from flatten_dict_inner(value, prefix + (key,))
+
+def flatten_dict(deep_dict: dict, prefix=()) -> dict:
+  return dict(flatten_dict_inner(deep_dict, prefix))
+
 @overload
 def deepen_dict[K1, U](d: dict[tuple[K1], U]) -> dict[K1, U]: ...
 @overload
@@ -85,13 +94,3 @@ def deepen_dict(d: dict[tuple[Any, ...], Any]) -> dict:
       curr = curr.setdefault(key, {})
     curr[head] = value
   return output
-
-def flatten_dict_inner(d, prefix=()):
-  for key, value in d.items():
-    if not isinstance(value, dict) or value == {}:
-      yield prefix + (key,), value
-    else:
-      yield from flatten_dict_inner(value, prefix + (key,))
-
-def flatten_dict(deep_dict: dict, prefix=()) -> dict:
-  return dict(flatten_dict_inner(deep_dict, prefix))

{relib-1.3.0 → relib-1.3.2}/relib/iter_utils.py

@@ -1,16 +1,17 @@
-from itertools import chain
-from typing import Any, Iterable, Literal, overload
+from contextlib import contextmanager
+from itertools import chain, islice
+from typing import Any, Iterable, Literal, Self, overload
 from .dict_utils import dict_firsts
 
 __all__ = [
+  "chunked",
   "distinct_by", "distinct", "drop_none",
   "first", "flatten",
-  "intersect",
+  "interleave", "intersect",
   "list_split",
   "move_value",
-  "num_partitions",
   "reversed_enumerate",
-  "sized_partitions", "sort_by",
+  "seekable", "sort_by",
   "transpose",
 ]
 
@@ -36,11 +37,83 @@ def move_value[T](iterable: Iterable[T], from_i: int, to_i: int) -> list[T]:
   return values
 
 def reversed_enumerate[T](values: list[T] | tuple[T, ...]) -> Iterable[tuple[int, T]]:
-  return zip(reversed(range(len(values))), reversed(values))
+  return zip(range(len(values))[::-1], reversed(values))
 
 def intersect[T](*iterables: Iterable[T]) -> list[T]:
   return list(set.intersection(*map(set, iterables)))
 
+def interleave[T](*iterables: Iterable[T]) -> list[T]:
+  return flatten(zip(*iterables))
+
+def list_split[T](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]
+
+class seekable[T]:
+  def __init__(self, iterable: Iterable[T]):
+    self.index = 0
+    self.source = iter(iterable)
+    self.sink: list[T] = []
+
+  def __iter__(self):
+    return self
+
+  def __next__(self) -> T:
+    if len(self.sink) > self.index:
+      item = self.sink[self.index]
+    else:
+      item = next(self.source)
+      self.sink.append(item)
+    self.index += 1
+    return item
+
+  def __bool__(self):
+    return bool(self.lookahead(1))
+
+  def clear(self):
+    self.sink[:self.index] = []
+    self.index = 0
+
+  def seek(self, index: int) -> Self:
+    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:
+    return self.seek(self.index + count)
+
+  @contextmanager
+  def freeze(self):
+    def commit(offset: int = 0):
+      nonlocal initial_index
+      initial_index = self.index + offset
+    initial_index = self.index
+    try:
+      yield commit
+    finally:
+      self.seek(initial_index)
+
+  def lookahead(self, count: int) -> list[T]:
+    with self.freeze():
+      return list(islice(self, count))
+
+@overload
+def chunked[T](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, *, num_chunks=None, chunk_size=None):
+  values = values if isinstance(values, list) else list(values)
+  if isinstance(num_chunks, int):
+    chunk_size = (len(values) / num_chunks).__ceil__()
+  elif isinstance(chunk_size, int):
+    num_chunks = (len(values) / chunk_size).__ceil__()
+  assert isinstance(num_chunks, int) and isinstance(chunk_size, int)
+  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]: ...
 @overload
@@ -58,25 +131,6 @@ def flatten(iterable: Iterable, depth: int = 1) -> list:
     iterable = chain.from_iterable(iterable)
   return list(iterable)
 
-def list_split[T](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 sized_partitions[T](values: Iterable[T], part_size: int) -> list[list[T]]:
-  # "chunk"
-  if not isinstance(values, list):
-    values = list(values)
-  num_parts = (len(values) / part_size).__ceil__()
-  return [values[i * part_size:(i + 1) * part_size] for i in range(num_parts)]
-
-def num_partitions[T](values: Iterable[T], num_parts: int) -> list[list[T]]:
-  if not isinstance(values, list):
-    values = list(values)
-  part_size = (len(values) / num_parts).__ceil__()
-  return [values[i * part_size:(i + 1) * part_size] for i in range(num_parts)]
-
 @overload
 def transpose[T1, T2](tuples: Iterable[tuple[T1, T2]], default_num_returns=0) -> tuple[list[T1], list[T2]]: ...
 @overload

{relib-1.3.0 → relib-1.3.2}/relib/runtime_tools.py

@@ -4,20 +4,23 @@ import os
 from concurrent.futures import ThreadPoolExecutor
 from functools import partial, wraps
 from time import time
-from typing import Awaitable, Callable, Iterable, ParamSpec, TypeVar
+from typing import Callable, Coroutine, Iterable, ParamSpec, TypeVar
 from .processing_utils import noop
 
 __all__ = [
   "as_async", "async_limit",
   "clear_console", "console_link",
+  "default_executor", "default_workers",
   "roll_tasks",
   "measure_duration",
 ]
 
 P = ParamSpec("P")
 R = TypeVar("R")
+Coro = Coroutine[object, object, R]
 
 default_workers = min(32, (os.cpu_count() or 1) + 4)
+default_executor = ThreadPoolExecutor(max_workers=default_workers)
 
 def clear_console() -> None:
   os.system("cls" if os.name == "nt" else "clear")
@@ -25,13 +28,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: Awaitable[T], semaphore: asyncio.Semaphore, update=noop) -> T:
+async def worker[T](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[Awaitable[T]], workers=default_workers, progress=False) -> list[T]:
+async def roll_tasks[T](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])
@@ -42,10 +45,10 @@ async def roll_tasks[T](tasks: Iterable[Awaitable[T]], workers=default_workers,
     update = partial(pbar.update, 1)
     return await asyncio.gather(*[worker(task, semaphore, update) for task in tasks])
 
-def as_async(workers=default_workers) -> Callable[[Callable[P, R]], Callable[P, Awaitable[R]]]:
-  executor = ThreadPoolExecutor(max_workers=workers)
+def as_async(workers: int | ThreadPoolExecutor = default_executor) -> Callable[[Callable[P, R]], Callable[P, Coro[R]]]:
+  executor = ThreadPoolExecutor(max_workers=workers) if isinstance(workers, int) else workers
 
-  def on_fn(func: Callable[P, R]) -> Callable[P, Awaitable[R]]:
+  def on_fn(func: Callable[P, R]) -> Callable[P, Coro[R]]:
     @wraps(func)
     async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
       loop = asyncio.get_running_loop()
@@ -55,10 +58,10 @@ def as_async(workers=default_workers) -> Callable[[Callable[P, R]], Callable[P,
     return wrapper
   return on_fn
 
-def async_limit(workers=default_workers) -> Callable[[Callable[P, Awaitable[R]]], Callable[P, Awaitable[R]]]:
+def async_limit(workers=default_workers) -> Callable[[Callable[P, Coro[R]]], Callable[P, Coro[R]]]:
   semaphore = asyncio.Semaphore(workers)
 
-  def on_fn(func: Callable[P, Awaitable[R]]) -> Callable[P, Awaitable[R]]:
+  def on_fn(func: Callable[P, Coro[R]]) -> Callable[P, Coro[R]]:
     @wraps(func)
     async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
       async with semaphore:
@@ -79,7 +82,7 @@ class measure_duration:
   def __exit__(self, *_):
     duration = round(time() - self.start, 4)
     depth = len(active_mds) - 1
-    indent = ('──' * depth) + (' ' * (depth > 0))
-    text = '{}: {} seconds'.format(self.name, duration)
+    indent = "──" * depth + " " * (depth > 0)
+    text = f"{self.name}: {duration} seconds"
     print(indent + text)
     active_mds.remove(self)

{relib-1.3.0 → relib-1.3.2}/uv.lock

@@ -106,7 +106,7 @@ wheels = [
 
 [[package]]
 name = "relib"
-version = "1.3.0"
+version = "1.3.2"
 source = { editable = "." }
 
 [package.dev-dependencies]