flpit 0.2.3__tar.gz → 0.2.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: flpit
-Version: 0.2.3
+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.3 → flpit-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flpit"
-version = "0.2.3"
+version = "0.2.4"
 description = "Fluent LINQ for Python — flip your iterables"
 readme = "README.md"
 requires-python = ">=3.12"

{flpit-0.2.3 → 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)