cli2 5.0.0rc9__tar.gz → 5.0.0rc12__tar.gz

{cli2-5.0.0rc9/cli2.egg-info → cli2-5.0.0rc12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: cli2
-Version: 5.0.0rc9
+Version: 5.0.0rc12
 Summary: image:: https://yourlabs.io/oss/cli2/badges/master/pipeline.svg
 Home-page: https://yourlabs.io/oss/cli2
 Author: James Pic
@@ -13,9 +13,6 @@ Requires-Dist: docstring_parser
 Requires-Dist: pyyaml
 Requires-Dist: pygments
 Requires-Dist: structlog
-Provides-Extra: client
-Requires-Dist: httpx; extra == "client"
-Requires-Dist: truststore; extra == "client"
 Provides-Extra: test
 Requires-Dist: freezegun; extra == "test"
 Requires-Dist: pytest; extra == "test"

{cli2-5.0.0rc9 → cli2-5.0.0rc12}/cli2/__init__.py

@@ -9,7 +9,7 @@ from .cli import (
     Group,
     EntryPoint,
 )
-from .asyncio import async_resolve, async_run
+from .asyncio import async_resolve, async_run, Queue
 from .colors import colors as c
 
 from .configuration import Configuration, cfg

cli2-5.0.0rc12/cli2/asyncio.py

@@ -0,0 +1,130 @@
+import asyncio
+import inspect
+from . import display
+from .log import log
+
+
+def async_iter(obj):
+    """ Check if an object is an async iterable. """
+    return inspect.isasyncgen(obj) or hasattr(obj, '__aiter__')
+
+
+async def async_resolve(result, output=False):
+    """
+    Recursively resolve awaitables and async iterables.
+
+    :param result: The awaitable or async iterable to resolve
+    :param output: If True, print results as they are resolved. If False,
+                   collect results.
+
+    :return: The resolved value(s). If output is True, returns None. If output
+             is False, returns a list of resolved values from async iterables.
+    """
+    while inspect.iscoroutine(result):
+        result = await result
+    if async_iter(result):
+        results = []
+        async for _ in result:
+            if output:
+                if (
+                    not inspect.iscoroutine(_)
+                    and not inspect.isasyncgen(_)
+                ):
+                    display.print(_)
+                else:
+                    await async_resolve(_, output=output)
+            else:
+                results.append(await async_resolve(_))
+        return None if output else results
+    return result
+
+
+def async_run(coroutine):
+    """Run an async coroutine in the current event loop or create a new one.
+
+    If an event loop is already running, creates a task in that loop.
+    If no event loop is running, creates a new one and runs the coroutine.
+
+    :param coroutine: The coroutine to run (return value of an async function)
+    :return: The result of the coroutine execution
+    """
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(coroutine)
+    else:
+        return loop.create_task(coroutine)
+
+
+class Queue(asyncio.Queue):
+    """
+    An async queue with worker pool for concurrent task processing.
+
+    Extends asyncio.Queue to manage a pool of worker tasks that process items
+    from the queue concurrently.
+
+    .. code-block:: python
+
+        # will run 2 at the time
+        queue = cli2.Queue(num_workers=2)
+        # call like asyncio.run
+        await queue.run(foo(), bar(), other())
+
+    .. py:attribute:: num_workers
+
+        Number of concurrent workers (default: 12)
+
+    .. py:attribute:: results
+
+        List of results from completed tasks, order of results not garanteed
+        due to concurrency.
+    """
+
+    def __init__(self, *args, num_workers=12, **kwargs):
+        """Initialize the queue with worker pool.
+
+        :param num_workers: Number of concurrent workers (default: 12)
+        :paarm *args: Positional arguments for asyncio.Queue
+        :param **kwargs: Keyword arguments for asyncio.Queue
+        """
+        self.num_workers = num_workers or 12
+        self.results = []
+        super().__init__(*args, **kwargs)
+
+    async def run(self, *tasks):
+        """
+        Run tasks through the worker pool.
+
+        :param tasks: Coroutines
+        """
+        self.results = []
+
+        for task in tasks:
+            await self.put(task)
+
+        workers = [
+            asyncio.create_task(self.worker())
+            for i in range(self.num_workers)
+        ]
+
+        await self.join()
+        for worker in workers:
+            worker.cancel()
+
+    async def worker(self):
+        """Worker task that processes items from the queue.
+
+        Continuously gets tasks from the queue, executes them, and stores
+        results.
+        Handles exceptions by logging them.
+        """
+        while True:
+            task = await self.get()
+            try:
+                result = await task
+            except:  # noqa
+                log.exception()
+            else:
+                self.results.append(result)
+            finally:
+                self.task_done()

{cli2-5.0.0rc9 → cli2-5.0.0rc12}/cli2/display.py

@@ -7,16 +7,11 @@ Generic pretty display utils.
     force it with :envvar:`FORCE_COLOR`, ie. gitlab-ci etc
 """
 import difflib
+import json
 import os
 import sys
 import yaml
 
-try:
-    import jsonlight as json
-except ImportError:
-    import json
-
-
 _print = print
 
 

{cli2-5.0.0rc9 → cli2-5.0.0rc12/cli2.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: cli2
-Version: 5.0.0rc9
+Version: 5.0.0rc12
 Summary: image:: https://yourlabs.io/oss/cli2/badges/master/pipeline.svg
 Home-page: https://yourlabs.io/oss/cli2
 Author: James Pic
@@ -13,9 +13,6 @@ Requires-Dist: docstring_parser
 Requires-Dist: pyyaml
 Requires-Dist: pygments
 Requires-Dist: structlog
-Provides-Extra: client
-Requires-Dist: httpx; extra == "client"
-Requires-Dist: truststore; extra == "client"
 Provides-Extra: test
 Requires-Dist: freezegun; extra == "test"
 Requires-Dist: pytest; extra == "test"

{cli2-5.0.0rc9 → cli2-5.0.0rc12}/cli2.egg-info/requires.txt

@@ -3,10 +3,6 @@ pyyaml
 pygments
 structlog
 
-[client]
-httpx
-truststore
-
 [test]
 freezegun
 pytest

{cli2-5.0.0rc9 → cli2-5.0.0rc12}/setup.py

@@ -44,7 +44,7 @@ from setuptools import setup
 
 setup(
     name='cli2',
-    version='5.0.0rc9',
+    version='5.0.0rc12',
     setup_requires='setupmeta',
     packages=['cli2'],
     install_requires=[
@@ -54,10 +54,6 @@ setup(
         'structlog',
     ],
     extras_require=dict(
-        client=[
-            'httpx',
-            'truststore',
-        ],
         test=[
             'freezegun',
             'pytest',

cli2-5.0.0rc12/tests/test_asyncio.py

@@ -0,0 +1,68 @@
+import asyncio
+import cli2
+import pytest
+from unittest import mock
+
+
+def test_async_run_noloop():
+    async def task():
+        await asyncio.sleep(.01)
+
+    cli2.async_run(task())
+
+
+@pytest.mark.asyncio
+async def test_async_run_loop():
+    async def task():
+        await asyncio.sleep(.01)
+
+    cli2.async_run(task())
+
+
+@pytest.mark.asyncio
+async def test_queue_basic():
+    async def task(i):
+        return i
+
+    queue = cli2.Queue()
+    await queue.run(task(1), task(2), task(3))
+
+    assert sorted(queue.results) == [1, 2, 3]
+
+
+@pytest.mark.asyncio
+async def test_queue_concurrency():
+    start = asyncio.get_event_loop().time()
+
+    async def worker(i):
+        await asyncio.sleep(0.1)
+        return i
+
+    queue = cli2.Queue(num_workers=3)
+    await queue.run(worker(1), worker(2), worker(3))
+
+    duration = asyncio.get_event_loop().time() - start
+    assert duration < 0.15, 'Should run in parallel'
+    assert sorted(queue.results) == [1, 2, 3]
+
+
+@pytest.mark.asyncio
+async def test_queue_error_handling(monkeypatch):
+    import cli2.asyncio
+    logger = mock.Mock()
+    monkeypatch.setattr(cli2.asyncio, 'log', logger)
+
+    async def worker(i):
+        if i == 2:
+            raise ValueError('test error')
+        await asyncio.sleep(0.01)
+        return i
+
+    queue = cli2.Queue()
+    await queue.run(worker(1), worker(2), worker(3))
+
+    # Error should not stop other tasks
+    assert queue.results == [1, 3]
+
+    # Exceptions should be printed though, not swallowed
+    logger.exception.assert_called_once()

cli2-5.0.0rc9/cli2/asyncio.py

@@ -1,42 +0,0 @@
-import asyncio
-import inspect
-from . import display
-
-
-def async_iter(obj):
-    return inspect.isasyncgen(obj) or hasattr(obj, '__aiter__')
-
-
-async def async_resolve(result, output=False):
-    """ Recursively resolve awaitables. """
-    while inspect.iscoroutine(result):
-        result = await result
-    if async_iter(result):
-        results = []
-        async for _ in result:
-            if output:
-                if (
-                    not inspect.iscoroutine(_)
-                    and not inspect.isasyncgen(_)
-                ):
-                    display.print(_)
-                else:
-                    await async_resolve(_, output=output)
-            else:
-                results.append(await async_resolve(_))
-        return None if output else results
-    return result
-
-
-def async_run(coroutine):
-    """
-    Run an async coroutineutine, in running loop or new loop.
-
-    :param coroutine: The return value of an async function call.
-    """
-    try:
-        loop = asyncio.get_running_loop()
-    except RuntimeError:
-        return asyncio.run(coroutine)
-    else:
-        return loop.create_task(coroutine)

cli2-5.0.0rc9/tests/test_asyncio.py

@@ -1,18 +0,0 @@
-import asyncio
-import cli2
-import pytest
-
-
-def test_async_run_noloop():
-    async def task():
-        await asyncio.sleep(.01)
-
-    cli2.async_run(task())
-
-
-@pytest.mark.asyncio
-async def test_async_run_loop():
-    async def task():
-        await asyncio.sleep(.01)
-
-    cli2.async_run(task())