flpit 0.2.1.dev6__tar.gz → 0.2.1.dev7__tar.gz

{flpit-0.2.1.dev6 → flpit-0.2.1.dev7}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "flpit"
-version = "0.2.1.dev6"
+version = "0.2.1.dev7"
 description = "Fluent LINQ for Python — flip your iterables"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -34,6 +34,7 @@ dev = [
     "pyright>=1.1.414",
     "pytest-benchmark>=5.3.0",
     "mypy>=2.4.0",
+    "httpx>=0.28.1",
 ]
 
 

{flpit-0.2.1.dev6 → flpit-0.2.1.dev7}/src/flpit/task.py

@@ -599,7 +599,7 @@ class Task(Generic[T]):
         Accepts Task instances and raw awaitables (including coroutine objects)
         positionally or in one iterable. Raw awaitables are scheduled
         automatically. The winning task is returned even if it failed or was
-        cancelled; inspect/await that task to observe
+        canceled; inspect/await that task to observe
         its outcome. Losing tasks continue running. An empty input is invalid.
         If multiple tasks are already complete at observation time, input order
         breaks the tie deterministically.
@@ -612,6 +612,22 @@ class Task(Generic[T]):
             cls.run(_when_any_coroutine, normalized, name=name, token=token),
         )
 
+    @staticmethod
+    async def collect(*tasks: Task[Any] | list[Task[Any]]):
+        """
+        Yields tasks as they complete. Accepts either a list or loose positional tasks.
+        """
+        # FIX: If it's a list or tuple, extract and cast the FIRST element to a mutable list
+        if len(tasks) == 1 and isinstance(tasks[0], (list, tuple)):
+            pending = list(tasks[0])  # Converts the inner container into a fresh list
+        else:
+            pending = list(tasks)     # Converts the *tasks tuple into a fresh list
+
+        while pending:
+            finished_task = await Task.when_any(pending)
+            pending.remove(finished_task)  # Safe to call, because pending is ALWAYS a list!
+            yield finished_task
+
     @classmethod
     def delay(
             cls,
@@ -1574,4 +1590,21 @@ def task(async_function: Callable[..., Any]) -> Callable[..., Task[Any]]:
     def wrapper(*args: Any, **kwargs: Any) -> Task[Any]:
         return Task.run(async_function, *args, **kwargs)
 
-    return wrapper
+    return wrapper
+
+
+def coro_task(async_function: Callable[..., Any]) -> Callable[..., Task[Any]]:
+    """
+    | Wraps an async coroutine function to be compatible with Task.run(coro)
+
+    Use with caution as this transfers execution control to an isolated asyncio loop runner.
+    """
+    import asyncio
+    @functools.wraps(async_function)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        with asyncio.Runner() as runner:
+            # Call the function with its arguments to generate the Coroutine object instance
+            coro = async_function(*args, **kwargs)
+            return runner.run(coro)
+
+    return task(wrapper)