semvec/pypi-packages huggingface dataset:
single-consumer-queue 1.1.1
Asyncio high-performance single consumer queue
License: MIT
Requires Python: >=3.10,<4.0

# Single Consumer Queue
Single Consumer Queue is a Python library that provides an alternative to the standard asyncio.Queue for single consumer scenarios. It consists of two classes: SingleConsumerQueue and SingleConsumerPriorityQueue. Both classes implement the AbstractSingleConsumerQueue abstract base class, which provides the basic functionality of a single consumer queue.

## Why Single Consumer Queue?
In some scenarios, the standard asyncio.Queue can be slower than necessary. This is because asyncio.Queue is designed to be used with multiple consumers, which means that it has additional overhead to handle multiple concurrent accesses. If you only have one consumer, you can use SingleConsumerQueue or SingleConsumerPriorityQueue to reduce this overhead and improve performance.

## How to use Single Consumer Queue
Installation
You can install Single Consumer Queue using pip:

```pip install single-consumer-queue```

## Usage
Here's an example of how to use SingleConsumerQueue:

```
async def consumer(queue: SingleConsumerQueue | SingleConsumerPriorityQueue):
    async for item in queue.start_consuming():
        print(item)
```

SingleConsumerQueue raises exception if you try to add multiple consumers:

```
async def consumer(queue: SingleConsumerQueue | SingleConsumerPriorityQueue):
    async for item in queue.start_consuming():
        print(item)

queue = SingleConsumerQueue()
asyncio.create_task(consumer(queue))
await asyncio sleep(0.1)
await queue.get()  # raises runtime error
```

Lock is checked and acquired when consumer starts and every time that get is awaited.

Get has considerate overhead because it has to use lock every time, so it is recommended to use `start_consuming` generator when you want to consume items in the loop.
CommonlyTools 2.1.3
You will use Python easily!
License: MIT
Requires Python: >=3.6
Keywords: CommonlyTools

# CommonlyTools

----------

How to use CommonlyTools?
>```pip install CommonlyTools```
----------

>commonlytools/discohook.py
>>Discord Webhook Sender
>>>Step 1(If you do not need to use embed, you can skip this step.)
>>>```py
>>>from commonlytools import discohook
>>>
>>>embed=discohook.Embed(color=..., colour=..., timestamp=..., title="...", description="...") #If you need, you can enter the colour, title or descriotion
>>>embed.author(name="...", url="...", icon_url="...") #author
>>>embed.footer(text="...", icon_url="...") #footer
>>>embed.image(image_url="...") #image
>>>embed.thumbnail(thumbnail_url="...") #thumbnail
>>>embed.add_field(name="...", value="...", inline=...) #add_field #This function can unlimited superposition.
>>>```
>>
>>Step 2
>>>```py
>>>discohook.send(webhook_url="...", username="...", avatar_url="...", content="...", embeds=[...])
>>>```
>>
>>Step 3
>>>```
>>>Message was sent!
>>>```
Bullpen 0.0.1a0
A workflow management suite for arbitrary actions
License: MIT
Keywords: LED matrix,matrix,raspberry pi,raspberry,RPI,LED

# `Bullpen`

`Bullpen` is a Python package for managing workflows and is designed to be as lightweight as possible.

## Installation

`Bullpen` is in the [Python Package Index (PyPI)](http://pypi.python.org/pypi/Bullpen/).
Installing with ``pip`` is recommended for all systems.

```sh
pip install Bullpen
```

## Contact

Tyler Porter

tyler.b.porter@gmail.com
donpeterlibs 0.0.0
An id generator that generated various types and lengths ids
License: MIT
Requires Python: >=3.10

1. bajar el repositorio
      - git clone https://github.com/soypedroamaya/docker-ubuntu-python-pkgs.git    
2. nos metemos dentro del repo
      - cd docker-ubuntu-python-pkgs
3. construimos la imagen
      - docker build -t img-docker-ubuntu-python-pkgs .

4. construimos el contenedor basado en la imagen, con interaccion en la terminal y pegada a nuestro directorio local 
      - docker run --name cnt-docker-ubuntu-python-pkgs -it -v $(pwd):/docker-ubuntu-python-pkgs img-docker-ubuntu-python-pkgs bash

4.1 nos conectamos desde visual studio y con la extension "dev containers" a nuestro contenedor corriendo

5. nos movemos a la rama que necesitemos:
    - git checkout exp

6. creamos el entorno virtual de la rama
    - python3.10 -m venv exp

7. activamos el entorno virtual anterior
    - source exp/bin/activate

8. bajamos las librerias necesarias y que estan segun la rama
    - pip install --no-cache-dir -r requirements.txt

    - (opcional) => pip freeze > requirements.txt
    nota: para sacar una lista con las versiones exactas de las librerias que ocupa ese entorno.

9. creamos las librerias externas
    - npm install

------- conf de sphinx ----
mkdir docs -> en la raiz del proyecto
cd docs
sphinx-quickstart -> llenar las preguntas (aqui me quede...)
cd .. -> te salis hasta el directorio raiz
sphinx-apidoc -o docs .
cd docs

-- agregar la palabra "modules" en el archivo index.rst, en el area del toctree

make html
meter en un browser:
file:///Volumes/MicroSD4GB/Codigo/public/soypedroamaya/docker-ubuntu-python-pkgs/docs/_build/html/index.html


-- commitizen
primera vez
    cz bump --yes --changelog  

python setup.py bdist_wheel sdist

pip install . (para probarlo localmente en un env)

twine check dist/* (para probar que todo este bien)
twine upload -r testpypi dist/*


twine upload dist/*