semvec/pypi-packages huggingface dataset:
develocorder 0.4.0
Simple live value plotter using Matplotlib
Requires Python: >=3.6

Develocorder
============

![Pytest badge](https://github.com/wahtak/develocorder/workflows/Pytest/badge.svg)

Develocorder is a simple live value plotter for Python3 using Matplotlib. It is intended to give insights into the training of machine learning models / reinforcement learning agents with only minimal effort to add to existing code.

![Original Develocorder](https://upload.wikimedia.org/wikipedia/commons/thumb/8/8d/Viewing_of_Develocorder_Film.jpg/319px-Viewing_of_Develocorder_Film.jpg)

[(image source)](https://commons.wikimedia.org/wiki/File:Viewing_of_Develocorder_Film.jpg)


Installation
------------

```
$ pip install develocorder
```


Simple Example
--------------

``` python
# initialize once
set_recorder(my_value=LinePlot())

# add values to plot from anywhere in code
for _ in range(10):
    record(my_value=random())
```
See [examples/simple.py](examples/simple.py)

### Result
![Simple Example](doc/simple_example.png)


Fancy Example
--------------

Some more features:

``` python
# axis labels
set_recorder(labeled=LinePlot(xlabel="Episode", ylabel="Score"))

# additional filtered values (window filter)
set_recorder(filtered=FilteredLinePlot(filter_size=50))

# maximum history length
set_recorder(detail=LinePlot(max_length=50))

# downsampled values (record mean of every filter_size values)
set_recorder(downsampled=DownsampledLinePlot(filter_size=5))

# multiple curves for recording 1d-array values
set_recorder(multiple=FilteredLinePlot(filter_size=50))

# heatmap for recording 1d-array values
set_recorder(heatmap=Heatmap())

# minimum update period (limit update rate for better performance)
set_update_period(0.5)  # [seconds]

# set number of columns
set_num_columns(2)
```
See [examples/fancy.py](examples/fancy.py)

![Fancy Example](doc/fancy_example.png)


Jupyter notebook
----------------

For use in a Jupyter notebook use the `%matplotlib notebook` backend. As of now you cannot rerun the cell which is showing the plot without restarting the notebook, otherwise the plot will disappear.

See [examples/simple.ipynb](examples/simple.ipynb)


TODOs
-----
  - [ ] document how to extend
  - [ ] better support for jupyter notebook
  - [ ] add new plot types
  - [ ] persistent storage/loading of log
trio-paho-mqtt 0.3.1
trio async MQTT Client
Requires Python: >=3.5, <4
Keywords: trio mqtt

# trio_paho_mqtt
[trio](https://github.com/python-trio/trio) specific async MQTT client. The goal of this project is to have all 
the MQTT protocol stuff handled by [paho-mqtt](https://github.com/eclipse/paho.mqtt.python),
while the async loopy stuff is handled by trio. This keeps our MQTT communication async, without having to
shove paho-mqtt into a thread, and without having to reimplement the MQTT protocol.

All callbacks are also removed to be more trio-like. Messages are accessed through an `async for` loop.

This is meant to be a light-as-possible wrapper around paho-mqtt. That way if something goes wrong with MQTT message
parsing, it's not my fault ;-)

## Usage
First, see the `example.py` and paho-mqtt documentation.
The goal is to expose all the same methods as the paho-mqtt `Client`. If any methods (besides callbacks) are missing
or do something unexpected, this is a bug. Please open an issue.

`AsyncClient` is initialized with a sync `mqtt.Client` and a `trio.Nursery` but then otherwise should operate much
like the sync `Client`.  Methods are *not* coroutines, they are non-blocking functions, so you do not need to call
`await`. The only exception is accessing messages through `async for`.

### Example
```python
import paho.mqtt.client as mqtt
import trio
from trio_paho_mqtt import AsyncClient


async def handle_messages(client):
    async for msg in client.messages():
        print(f"Received msg: {msg}")

async with trio.open_nursery() as nursery:
    sync_client = mqtt.Client()
    client = AsyncClient(sync_client, nursery)
    client.connect('mqtt.eclipse.org', 1883, 60)
    client.subscribe(topic)
    client.publish(topic, msg)

    nursery.start_soon(handle_messages, client)
```

## Related projects
  - [gmqtt](https://github.com/wialon/gmqtt) - Uses asyncio and callbacks. Isn't compatible with trio.
  - [hbmqtt](https://github.com/beerfactory/hbmqtt) - Uses asyncio. Reimplements the MQTT protocol.
  - [aiomqtt](https://github.com/mossblaser/aiomqtt) - Uses asyncio and wraps paho, but still uses the loop from 
  paho-mqtt. I believe all operations are put into a worker thread.
  - [distmqtt](https://github.com/smurfix/distmqtt) - anyio-ified hbmqtt fork. Works with trio.
acornio 0.0.1
An asynchronous mail server

![](assets/acorn_io.png)

 An Asynchronous WSGI server.



Work in progress... please call back soon!

```bash
pip install acorn-io
```


## Authors

* **Joe Gasewicz** - *Initial work* - [JoeGasewicz](https://github.com/joegasewicz/)

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details

## Acknowledgments

...