queutils 0.8.5__tar.gz → 0.9.3__tar.gz

queutils-0.9.3/.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.9.3/.github/workflows/python-publish.yml

@@ -0,0 +1,39 @@
+# This workflow will upload a Python Package using Twine when a release is created
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    environment: production
+    permissions:
+      id-token: write
+      contents: read
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install build
+      - name: Build package
+        run: python -m build
+      - name: Publish package
+        uses: pypa/gh-action-pypi-publish@v1.12.4
+#        with:
+#          user: __token__
+#          password: ${{ secrets.PYPI_API_TOKEN }}

{queutils-0.8.5 → queutils-0.9.3}/PKG-INFO

@@ -1,10 +1,11 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: queutils
-Version: 0.8.5
+Version: 0.9.3
 Summary: Handy Python Queue utilies
 Project-URL: Homepage, https://github.com/Jylpah/queutils
 Project-URL: Bug Tracker, https://github.com/Jylpah/queutils/issues
 Author-email: Jylpah <jylpah@gmail.com>
+License-File: LICENSE
 Classifier: Development Status :: 4 - Beta
 Classifier: Framework :: AsyncIO
 Classifier: License :: OSI Approved :: MIT License
@@ -13,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'
@@ -24,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)
@@ -32,14 +35,15 @@ Description-Content-Type: text/markdown
 
 Queutils *[Queue Utils]* is a package of handy Python queue classes:
 
-- **[AsyncQueue](docs/asyncqueue.md)** - An `async` wrapper for non-async `queue.Queue`
-- **[IterableQueue](docs/iterablequeue.md)** - An `AsyncIterable` queue that terminates when finished
-- **[FileQueue](docs/filequeue.md)** - Builds an iterable queue of filenames from files/dirs given as input
+- **AsyncQueue** - An `async` wrapper for non-async `queue.Queue`
+- **IterableQueue** - An `AsyncIterable` queue that terminates when finished
+- **EventCounterQueue** - An `IterableQueue` for counting events in `async` threads
+- **FileQueue** - Builds an iterable queue of filenames from files/dirs given as input
 
 
 # AsyncQueue
 
-[`AsyncQueue`](docs/asyncqueue.md) is a async wrapper for non-async `queue.Queue`. It can be used to create 
+`AsyncQueue` is a async wrapper for non-async `queue.Queue`. It can be used to create 
 an `asyncio.Queue` compatible interface to a (non-async) managed `multiprocessing.Queue` and thus enable `async` code in parent/child processes to communicate over  `multiprocessing.Queue` as it were an `asyncio.Queue`. 
 
 ## Features 
@@ -51,7 +55,7 @@ an `asyncio.Queue` compatible interface to a (non-async) managed `multiprocessin
 
 # IterableQueue
 
-[`IterableQueue`](docs/iterablequeue.md) is an `asyncio.Queue` subclass that is `AsyncIterable[T]` i.e. it can be 
+`IterableQueue` is an `asyncio.Queue` subclass that is `AsyncIterable[T]` i.e. it can be 
 iterated in `async for` loop. `IterableQueue` terminates automatically when the queue has been filled and emptied. 
 
 The `IterableQueue` requires "producers" (functions adding items to the queue) to register themselves and it 
@@ -71,9 +75,19 @@ producers are "finished", the queue enters into "filled" state and no new items
 - Countable property can be disabled with count_items=False. This is useful when you
     want to sum the count of multiple IterableQueues 
 
+# EventCounterQueue
+
+`EventCounterQueue` can be used to count named events (default event is `count`) between `async` threads. `async` worker threads call `queue.send(event="event_name", N=amount)`. The receving end can either `receive()` a single event or `listen()` all  events and return `collections.defaultdict[str, int]` as a result.
+
+## Features
+
+- Supports multiple producers and a single listener
+- Default event is `count`
+
+
 # FileQueue
 
-[`FileQueue`](docs/filequeue.md) builds a queue (`IterableQueue[pathlib.Path]`) of the matching 
+`FileQueue` builds a queue (`IterableQueue[pathlib.Path]`) of the matching 
 files found based on search parameters given. It can search both list of files or directories or 
 mixed. Async method `FileQueue.mk_queue()` searches subdirectories of given directories.  
 

{queutils-0.8.5 → queutils-0.9.3}/README.md

@@ -6,6 +6,7 @@ Queutils *[Queue Utils]* is a package of handy Python queue classes:
 
 - **[AsyncQueue](docs/asyncqueue.md)** - An `async` wrapper for non-async `queue.Queue`
 - **[IterableQueue](docs/iterablequeue.md)** - An `AsyncIterable` queue that terminates when finished
+- **EventCounterQueue** - An `IterableQueue` for counting events in `async` threads
 - **[FileQueue](docs/filequeue.md)** - Builds an iterable queue of filenames from files/dirs given as input
 
 
@@ -43,6 +44,16 @@ producers are "finished", the queue enters into "filled" state and no new items
 - Countable property can be disabled with count_items=False. This is useful when you
     want to sum the count of multiple IterableQueues 
 
+# EventCounterQueue
+
+`EventCounterQueue` can be used to count named events (default event is `count`) between `async` threads. `async` worker threads call `queue.send(event="event_name", N=amount)`. The receving end can either `receive()` a single event or `listen()` all  events and return `collections.defaultdict[str, int]` as a result.
+
+## Features
+
+- Supports multiple producers and a single listener
+- Default event is `count`
+
+
 # FileQueue
 
 [`FileQueue`](docs/filequeue.md) builds a queue (`IterableQueue[pathlib.Path]`) of the matching 

{queutils-0.8.5 → queutils-0.9.3}/docs/filequeue.md

@@ -35,4 +35,18 @@ async def main() -> None:
 
 if __name__ == "__main__":
     run(main())
+```
+
+### Run
+
+```bash
+cd demos
+python -m filequeue_demo
+```
+Output
+```text
+found asyncqueue_demo.py
+found iterablequeue_demo.py
+found filequeue_demo.py
+finished, no need to use fileQ.join()
 ```

queutils-0.9.3/docs/rm_links

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+# Usage: ./rmlinks.sh input.md > output.md
+
+if [ "$#" -ne 1 ]; then
+    echo "Usage: $0 <markdown-file>"
+    exit 1
+fi
+
+INPUT_FILE="$1"
+
+# Use sed to remove markdown links to /docs but keep the link text
+# Matches: [link text](/docs/whatever.md) and turns into: link text
+perl -pe 's/\[([^\]]+)\]\((\/?docs\/[^)]+)\)/\1/g' "$INPUT_FILE"

queutils-0.9.3/pypi.md

@@ -0,0 +1,69 @@
+[![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
+
+Queutils *[Queue Utils]* is a package of handy Python queue classes:
+
+- **AsyncQueue** - An `async` wrapper for non-async `queue.Queue`
+- **IterableQueue** - An `AsyncIterable` queue that terminates when finished
+- **EventCounterQueue** - An `IterableQueue` for counting events in `async` threads
+- **FileQueue** - Builds an iterable queue of filenames from files/dirs given as input
+
+
+# AsyncQueue
+
+`AsyncQueue` is a async wrapper for non-async `queue.Queue`. It can be used to create 
+an `asyncio.Queue` compatible interface to a (non-async) managed `multiprocessing.Queue` and thus enable `async` code in parent/child processes to communicate over  `multiprocessing.Queue` as it were an `asyncio.Queue`. 
+
+## Features 
+
+- `asyncio.Queue` compatible
+- `queue.Queue` support
+- `multiprocessing.Queue` support
+
+
+# IterableQueue
+
+`IterableQueue` is an `asyncio.Queue` subclass that is `AsyncIterable[T]` i.e. it can be 
+iterated in `async for` loop. `IterableQueue` terminates automatically when the queue has been filled and emptied. 
+
+The `IterableQueue` requires "producers" (functions adding items to the queue) to register themselves and it 
+keeps count of registered producers which are "finished" adding items to the queue. Once all the registered 
+producers are "finished", the queue enters into "filled" state and no new items can be added. Once an 
+"filled" queue is emptied, the queue becomes "done" and all new `get()` calls to the queue will 
+`raise QueueDone` exception. 
+    
+## Features
+
+- `asyncio.Queue` interface, `_nowait()` methods are experimental
+- `AsyncIterable` support: `async for item in queue:`
+- Automatic termination of the consumers with `QueueDone` exception when the queue has been emptied 
+- Producers must be registered with `add_producer()` and they must notify the queue
+  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 
+
+# EventCounterQueue
+
+`EventCounterQueue` can be used to count named events (default event is `count`) between `async` threads. `async` worker threads call `queue.send(event="event_name", N=amount)`. The receving end can either `receive()` a single event or `listen()` all  events and return `collections.defaultdict[str, int]` as a result.
+
+## Features
+
+- Supports multiple producers and a single listener
+- Default event is `count`
+
+
+# FileQueue
+
+`FileQueue` builds a queue (`IterableQueue[pathlib.Path]`) of the matching 
+files found based on search parameters given. It can search both list of files or directories or 
+mixed. Async method `FileQueue.mk_queue()` searches subdirectories of given directories.  
+
+## Features
+
+- Input can be given both as `str` and `pathlib.Path`
+- `exclude: bool` exclusive or  inclusive filtering. Default is `False`.
+- `case_sensitive: bool` case sensitive filtering (use of `fnmatch` or `fnmatchcase`). Default is `True`.
+- `follow_symlinks: bool` whether to follow symlinks. Default is `False`.
+

{queutils-0.8.5 → queutils-0.9.3}/pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "queutils"
-version = "0.8.5"
+version = "0.9.3"
 authors = [{ name = "Jylpah", email = "jylpah@gmail.com" }]
 description = "Handy Python Queue utilies"
-readme = "README.md"
+readme = { file = "pypi.md", content-type = "text/markdown" }
 requires-python = ">=3.11"
 classifiers = [
     "Programming Language :: Python :: 3",
@@ -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.5 → queutils-0.9.3}/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 .eventcounterqueue import (
+    QCounter as QCounter,
+    EventCounterQueue as EventCounterQueue,
+)
 
 __all__ = [
     "asyncqueue",
     "countable",
+    "eventcounterqueue",
     "filequeue",
     "iterablequeue",
 ]

queutils-0.9.3/src/queutils/eventcounterqueue.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 EventCounterQueue 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 EventCounterQueue(IterableQueue[tuple[str, int]]):
+    """
+    EventCounterQueue is a asyncio.Queue for counting events by name
+    """
+
+    _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 an event value from the queue and sum it"""
+        event: str
+        value: int
+        event, value = await super().get()
+        self._counter[event] += value
+        super().task_done()
+        return (event, value)
+
+    async def send(self, event: str = "count", value: int = 1) -> None:
+        """Send count of an event"""
+        await super().put((event, value))
+        return None
+
+    def get_count(self, event: str = "count") -> int:
+        """Return count for an event"""
+        return self._counter[event]
+
+    def get_counts(self) -> defaultdict[str, int]:
+        """Return counts of all events"""
+        return self._counter
+
+    async def listen(self) -> defaultdict[str, int]:
+        """Listen for event 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.9.3/tests/test_eventcounterqueue.py

@@ -0,0 +1,80 @@
+import pytest  # type: ignore
+from asyncio import (
+    Task,
+    create_task,
+    gather,
+    TimeoutError,
+)
+from random import choice, randint
+import string
+from collections import defaultdict
+
+from queutils import EventCounterQueue
+
+
+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.mark.parametrize(
+    "events,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_1_category_counter_queue(
+    events: list[str], N: int, producers: int
+) -> None:
+    """Test EventCounterQueue"""
+    Q = EventCounterQueue(maxsize=QSIZE)
+
+    async def producer(
+        Q: EventCounterQueue, events: list[str], N: int = 100
+    ) -> defaultdict[str, int]:
+        """
+        Test Producer for EventCounterQueue
+        """
+        _counter: defaultdict[str, int] = defaultdict(int)
+        await Q.add_producer()
+        for _ in range(N):
+            cat: str = choice(events)
+            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, events, N)))
+
+    try:
+        res_in: defaultdict[str, int] = await Q.listen()
+        res_out: defaultdict[str, int] = defaultdict(int)
+        for res in await gather(*senders):
+            for event, count in res.items():
+                res_out[event] += count
+
+        assert res_in == res_out, f"EventCounterQueue: {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"

queutils-0.8.5/.github/workflows/python-publish.yml

@@ -1,39 +0,0 @@
-# This workflow will upload a Python Package using Twine when a release is created
-# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries
-
-# This workflow uses actions that are not certified by GitHub.
-# They are provided by a third-party and are governed by
-# separate terms of service, privacy policy, and support
-# documentation.
-
-name: Upload Python Package
-
-on:
-  release:
-    types: [published]
-
-permissions:
-  contents: read
-
-jobs:
-  deploy:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v4
-    - name: Set up Python
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.11'
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install build
-    - name: Build package
-      run: python -m build
-    - name: Publish package
-      uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29
-      with:
-        user: __token__
-        password: ${{ secrets.PYPI_API_TOKEN }}