relib 1.3.1__tar.gz → 1.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: relib
-Version: 1.3.1
+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.1 → relib-1.3.2}/pyproject.toml

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

{relib-1.3.1 → 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",
   "interleave", "intersect",
   "list_split",
   "move_value",
-  "num_partitions",
   "reversed_enumerate",
-  "sized_partitions", "sort_by",
+  "seekable", "sort_by",
   "transpose",
 ]
 
@@ -36,7 +37,7 @@ 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(range(len(values))[::1], 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)))
@@ -50,18 +51,68 @@ def list_split[T](iterable: Iterable[T], sep: T) -> list[list[T]]:
   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)]
+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]: ...

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

@@ -4,7 +4,7 @@ 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__ = [
@@ -17,6 +17,7 @@ __all__ = [
 
 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)
@@ -27,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])
@@ -44,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: int | ThreadPoolExecutor = default_executor) -> Callable[[Callable[P, R]], Callable[P, Awaitable[R]]]:
+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()
@@ -57,10 +58,10 @@ def as_async(workers: int | ThreadPoolExecutor = default_executor) -> Callable[[
     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:

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

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