relib 1.3.1__py3-none-any.whl → 1.3.3__py3-none-any.whl

relib/iter_utils.py

@@ -1,16 +1,18 @@
-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",
+  "partition",
   "reversed_enumerate",
-  "sized_partitions", "sort_by",
+  "seekable", "sort_by",
   "transpose",
 ]
 
@@ -36,7 +38,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 +52,77 @@ 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)]
+def partition[T](iterable: Iterable[tuple[bool, T]]) -> tuple[list[T], list[T]]:
+  true_values, false_values = [], []
+  for predicate, value in iterable:
+    if predicate:
+      true_values.append(value)
+    else:
+      false_values.append(value)
+  return true_values, false_values
+
+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/runtime_tools.py

@@ -1,39 +1,45 @@
 import asyncio
 import contextvars
 import os
+import sys
 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",
+  "raise_if_interrupt", "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 raise_if_interrupt():
+  if sys.exc_info()[0] in (KeyboardInterrupt, SystemExit):
+     raise
+
 def clear_console() -> None:
   os.system("cls" if os.name == "nt" else "clear")
 
 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 +50,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 +63,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.dist-info → relib-1.3.3.dist-info}/METADATA

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

{relib-1.3.1.dist-info → relib-1.3.3.dist-info}/RECORD

@@ -1,11 +1,11 @@
 relib/__init__.py,sha256=WerjUaM_sNvudjXFudLRtXB7viZWEW1RSinkDjrh4nE,163
 relib/dict_utils.py,sha256=jqW6bYSaQMt2AC2KFzDJKyl88idyMttWxXDu3t-fA5I,2980
 relib/io_utils.py,sha256=EtnIGQmLXjoHUPFteB5yPXDD3wGLvH4O3CahlCebXDQ,555
-relib/iter_utils.py,sha256=5N5WVx2oZmZSxv8EnMbKeDKsAOlmPJkEARscwC4zToo,3854
+relib/iter_utils.py,sha256=r9tus9F_obwXsHE8Jk8H9_ZPdOgtBI6WnpDxI6La-to,5477
 relib/processing_utils.py,sha256=eMzjlxsEmfvtKafDITBWSp9D5RwegSWsUsvj1FpmBM0,1893
-relib/runtime_tools.py,sha256=l7B-C3Dz8o3ffRXHC2ysyf59QfbDrzOd-KCxPgyohnE,2842
+relib/runtime_tools.py,sha256=9N8gn3WCfqyS6D3Qs4l2nDja_NxDVVF-7hHIVrXA7Fc,2968
 relib/type_utils.py,sha256=oY96cAAux1JwhXgWFFyqEv_f-wwyPc_Hm6I9Yeisu_M,323
-relib-1.3.1.dist-info/METADATA,sha256=J_X6XPYfnT_MNGLel5k8UHThx2N7eV6YK9SzQ9xcs-M,1295
-relib-1.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-relib-1.3.1.dist-info/licenses/LICENSE,sha256=9xVsdtv_-uSyY9Xl9yujwAPm4-mjcCLeVy-ljwXEWbo,1059
-relib-1.3.1.dist-info/RECORD,,
+relib-1.3.3.dist-info/METADATA,sha256=3z1-dTnOlkjYiy54JQ2VQOs0zy5_kyP4Bk33l1YuAoQ,1295
+relib-1.3.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+relib-1.3.3.dist-info/licenses/LICENSE,sha256=9xVsdtv_-uSyY9Xl9yujwAPm4-mjcCLeVy-ljwXEWbo,1059
+relib-1.3.3.dist-info/RECORD,,