queutils 0.8.4__tar.gz → 0.9.1__tar.gz

queutils-0.9.1/.github/workflows/codeql.yml

@@ -0,0 +1,100 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL Advanced"
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  schedule:
+    - cron: '39 23 8 * *'
+
+jobs:
+  analyze:
+    name: Analyze (${{ matrix.language }})
+    # Runner size impacts CodeQL analysis time. To learn more, please see:
+    #   - https://gh.io/recommended-hardware-resources-for-running-codeql
+    #   - https://gh.io/supported-runners-and-hardware-resources
+    #   - https://gh.io/using-larger-runners (GitHub.com only)
+    # Consider using larger runners or machines with greater resources for possible analysis time improvements.
+    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
+    permissions:
+      # required for all workflows
+      security-events: write
+
+      # required to fetch internal or private CodeQL packs
+      packages: read
+
+      # only required for workflows in private repositories
+      actions: read
+      contents: read
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+        - language: actions
+          build-mode: none
+        - language: python
+          build-mode: none
+        # CodeQL supports the following values keywords for 'language': 'actions', 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'swift'
+        # Use `c-cpp` to analyze code written in C, C++ or both
+        # Use 'java-kotlin' to analyze code written in Java, Kotlin or both
+        # Use 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both
+        # To learn more about changing the languages that are analyzed or customizing the build mode for your analysis,
+        # see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning.
+        # If you are analyzing a compiled language, you can modify the 'build-mode' for that language to customize how
+        # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    # Add any setup steps before running the `github/codeql-action/init` action.
+    # This includes steps like installing compilers or runtimes (`actions/setup-node`
+    # or others). This is typically only required for manual builds.
+    # - name: Setup runtime (example)
+    #   uses: actions/setup-example@v1
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      with:
+        languages: ${{ matrix.language }}
+        build-mode: ${{ matrix.build-mode }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+
+        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+    # If the analyze step fails for one of the languages you are analyzing with
+    # "We were unable to automatically build your code", modify the matrix above
+    # to set the build mode to "manual" for that language. Then modify this step
+    # to build your code.
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+    - if: matrix.build-mode == 'manual'
+      shell: bash
+      run: |
+        echo 'If you are using a "manual" build mode for one or more of the' \
+          'languages you are analyzing, replace this with the commands to build' \
+          'your code, for example:'
+        echo '  make bootstrap'
+        echo '  make release'
+        exit 1
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v3
+      with:
+        category: "/language:${{matrix.language}}"

{queutils-0.8.4 → queutils-0.9.1}/.github/workflows/python-package.yml

@@ -14,7 +14,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.11", "3.12"]
+        python-version: ["3.11", "3.12", "3.13"]
         os: [ ubuntu-latest, windows-latest, macos-latest ]
     runs-on: ${{ matrix.os }}
 

{queutils-0.8.4 → queutils-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: queutils
-Version: 0.8.4
+Version: 0.9.1
 Summary: Handy Python Queue utilies
 Project-URL: Homepage, https://github.com/Jylpah/queutils
 Project-URL: Bug Tracker, https://github.com/Jylpah/queutils/issues
@@ -14,6 +14,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.11
 Requires-Dist: aioconsole>=0.6
+Requires-Dist: deprecated>=1.2.18
 Provides-Extra: dev
 Requires-Dist: build>=0.10; extra == 'dev'
 Requires-Dist: hatchling>=1.22.4; extra == 'dev'
@@ -25,6 +26,7 @@ Requires-Dist: pytest-datafiles>=3.0; extra == 'dev'
 Requires-Dist: pytest-timeout>=2.2; extra == 'dev'
 Requires-Dist: pytest>=8.0; extra == 'dev'
 Requires-Dist: ruff>=0.1.9; extra == 'dev'
+Requires-Dist: types-deprecated>=1.2.15; extra == 'dev'
 Description-Content-Type: text/markdown
 
 [![Python package](https://github.com/Jylpah/queutils/actions/workflows/python-package.yml/badge.svg)](https://github.com/Jylpah/queutils/actions/workflows/python-package.yml)  [![codecov](https://codecov.io/gh/Jylpah/queutils/graph/badge.svg?token=rMKdbfHOFs)](https://codecov.io/gh/Jylpah/queutils)

{queutils-0.8.4 → queutils-0.9.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "queutils"
-version = "0.8.4"
+version = "0.9.1"
 authors = [{ name = "Jylpah", email = "jylpah@gmail.com" }]
 description = "Handy Python Queue utilies"
 readme = "README.md"
@@ -13,7 +13,7 @@ classifiers = [
     "Framework :: AsyncIO",
     "Topic :: Software Development :: Libraries",
 ]
-dependencies = ["aioconsole>=0.6"]
+dependencies = ["aioconsole>=0.6", "Deprecated>=1.2.18"]
 
 [project.optional-dependencies]
 dev = [
@@ -27,6 +27,7 @@ dev = [
     "pytest-cov>=4.1",
     "pytest-timeout>=2.2",
     "ruff>=0.1.9",
+    "types-Deprecated>=1.2.15",
 ]
 
 
@@ -59,7 +60,10 @@ lint.fixable = ["ALL"]
 minversion = "7.4"
 addopts = ["-v", "--cov=src"]
 testpaths = ["tests", "demos"]
-pythonpath = "src"             # avoid import path append in test files
+pythonpath = "src"                              # avoid import path append in test files
+asyncio_default_fixture_loop_scope = "function"
 
 [tool.pyright]
 reportGeneralTypeIssues = false
+reportInvalidStringEscapeSequence = false
+typeCheckingMode = "off"

{queutils-0.8.4 → queutils-0.9.1}/src/queutils/__init__.py

@@ -2,10 +2,15 @@ from .countable import Countable as Countable
 from .asyncqueue import AsyncQueue as AsyncQueue
 from .iterablequeue import IterableQueue as IterableQueue, QueueDone as QueueDone
 from .filequeue import FileQueue as FileQueue
+from .categorycounterqueue import (
+    QCounter as QCounter,
+    CategoryCounterQueue as CategoryCounterQueue,
+)
 
 __all__ = [
     "asyncqueue",
     "countable",
+    "categorycounterqueue",
     "filequeue",
     "iterablequeue",
 ]

{queutils-0.8.4 → queutils-0.9.1}/src/queutils/asyncqueue.py

@@ -1,7 +1,7 @@
 # -----------------------------------------------------------
 #  Class AsyncQueue(asyncio.Queue, Generic[T])
 #
-#  asyncio wrapper for non-async queue.Queue. Can be used to create 
+#  asyncio wrapper for non-async queue.Queue. Can be used to create
 #  an asyncio.Queue out of a (non-async) multiprocessing.Queue.
 #
 # -----------------------------------------------------------
@@ -10,7 +10,6 @@ __author__ = "Jylpah"
 __copyright__ = "Copyright 2024, Jylpah <Jylpah@gmail.com>"
 __credits__ = ["Jylpah"]
 __license__ = "MIT"
-# __version__ = "1.0"
 __maintainer__ = "Jylpah"
 __email__ = "Jylpah@gmail.com"
 __status__ = "Production"
@@ -35,18 +34,17 @@ error = logger.error
 
 class AsyncQueue(asyncio.Queue, Generic[T]):
     """
-    Async wrapper for non-async queue.Queue. Can be used to create 
+    Async wrapper for non-async queue.Queue. Can be used to create
     an asyncio.Queue out of a (non-async) multiprocessing.Queue.
     """
 
-    def __init__(self, queue: Queue[T], asleep: float = 0.01):
+    def __init__(self, queue: Queue[T], asleep: float = 0.001):
         self._Q: Queue[T] = queue
         # self._maxsize: int = queue.maxsize
         self._done: int = 0
         self._items: int = 0
         self._sleep: float = asleep
 
-
     @property
     def maxsize(self) -> int:
         """not supported by queue.Queue"""

queutils-0.9.1/src/queutils/categorycounterqueue.py

@@ -0,0 +1,116 @@
+from asyncio import Queue
+from typing import TypeVar
+from deprecated import deprecated
+from .countable import Countable
+from .iterablequeue import IterableQueue, QueueDone
+from collections import defaultdict
+import logging
+
+logger = logging.getLogger()
+error = logger.error
+message = logger.warning
+verbose = logger.info
+debug = logger.debug
+
+###########################################
+#
+# class CounterQueue
+#
+###########################################
+T = TypeVar("T")
+
+
+@deprecated(version="0.9.1", reason="Use CategoryCounterQueue instead")
+class CounterQueue(Queue[T], Countable):
+    """
+    CounterQueue is a asyncio.Queue for counting items
+    """
+
+    _counter: int
+    _count_items: bool
+    _batch: int
+
+    def __init__(
+        self, *args, count_items: bool = True, batch: int = 1, **kwargs
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self._counter = 0
+        self._count_items = count_items
+        self._batch = batch
+
+    def task_done(self) -> None:
+        super().task_done()
+        if self._count_items:
+            self._counter += 1
+        return None
+
+    @property
+    def count(self) -> int:
+        """Return number of completed tasks"""
+        return self._counter * self._batch
+
+    @property
+    def count_items(self) -> bool:
+        """Whether or not count items"""
+        return self._count_items
+
+
+class CategoryCounterQueue(IterableQueue[tuple[str, int]]):
+    """
+    CategorySummerQueue is a asyncio.Queue for summing up values by category
+    """
+
+    _counter: defaultdict[str, int]
+    _batch: int
+
+    def __init__(self, *args, batch: int = 1, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._batch = batch
+        self._counter = defaultdict(int)
+
+    async def receive(self) -> tuple[str, int]:
+        """Receive a category value from the queue and sum it"""
+        category: str
+        value: int
+        category, value = await super().get()
+        self._counter[category] += value
+        super().task_done()
+        return (category, value)
+
+    async def send(self, category: str = "count", value: int = 1) -> None:
+        """Send count of a category"""
+        await super().put((category, value))
+        return None
+
+    def get_count(self, category: str = "count") -> int:
+        """Return count of a category"""
+        return self._counter[category]
+
+    def get_counts(self) -> defaultdict[str, int]:
+        """Return counts of all categories"""
+        return self._counter
+
+    async def listen(self) -> defaultdict[str, int]:
+        """Listen for category values"""
+        try:
+            while True:
+                await self.receive()
+        except QueueDone:
+            pass
+        return self.get_counts()
+
+
+class QCounter:
+    def __init__(self, Q: Queue[int]):
+        self._count = 0
+        self._Q: Queue[int] = Q
+
+    @property
+    def count(self) -> int:
+        return self._count
+
+    async def start(self) -> None:
+        """Read and count items from Q"""
+        while True:
+            self._count += await self._Q.get()
+            self._Q.task_done()

{queutils-0.8.4 → queutils-0.9.1}/src/queutils/iterablequeue.py

@@ -1,7 +1,7 @@
 # -----------------------------------------------------------
 #  Class IterableQueue(asyncio.Queue[T], AsyncIterable[T], Countable)
 #
-#  IterableQueue is asyncio.Queue subclass that can be iterated asynchronusly. 
+#  IterableQueue is asyncio.Queue subclass that can be iterated asynchronusly.
 #  IterableQueue terminates automatically when the queue has been
 #  filled and emptied.
 #
@@ -23,7 +23,7 @@ from .countable import Countable
 import logging
 
 # Setup logging
-logger = logging.getLogger()
+logger = logging.getLogger(__name__)
 error = logger.error
 message = logger.warning
 verbose = logger.info
@@ -31,24 +31,26 @@ debug = logger.debug
 
 T = TypeVar("T")
 
+
 class QueueDone(Exception):
     """
     Exception to mark an IterableQueue as filled and emptied i.e. done
     """
+
     pass
 
 
 class IterableQueue(Queue[T], AsyncIterable[T], Countable):
     """
-    IterableQueue is asyncio.Queue subclass that can be iterated asynchronusly. 
-    
+    IterableQueue is asyncio.Queue subclass that can be iterated asynchronusly.
+
     IterableQueue terminates automatically when the queue has been
     filled and emptied. Supports:
     - asyncio.Queue() interface, _nowait() methods are experimental
     - AsyncIterable(): async for item in queue:
     - Automatic termination of the consumers when the queue has been emptied with QueueDone exception
     - Producers must be registered with add_producer() and they must notify the queue
-      with finish() once they have finished adding items 
+      with finish() once they have finished adding items
     - Countable interface to count number of items task_done() through 'count' property
     - Countable property can be disabled with count_items=False. This is useful when you
     want to sum the count of multiple IterableQueues
@@ -74,16 +76,16 @@ class IterableQueue(Queue[T], AsyncIterable[T], Countable):
 
     @property
     def is_filled(self) -> bool:
-        """"
-        True if all the producers finished filling the queue. 
+        """ "
+        True if all the producers finished filling the queue.
         New items cannot be added to a filled queue nor can new producers can be added.
         """
         return self._filled.is_set()
-    
+
     @property
     def is_done(self) -> bool:
         """
-        Has the queue been filled, emptied and all the items have been marked with task_done() 
+        Has the queue been filled, emptied and all the items have been marked with task_done()
         """
         return self.is_filled and self.empty() and not self.has_wip
 
@@ -91,7 +93,6 @@ class IterableQueue(Queue[T], AsyncIterable[T], Countable):
     def maxsize(self) -> int:
         return self._Q.maxsize
 
-
     def full(self) -> bool:
         """
         True if the queue is full
@@ -122,8 +123,8 @@ class IterableQueue(Queue[T], AsyncIterable[T], Countable):
     @property
     def wip(self) -> int:
         """
-        Number of items in progress i.e. items that have been 
-        read from the queue, but not marked with task_done() 
+        Number of items in progress i.e. items that have been
+        read from the queue, but not marked with task_done()
         """
         return self._wip
 
@@ -236,7 +237,7 @@ class IterableQueue(Queue[T], AsyncIterable[T], Countable):
     def get_nowait(self) -> T:
         """
         Experimental asyncio.Queue.get_nowait() implementation
-        """        
+        """
         item: T | None = self._Q.get_nowait()
         if item is None:
             self._empty.set()

queutils-0.9.1/tests/test_ccategorycounterqueue.py

@@ -0,0 +1,333 @@
+import pytest  # type: ignore
+from asyncio.queues import QueueEmpty, QueueFull
+from asyncio import (
+    Task,
+    create_task,
+    sleep,
+    gather,
+    timeout,
+    TimeoutError,
+    CancelledError,
+)
+from random import random, choice, randint
+import string
+from collections import defaultdict
+
+from queutils import IterableQueue, CategoryCounterQueue, QueueDone
+
+
+def randomword(length: int) -> str:
+    """Generate a random word of fixed length"""
+    # https://stackoverflow.com/a/2030081/12946084
+    letters: str = string.ascii_lowercase
+    return "".join(choice(letters) for i in range(length))
+
+
+QSIZE: int = 10
+N: int = 100  # N >> QSIZE
+THREADS: int = 4
+# N : int = int(1e10)
+
+
+@pytest.fixture
+def test_interablequeue_int() -> IterableQueue[int]:
+    return IterableQueue[int](maxsize=QSIZE)
+
+
+async def _producer_int(
+    Q: IterableQueue[int], n: int, finish: bool = False, wait: float = 0
+) -> None:
+    await Q.add_producer(N=1)
+    await sleep(wait)
+    try:
+        for i in range(n):
+            await sleep(wait * random())
+            await Q.put(i)
+    except QueueDone:
+        pass
+    if finish:
+        await Q.finish()
+    return None
+
+
+async def _consumer_int(Q: IterableQueue[int], n: int = -1, wait: float = 0) -> bool:
+    try:
+        while n != 0:
+            _ = await Q.get()
+            await sleep(wait * random())
+            Q.task_done()
+            n -= 1
+    except QueueDone:
+        pass
+    except CancelledError:
+        raise
+    return True
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.asyncio
+async def test_1_put_get_async(test_interablequeue_int: IterableQueue[int]):
+    """Test: put(), get(), join(), qsize(), empty() == True"""
+    Q = test_interablequeue_int
+    try:
+        async with timeout(5):
+            await _producer_int(Q, QSIZE - 1, finish=True)
+    except TimeoutError:
+        assert False, "IterableQueue got stuck"
+    assert Q.qsize() == QSIZE - 1, (
+        f"qsize() returned {Q.qsize()}, should be {QSIZE - 1}"
+    )
+    try:
+        await Q.put(1)
+        assert False, "Queue is filled and put() should raise an exception"
+    except QueueDone:
+        pass  # Queue is done and put() should raise an exception
+    assert not Q.is_done, "is_done returned True even queue is not finished"
+    consumer: Task = create_task(_consumer_int(Q))
+    try:
+        async with timeout(5):
+            await Q.join()
+        await Q.get()
+        assert False, "Queue is done and put() should raise an exception"
+    except TimeoutError:
+        assert False, "IterableQueue.join() took too long"
+    except QueueDone:
+        pass  # should be raised
+    assert Q.qsize() == 0, "queue not empty"
+    assert Q.empty(), "queue not empty"
+    consumer.cancel()
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.asyncio
+async def test_2_put_get_nowait(test_interablequeue_int: IterableQueue[int]):
+    """Test put_nowait() and get_nowait() methods"""
+    Q = test_interablequeue_int
+    producer: Task = create_task(_producer_int(Q, N))
+    await sleep(1)
+    # In theory this could fail without a real error
+    # if QSIZE is huge and/or system is slow
+    assert Q.qsize() == Q.maxsize, "Queue was supposed to be at maxsize"
+    assert Q.full(), "Queue should be full"
+    assert not Q.empty(), "Queue should not be empty"
+
+    try:
+        Q.put_nowait(1)
+        assert False, "Queue was supposed to be full, but was not"
+    except QueueFull:
+        pass  # OK, Queue was supposed to be full
+
+    try:
+        while True:
+            _ = Q.get_nowait()
+            Q.task_done()
+            await sleep(0.01)
+    except QueueEmpty:
+        assert Q.qsize() == 0, "Queue size should be zero"
+
+    try:
+        async with timeout(5):
+            await Q.finish()
+            await Q.join()
+    except TimeoutError:
+        assert False, "Queue.join() took longer than it should"
+    assert Q.qsize() == 0, "queue size is > 0 even it should be empty"
+    assert Q.empty(), "queue not empty()"
+    producer.cancel()
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.asyncio
+async def test_3_multiple_producers(test_interablequeue_int: IterableQueue[int]):
+    Q = test_interablequeue_int
+    workers: list[Task] = list()
+    for _ in range(THREADS):
+        workers.append(create_task(_producer_int(Q, N, finish=True, wait=0.05)))
+    try:
+        assert not Q.is_done, "is_done returned True even queue is not finished"
+        async with timeout(10):
+            async for _ in Q:
+                pass
+    except TimeoutError:
+        assert False, "IterableQueue.join() took too long"
+    except QueueDone:
+        pass  # Queue is done
+
+    assert Q.qsize() == 0, f"queue size is {Q.qsize()} even it should be empty"
+    assert Q.empty(), "queue not empty"
+    for w in workers:
+        w.cancel()
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.asyncio
+async def test_4_multiple_producers_consumers(
+    test_interablequeue_int: IterableQueue[int],
+):
+    Q = test_interablequeue_int
+    producers: list[Task] = list()
+    consumers: list[Task] = list()
+
+    for _ in range(THREADS):
+        producers.append(create_task(_producer_int(Q, N, finish=False, wait=0.05)))
+        consumers.append(create_task(_consumer_int(Q, 2 * N, wait=0.06)))
+    try:
+        async with timeout(10):
+            await gather(*producers)
+            await Q.finish(all=True)
+            await Q.join()
+            assert not Q.has_wip, "Queue should not have any items WIP"
+    except TimeoutError:
+        assert False, "IterableQueue.join() took too long"
+    assert Q.count == THREADS * N, (
+        f"count returned wrong value {Q.count}, should be {THREADS * N}"
+    )
+    assert Q.qsize() == 0, "queue size is > 0 even it should be empty"
+    assert Q.empty(), "queue not empty"
+    for p in consumers:
+        p.cancel()
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.asyncio
+async def test_5_empty_join(test_interablequeue_int: IterableQueue[int]):
+    """Test for await join when an empty queue is finished"""
+    Q = test_interablequeue_int
+    producer: Task = create_task(_producer_int(Q, n=0, finish=True, wait=2))
+    assert not Q.is_done, "is_done returned True even queue is not finished"
+    consumer: Task = create_task(_consumer_int(Q))
+    try:
+        async with timeout(3):
+            await Q.join()
+        assert Q.empty(), (
+            "Queue is done after 3 secs and the join() should finish before timeout(5)"
+        )
+    except TimeoutError:
+        assert False, "await IterableQueue.join() failed with an empty queue finished"
+    await sleep(0.1)
+
+    try:
+        consumer.cancel()
+        assert not consumer.cancelled(), (
+            "consumer task was cancelled and did not complete even it should have"
+        )
+    except Exception as err:
+        assert False, f"Unknown Exception caught: {err}"
+    assert producer.done(), "producer has not finished"
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.asyncio
+async def test_6_finish_full_queue(test_interablequeue_int: IterableQueue[int]):
+    """Test for await join when an empty queue is finished"""
+    Q = test_interablequeue_int
+    producer: Task = create_task(_producer_int(Q, n=QSIZE * 2))
+    try:
+        await sleep(0.5)
+        async with timeout(3):
+            await Q.finish(all=True, empty=True)
+        assert Q.empty(), (
+            f"Queue should be empty: qsize={Q._Q.qsize()}: {Q._Q.get_nowait()}, {Q._Q.get_nowait()}"
+        )
+        assert Q.is_done, "Queue is not done"
+    except TimeoutError:
+        assert False, "await IterableQueue.join() failed with an empty queue finished"
+    await sleep(0.1)
+    assert Q.is_done, "Queue is not done"
+    producer.cancel()
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.asyncio
+async def test_7_aiter(test_interablequeue_int: IterableQueue[int]):
+    """Test for await join when an empty queue is finished"""
+    Q = test_interablequeue_int
+    await _producer_int(Q, n=QSIZE - 1, finish=True)
+
+    try:
+        await sleep(0.5)
+        async for i in Q:
+            assert i >= 0, "Did not receive an int"
+        assert Q.is_done, "Queue is not done"
+        # assert (
+        #     True
+        # ), "Queue is done after 3 secs and the join() should finish before timeout(5)"
+    except TimeoutError:
+        assert False, "await IterableQueue.join() failed with an empty queue finished"
+
+
+@pytest.mark.timeout(10)
+@pytest.mark.asyncio
+async def test_8_aiter_1_item(test_interablequeue_int: IterableQueue[int]):
+    """Test for await join when an empty queue is finished"""
+    Q = test_interablequeue_int
+    await _producer_int(Q, n=1, finish=True)
+
+    try:
+        assert Q.qsize() == 1, f"incorrect queue length {Q.qsize()} != 1"
+        await sleep(0.5)
+        count: int = 0
+        async for i in Q:
+            count += 1
+            assert i >= 0, "Did not receive an int"
+        assert count == 1, f"Did not receive correct number of elements {count} != 1"
+        assert True, (
+            "Queue is done after 3 secs and the join() should finish before timeout(5)"
+        )
+    except TimeoutError:
+        assert False, "await IterableQueue.join() failed with an empty queue finished"
+
+
+@pytest.mark.parametrize(
+    "cats,N, producers",
+    [
+        ([randomword(5) for _ in range(10)], 1000, 1),
+        ([randomword(5) for _ in range(20)], 10000, 1),
+        ([randomword(5) for _ in range(5)], 1000, 3),
+    ],
+)
+@pytest.mark.timeout(10)
+@pytest.mark.asyncio
+async def test_9_category_counter_queue(
+    cats: list[str], N: int, producers: int
+) -> None:
+    """Test CategoryCounterQueue"""
+    Q = CategoryCounterQueue(maxsize=QSIZE)
+
+    async def producer(
+        Q: CategoryCounterQueue, cats: list[str], N: int = 100
+    ) -> defaultdict[str, int]:
+        """
+        Test Producer for CategoryCounterQueue
+        """
+        _counter: defaultdict[str, int] = defaultdict(int)
+        await Q.add_producer()
+        for _ in range(N):
+            cat: str = choice(cats)
+            count: int = randint(1, 10)
+            await Q.send(cat, count)
+            _counter[cat] += count
+        await Q.finish()
+        return _counter
+
+    senders: list[Task] = list()
+
+    for _ in range(producers):
+        senders.append(create_task(producer(Q, cats, N)))
+
+    try:
+        res_in: defaultdict[str, int] = await Q.listen()
+        res_out: defaultdict[str, int] = defaultdict(int)
+        for res in await gather(*senders):
+            for cat, count in res.items():
+                res_out[cat] += count
+
+        assert res_in == res_out, f"CategoryCounterQueue: {res_in} != {res_out}"
+        assert Q.qsize() == 0, "queue size is > 0 even it should be empty"
+        assert Q.empty(), "queue not empty"
+        assert Q.count == N * producers, (
+            f"count returned wrong value {Q.count}, should be {N * producers}"
+        )
+
+    except TimeoutError:
+        assert False, "await IterableQueue.join() failed with an empty queue finished"