flpit 0.2.2__tar.gz → 0.2.4__tar.gz

{flpit-0.2.2 → flpit-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: flpit
-Version: 0.2.2
+Version: 0.2.4
 Summary: Fluent LINQ for Python — flip your iterables
 Project-URL: Homepage, https://github.com/riemar/flpit
 Project-URL: Repository, https://github.com/riemar/flpit

{flpit-0.2.2 → flpit-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flpit"
-version = "0.2.2"
+version = "0.2.4"
 description = "Fluent LINQ for Python — flip your iterables"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -55,7 +55,7 @@ include = ["src/flp", "src/flpit"]
 [tool.pyrefly]
 project-includes = ["src"]
 project-excludes = ["**/__pycache__", "tests"]
-search-path = ["src"]
+search-path = ["src", "typing"]
 preset = "strict"
 
 [tool.pytest.ini_options]

{flpit-0.2.2 → flpit-0.2.4}/src/flpit/core/linq.py

@@ -14,7 +14,6 @@ from itertools import islice
 from typing import (
     Any,
     Callable,
-    Generic,
     Iterable,
     Iterator,
     Collection,
@@ -27,14 +26,14 @@ from typing import (
     Union,
     override,
     overload,
-    cast as typing_cast, BinaryIO,
+    cast as typing_cast,
+    BinaryIO,
+    Concatenate,
+    Sized
 )
 
-import flpit.json
 from flpit.json import JsonConvert, JsonSerializerOptions
 
-TItem = TypeVar("TItem")
-TResult = TypeVar("TResult")
 TKey = TypeVar("TKey")
 TOther = TypeVar("TOther")
 TAccumulate = TypeVar("TAccumulate")
@@ -114,16 +113,24 @@ class ArgumentOutOfBoundsError(ArgumentError):
         super().__init__("Offset and length were out of bounds for the array or count is greater than the number of elements from index to the end of the source collection.")
 
 
-def _guard_empty(func: Callable[..., Any]) -> Callable[..., Any]:
-    """Catches Python's native empty-sequence ValueError and re-raises LINQ-compliant error."""
+def _guard_empty[SelfT: Sized, R, **P](
+        func: Callable[Concatenate[SelfT, P], R],
+) -> Callable[Concatenate[SelfT, P], R]:
+    """Translate empty-sequence ValueError into EmptySequenceError."""
+
     @wraps(func)
-    def wrapper(self: Any, *args: Any, **kwargs: Any) -> Any:
+    def wrapper(
+            self: SelfT,
+            *args: P.args,
+            **kwargs: P.kwargs,
+    ) -> R:
         try:
             return func(self, *args, **kwargs)
         except ValueError as e:
-            if not self._FlpList__list.data:
+            if len(self) == 0:
                 raise EmptySequenceError() from e
             raise
+
     return wrapper
 
 
@@ -137,7 +144,7 @@ def dotnet_context() -> AbstractContextManager[decimal.Context]:
     return decimal.localcontext(ctx)
 
 
-class _FactoryIterable(Iterable[TItem], Generic[TItem]):
+class _FactoryIterable[TItem](Iterable[TItem]):
     """
     Wraps a generator factory function into a clean Iterable[T].
     Ensures __iter__ produces a brand-new iterator instance on every call
@@ -152,7 +159,7 @@ class _FactoryIterable(Iterable[TItem], Generic[TItem]):
         return self._factory()
 
 
-class FlpIt(Iterable[TItem], Generic[TItem]):
+class FlpIt[TItem](Iterable[TItem]):
     """
     | Fluent Iterable
     Lazy evaluation wrapper around an iterable, inspired by .NET LINQ's
@@ -173,7 +180,7 @@ class FlpIt(Iterable[TItem], Generic[TItem]):
         return iter(self._iterable)
 
     # noinspection unused-parameter
-    def as_type(self, target_type: Type[TResult]) -> FlpIt[TResult]:
+    def as_type[TResult](self, target_type: Type[TResult]) -> FlpIt[TResult]:
         """Zero-cost static type hint update returning self directly without checks or allocations."""
         return self  # type: ignore[return-value]
 
@@ -257,7 +264,7 @@ class FlpIt(Iterable[TItem], Generic[TItem]):
         # return typing_cast(FlpIt[TItem], FlpIt[TItem](_FactoryIterable(_generator)))
         return FlpIt[TItem](_FactoryIterable(_generator))
 
-    def select(self, selector: Callable[[TItem], TResult]) -> FlpIt[TResult]:
+    def select[TResult](self, selector: Callable[[TItem], TResult]) -> FlpIt[TResult]:
         """Projects each element into a new form."""
         def _generator() -> Iterator[TResult]:
             for item in self:
@@ -265,7 +272,7 @@ class FlpIt(Iterable[TItem], Generic[TItem]):
 
         return FlpIt(_FactoryIterable(_generator))
 
-    def select_many(
+    def select_many[TResult](
             self, selector: Callable[[TItem], Iterable[TResult]]
     ) -> FlpIt[TResult]:
         """Flattens sequence projections."""
@@ -310,7 +317,7 @@ class FlpIt(Iterable[TItem], Generic[TItem]):
 
         return FlpIt(_FactoryIterable(_generator))
 
-    def cast(self, target_type: Type[TResult]) -> FlpIt[TResult]:
+    def cast[TResult](self, target_type: Type[TResult]) -> FlpIt[TResult]:
         """Casts elements to a specified type or raises TypeError if cast fails."""
         def _generator() -> Iterator[TResult]:
             for item in self:
@@ -322,7 +329,7 @@ class FlpIt(Iterable[TItem], Generic[TItem]):
 
         return FlpIt(_FactoryIterable(_generator))
 
-    def of_type(self, target_type: Type[TResult]) -> FlpIt[TResult]:
+    def of_type[TResult](self, target_type: Type[TResult]) -> FlpIt[TResult]:
         """Filters the elements of an Iterable based on a specified type."""
         def _generator() -> Iterator[TResult]:
             for item in self:
@@ -360,7 +367,7 @@ class FlpIt(Iterable[TItem], Generic[TItem]):
     def zip(self, second: Iterable[TOther]) -> FlpIt[tuple[TItem, TOther]]: ...
 
     @overload
-    def zip(
+    def zip[TResult, TOther](
             self,
             second: Iterable[TOther],
             result_selector: Callable[[TItem, TOther], TResult],
@@ -598,7 +605,7 @@ class FlpIt(Iterable[TItem], Generic[TItem]):
             return item
         raise EmptySequenceError() if predicate is _SENTINEL else NoMatchError()
 
-    def first_or_default(
+    def first_or_default[TResult](
             self, default: TResult, predicate: Callable[[TItem], bool] | _Sentinel = _SENTINEL
     ) -> Union[TItem, TResult]:
         """Returns the first element matching a predicate, or a default value."""
@@ -673,14 +680,7 @@ class _NoneOrderKey:
 
 _NONE_ORDER_KEY = _NoneOrderKey()
 
-def _none_aware_key(
-        selector: Callable[[TItem], Any],
-        item: TItem,
-) -> Any:
-    key = selector(item)
-    return _NONE_ORDER_KEY if key is None else key
-
-class OrderedIt(FlpIt[TItem]):
+class OrderedIt[TItem](FlpIt[TItem]):
     __slots__ = ("_criteria",)
 
     def __init__(
@@ -701,13 +701,21 @@ class OrderedIt(FlpIt[TItem]):
         else:
             self._criteria = _criteria + ((selector, descending),)
 
+    @staticmethod
+    def __none_aware_key(
+            selector: Callable[[TItem], Any],
+            item: TItem,
+    ) -> Any:
+        key = selector(item)
+        return _NONE_ORDER_KEY if key is None else key
+
     @override
     def __iter__(self) -> Iterator[TItem]:
         items = list(self._iterable)
 
         for selector, descending in reversed(self._criteria):
             items.sort(
-                key=partial(_none_aware_key, selector),
+                key=partial(self.__none_aware_key, selector),
                 reverse=descending,
             )
 
@@ -736,7 +744,7 @@ class OrderedIt(FlpIt[TItem]):
         )
 
 
-class Grouping(FlpIt[TItem], Generic[TKey, TItem]):
+class Grouping[TKey, TItem](FlpIt[TItem]):
     """Represents a collection of elements sharing a common key (.NET IGrouping<TKey, TElement>)."""
     __slots__ = ("_key", )
 
@@ -760,7 +768,7 @@ class Grouping(FlpIt[TItem], Generic[TKey, TItem]):
         return self.key == other.key and self.to_list() == other.to_list()
 
 
-class FlpList(Collection[TItem], Generic[TItem]):
+class FlpList[TItem](Collection[TItem]):
     """
     | Fluent List
     A materialized list extending UserList that yields lazy FlpIt instances for query operations.
@@ -781,7 +789,7 @@ class FlpList(Collection[TItem], Generic[TItem]):
     # =====================================================================
     # 1. THE ABC CONTRACT
     # =====================================================================
-    def __iter__(self) -> Iterator[Any]:
+    def __iter__(self) -> Iterator[TItem]:
         return self.__list.__iter__()
 
     def __len__(self) -> int:
@@ -1032,17 +1040,16 @@ class FlpList(Collection[TItem], Generic[TItem]):
     def concat(self, second: Iterable[TItem]) -> FlpIt[TItem]:
         return FlpIt(self.__list.data).concat(second)
 
-    # noinspection unused-parameter
-    def as_type(self, target_type: Type[TResult]) -> FlpList[TResult]:
-        return self  # type: ignore[return-value]
+    def as_type[TResult](self, target_type: Type[TResult]) -> FlpList[TResult]:
+        return typing_cast(FlpList[TResult], self)
 
     def where(self, predicate: Callable[[TItem], bool]) -> FlpIt[TItem]:
         return FlpIt[TItem](self.__list.data).where(predicate)
 
-    def select(self, selector: Callable[[TItem], TResult]) -> FlpIt[TResult]:
+    def select[TResult](self, selector: Callable[[TItem], TResult]) -> FlpIt[TResult]:
         return FlpIt(self.__list.data).select(selector)
 
-    def select_many(
+    def select_many[TResult](
             self, selector: Callable[[TItem], Iterable[TResult]]
     ) -> FlpIt[TResult]:
         return FlpIt(self.__list.data).select_many(selector)
@@ -1053,10 +1060,10 @@ class FlpList(Collection[TItem], Generic[TItem]):
     def take(self, count: int) -> FlpIt[TItem]:
         return FlpIt(self.__list.data).take(count)
 
-    def cast(self, target_type: Type[TResult]) -> FlpIt[TResult]:
+    def cast[TResult](self, target_type: Type[TResult]) -> FlpIt[TResult]:
         return FlpIt(self.__list.data).cast(target_type)
 
-    def of_type(self, target_type: Type[TResult]) -> FlpIt[TResult]:
+    def of_type[TResult](self, target_type: Type[TResult]) -> FlpIt[TResult]:
         return FlpIt(self.__list.data).of_type(target_type)
 
     def distinct(self) -> FlpIt[TItem]:
@@ -1071,7 +1078,7 @@ class FlpList(Collection[TItem], Generic[TItem]):
     def zip(self, second: Iterable[TOther]) -> FlpIt[tuple[TItem, TOther]]: ...
 
     @overload
-    def zip(
+    def zip[TResult, TOther](
             self,
             second: Iterable[TOther],
             result_selector: Callable[[TItem, TOther], TResult],
@@ -1204,7 +1211,7 @@ class FlpList(Collection[TItem], Generic[TItem]):
 
         raise EmptySequenceError() if predicate is _SENTINEL else NoMatchError()
 
-    def first_or_default(
+    def first_or_default[TResult](
             self, default: TResult, predicate: Callable[[TItem], bool] | _Sentinel = _SENTINEL
     ) -> TItem | TResult:
         return FlpIt(self.__list.data).first_or_default(default, predicate)

{flpit-0.2.2 → flpit-0.2.4}/src/flpit/task.py

@@ -49,7 +49,7 @@ from collections.abc import Awaitable, Callable, Coroutine
 import flpit
 
 T = TypeVar("T")
-_LOG = logging.getLogger("tinytask")
+_LOG = logging.getLogger("task")
 _MISSING = object()
 _WAKE = object()
 
@@ -71,7 +71,7 @@ class OperationCanceledError(Exception):
         super().__init__(message)
 
 
-# Backwards-compatible spelling used by the first TinyTask prototype.
+# Backwards-compatible spelling used by the first Task prototype.
 CancelledError = OperationCanceledError
 
 
@@ -236,7 +236,7 @@ class CancellationToken:
 
     def throw_if_cancellation_requested(self) -> None:
         if self.is_cancellation_requested:
-            raise OperationCanceledError("Cancellation was requested")
+            raise OperationCanceledError("Cancellation was requested", token=self)
 
     def register(self, callback: Callable[[], Any]) -> CancellationTokenRegistration:
         if not callable(callback):
@@ -393,8 +393,13 @@ class _Operation:
 
 
 class _Sleep(_Operation):
-    def __init__(self, runtime: "_Runtime", delay: float) -> None:
-        super().__init__(runtime)
+    def __init__(
+            self,
+            runtime: "_Runtime",
+            delay: float,
+            token: CancellationToken | None = None,
+    ) -> None:
+        super().__init__(runtime, token)
         self.delay = delay
         self.deadline = time.monotonic() + delay
 
@@ -471,8 +476,12 @@ async def _invoke_background(
     return result
 
 
-async def _delay_coroutine(runtime: "_Runtime", delay: float) -> None:
-    await _Sleep(runtime, delay)
+async def _delay_coroutine(
+        runtime: "_Runtime",
+        delay: float,
+        token: CancellationToken | None = None,
+) -> None:
+    await _Sleep(runtime, delay, token=token)
 
 
 class Task(Generic[T]):
@@ -487,11 +496,10 @@ class Task(Generic[T]):
             self,
             runtime: "_Runtime",
             *,
-            name: str | None = None,
             token: CancellationToken | None = None,
     ) -> None:
         self._runtime = runtime
-        self.name = name or f"Task-{id(self):x}"
+        self.name = f"Task-{id(self):x}"
         self._state = self.PENDING
         self._result: Any = None
         self._exception: BaseException | None = None
@@ -560,17 +568,42 @@ class Task(Generic[T]):
             raise TypeError("handler must be callable or None")
         _get_runtime().set_exception_handler(handler)
 
+    @overload
+    @classmethod
+    def run[R](
+            cls,
+            work: Callable[..., Coroutine[Any, Any, R]],
+            /,
+            *args: Any,
+            token: CancellationToken | None = None,
+            pass_token: bool = False,
+            **kwargs: Any,
+    ) -> Task[R]: ...
+
+    @overload
+    @classmethod
+    def run[R](
+            cls,
+            work: Callable[..., R],
+            /,
+            *args: Any,
+            token: CancellationToken | None = None,
+            pass_token: bool = False,
+            **kwargs: Any,
+    ) -> Task[R]: ...
+
     @classmethod
     def run(
             cls,
-            work: Callable[..., T],
+            work: Callable[..., Any],
             /,
             *args: Any,
-            name: str | None = None,
             token: CancellationToken | None = None,
             pass_token: bool = False,
             **kwargs: Any,
-    ) -> "Task[T]":
+    ) -> Task[Any]:
+        # Keep your existing implementation here.
+        ...
         """Schedule a coroutine/awaitable or ordinary callable.
 
         Ordinary functions run in the bounded worker pool. ``token`` controls
@@ -594,7 +627,7 @@ class Task(Generic[T]):
                 work.close()
             raise ValueError("pass_token=True requires an explicit token")
         runtime = _get_runtime()
-        task = cls(runtime, name=name, token=token)
+        task = cls(runtime, token=token)
         task._pass_token = pass_token
         runtime._submit(task, work, args, kwargs)
         return task
@@ -602,9 +635,7 @@ class Task(Generic[T]):
     @classmethod
     def when_all(
             cls,
-            *tasks: Any,
-            name: str | None = None,
-            token: CancellationToken | None = None,
+            *tasks: Awaitable[T]
     ) -> "Task[list[Any]]":
         """Complete when every supplied task completes, preserving input order.
 
@@ -615,22 +646,16 @@ class Task(Generic[T]):
         several children fail, TaskAggregateError exposes all their exceptions.
         If there are no tasks, the result is an empty list.
         """
-        if token is not None and not isinstance(token, CancellationToken):
-            raise TypeError("token must be a CancellationToken")
         normalized = _normalize_tasks(tasks, allow_empty=True)
         return cast(
             "Task[list[Any]]",
-            # todo: make run type compatible via Generator[Y, S, R]
-            # pyrefly: ignore [bad-argument-type]
-            cls.run(_when_all_coroutine, normalized, name=name, token=token),
+            cls.run(_when_all_coroutine, normalized),
         )
 
     @classmethod
     def when_any(
             cls,
             *tasks: Any,
-            name: str | None = None,
-            token: CancellationToken | None = None,
     ) -> "Task[Task[Any]]":
         """Complete when one supplied task completes and return that task.
 
@@ -642,14 +667,10 @@ class Task(Generic[T]):
         If multiple tasks are already complete at observation time, input order
         breaks the tie deterministically.
         """
-        if token is not None and not isinstance(token, CancellationToken):
-            raise TypeError("token must be a CancellationToken")
         normalized = _normalize_tasks(tasks, allow_empty=False)
         return cast(
             "Task[Task[Any]]",
-            # todo: make run type compatible via Generator[Y, S, R]
-            # pyrefly: ignore [bad-argument-type]
-            cls.run(_when_any_coroutine, normalized, name=name, token=token),
+            cls.run(_when_any_coroutine, normalized),
         )
 
     @staticmethod
@@ -674,7 +695,6 @@ class Task(Generic[T]):
             seconds: float,
             *,
             token: CancellationToken | None = None,
-            name: str | None = None,
     ) -> "Task[None]":
         """Return a task completed after seconds without blocking a worker."""
         if seconds < 0:
@@ -682,12 +702,12 @@ class Task(Generic[T]):
         if token is not None and not isinstance(token, CancellationToken):
             raise TypeError("token must be a CancellationToken")
         runtime = _get_runtime()
-        task: Task[None] = cls(runtime, name=name or f"Delay({seconds:g}s)", token=token)
+        task: Task[None] = cls(runtime, token=token)
         # During graceful cancellation, allow an already-running coroutine to
         # create a delay for async cleanup. External callers are still rejected.
         runtime._submit_coroutine(
             task,
-            _delay_coroutine(runtime, seconds),
+            _delay_coroutine(runtime, seconds, token),
             allow_during_shutdown=runtime.is_runtime_thread(),
         )
         return task
@@ -754,16 +774,6 @@ class Task(Generic[T]):
             return self._exception
         return OperationCanceledError(f"{self.name} was cancelled")
 
-    def cancel(self) -> bool:
-        """Request cancellation of this Task, independently of other token users."""
-        if self.done():
-            return False
-        try:
-            self._runtime._post(lambda: self._cancel_on_runtime(), internal=True)
-        except RuntimeShutdownError:
-            return False
-        return True
-
     def __await__(self) -> Generator[Any, T, T]:
         if self.done():
             return self._raise_or_return()
@@ -780,11 +790,6 @@ class Task(Generic[T]):
             raise InvalidStateError(f"{self.name} has not completed")
         return cast(T, self._result)
 
-    def _bind_token(self) -> None:
-        if not self._token.can_be_cancelled or self._token_registration is not None:
-            return
-        self._token_registration = self._token.register(self.cancel)
-
     def _cancel_on_runtime(self) -> None:
         if self.done():
             return
@@ -1152,7 +1157,7 @@ class _Runtime:
         self._max_pending_background = max_pending_background
         self._pending_background: deque[tuple[Task[Any], _BackgroundCall]] = deque()
         self._background_active = 0  # scheduler-thread-owned submitted call count
-        self._executor = ThreadPoolExecutor(max_workers=max_workers, thread_name_prefix="tinytask-io")
+        self._executor = ThreadPoolExecutor(max_workers=max_workers, thread_name_prefix="Thread")
         self._inflight_lock = threading.Condition()
         self._inflight_futures: set[Future[Any]] = set()
         self._current_task: Task[Any] | None = None
@@ -1181,8 +1186,8 @@ class _Runtime:
                 return
             with self._state_lock:
                 if self._closed or self._shutdown_requested:
-                    raise RuntimeShutdownError("TinyTask runtime is shutting down")
-            self._thread = threading.Thread(target=self._loop, name="TinyTask-runtime", daemon=True)
+                    raise RuntimeShutdownError("Task runtime is shutting down")
+            self._thread = threading.Thread(target=self._loop, name="Task-runtime", daemon=True)
             self._thread.start()
             self._started.wait()
 
@@ -1199,8 +1204,8 @@ class _Runtime:
                 handler({**context, "exception": error})
                 return
             except Exception:
-                _LOG.exception("TinyTask exception handler itself failed")
-        message = str(context.get("message", "Unexpected TinyTask runtime error"))
+                _LOG.exception("Task exception handler itself failed")
+        message = str(context.get("message", "Unexpected Task runtime error"))
         _LOG.error("%s", message, exc_info=(type(error), error, error.__traceback__))
 
     def _call_sync(self, callback: Callable[[], T], *, internal: bool = False) -> T:
@@ -1230,7 +1235,7 @@ class _Runtime:
             thread = self._thread
             if thread is None or not thread.is_alive():
                 raise RuntimeShutdownError(
-                    "TinyTask runtime stopped before the scheduled operation ran"
+                    "Task runtime stopped before the scheduled operation ran"
                 )
         if "error" in outcome:
             raise outcome["error"]
@@ -1241,7 +1246,7 @@ class _Runtime:
         execute_inline = False
         with self._state_lock:
             if self._closed or self._stopping or (self._shutdown_requested and not internal):
-                raise RuntimeShutdownError("TinyTask runtime is shutting down")
+                raise RuntimeShutdownError("Task runtime is shutting down")
             if self.is_runtime_thread():
                 execute_inline = True
             else:
@@ -1312,7 +1317,6 @@ class _Runtime:
             return
         task._coroutine = coroutine
         self._tasks.add(task)
-        task._bind_token()
         self._schedule(task)
 
     def _schedule(
@@ -1361,7 +1365,7 @@ class _Runtime:
         if not isinstance(yielded, _Operation):
             raise RuntimeError(
                 f"{task.name} yielded unsupported object {yielded!r}; "
-                "this runtime only supports TinyTask awaitables"
+                "this runtime only supports Task awaitables"
             )
         if yielded.runtime is not self:
             raise RuntimeError("awaitable belongs to a different runtime")
@@ -1614,7 +1618,7 @@ class _Runtime:
                 callback()
             except BaseException as error:
                 self._report_exception(
-                    {"message": "Unhandled exception in TinyTask scheduler callback", "callback": callback},
+                    {"message": "Unhandled exception in Task scheduler callback", "callback": callback},
                     error,
                 )
 
@@ -1704,7 +1708,7 @@ class _Runtime:
                     if self._stopping or self.closed:
                         break
                     self._report_exception(
-                        {"message": "Selector failed; stopping TinyTask runtime"}, error
+                        {"message": "Selector failed; stopping Task runtime"}, error
                     )
                     self._stopping = True
                     break
@@ -1716,7 +1720,7 @@ class _Runtime:
                     )
                     self._stopping = True
         except BaseException as error:
-            self._report_exception({"message": "Fatal error in TinyTask scheduler loop"}, error)
+            self._report_exception({"message": "Fatal error in Task scheduler loop"}, error)
             self._stopping = True
         finally:
             # Stop accepting work before releasing scheduler resources. The
@@ -1771,7 +1775,7 @@ class _Runtime:
         runtime_stopped = thread is None or not thread.is_alive()
         if not runtime_stopped:
             self._report_exception(
-                {"message": "TinyTask scheduler thread did not stop before timeout"},
+                {"message": "Task scheduler thread did not stop before timeout"},
                 TimeoutError("scheduler shutdown timed out"),
             )
 
@@ -1825,7 +1829,7 @@ def _shutdown_at_exit() -> None:
     try:
         Task.shutdown(grace_timeout=0.2, worker_timeout=0.2)
     except BaseException:
-        _LOG.exception("Error during TinyTask interpreter shutdown")
+        _LOG.exception("Error during Task interpreter shutdown")
 
 
 atexit.register(_shutdown_at_exit)