semvec/pypi-packages huggingface dataset:
thonny-lahendus 9.2.0
Thonny plugin for lahendus.ut.ee
Requires Python: >=3.7

## [Thonny](https://thonny.org/) plugin for [Lahendus](https://lahendus.ut.ee/).

### Installation instructions
To install this plugin, please refer to the Thonny [plug-in installation guide](https://github.com/thonny/thonny/wiki/Plugins#plug-ins).

### Availability
You can find this plugin on PyPI at [thonny-lahendus](https://pypi.org/project/thonny-lahendus/).
json-line-logger 0.0.10
Configs for python's logging library to have a JSONL-log

################
Json Line Logger
################
|TestStatus| |PyPiStatus| |BlackStyle| |BlackPackStyle| |MITLicenseBadge|


Uses python's awesome logging-library and configures it to write JSON-lines.
In JSON-lines, each line in the log is a valid json-object.
This makes the log easy to read with a machine.


*******
install
*******

.. code-block::

    pip install json-line-logger


*****
usage
*****

There are three handy constructors for loggers: ``LoggerFile``,
``LoggerStream``, and ``LoggerStdout``.

.. code-block:: python

    import json_line_logger

    logger = json_line_logger.LoggerFile(path="test.log.jsonl")

    logger.debug("This is a log message")

    with json_line_logger.TimeDelta(logger=logger, name="some costly task"):
        result_of_a_costly_task = 1 + 1

    json_line_logger.shutdown(logger=logger)


Yields a logfile ``test.log.jsonl`` which contains:

.. code-block::

    {"t":"1886-03-27T11:01:01.341", "l":"DEBUG", "m":"This is a log message"}
    {"t":"1886-03-27T11:01:01.341", "l":"INFO", "m":"<TimeDelta name='some costly task' delta='2.1457672119140625e-06'/>"}


.. |TestStatus| image:: https://github.com/cherenkov-plenoscope/json_line_logger/actions/workflows/test.yml/badge.svg?branch=main
    :target: https://github.com/cherenkov-plenoscope/json_line_logger/actions/workflows/test.yml

.. |PyPiStatus| image:: https://img.shields.io/pypi/v/json_line_logger
    :target: https://pypi.org/project/json_line_logger

.. |BlackStyle| image:: https://img.shields.io/badge/code%20style-black-000000.svg
    :target: https://github.com/psf/black

.. |BlackPackStyle| image:: https://img.shields.io/badge/pack%20style-black-000000.svg
    :target: https://github.com/cherenkov-plenoscope/black_pack

.. |MITLicenseBadge| image:: https://img.shields.io/badge/License-MIT-yellow.svg
    :target: https://opensource.org/licenses/MIT
json-utils-sebastian-achim-mueller 0.0.6
JSON-lines and recursive reading of json-files in a path.
Requires Python: >=3.0

##########
Json-utils
##########
|TestStatus| |PyPiStatus| |BlackStyle| |BlackPackStyle| |MITLicenseBadge|

*****
numpy
*****
Uses ``json_numpy`` for transparent ``loads`` and ``dumps`` of lists into numpy-arrayrs if the ``dtype`` is either purely int or float.

*****
trees
*****
Recursively read (or write) ``.json`` files in a tree of directories.

*****
lines
*****
JSON-lines or ``.jsonl`` is a powerful extension to the JSON-family.

.. code-block:: python

    import json_utils as ju

    with ju.lines.open("my-items.jsonl.gz", mode="w|gz") as jl:
        for i in range(100):
            jl.write({"number": i})

    with ju.lines.open("my-items.jsonl.gz", mode="r|gz") as jl:
        for obj in jl:
            print("item", obj["number"])


.. |TestStatus| image:: https://github.com/cherenkov-plenoscope/json_utils/actions/workflows/test.yml/badge.svg?branch=main
    :target: https://github.com/cherenkov-plenoscope/json_utils/actions/workflows/test.yml

.. |PyPiStatus| image:: https://img.shields.io/pypi/v/json_utils_sebastian-achim-mueller
    :target: https://pypi.org/project/json_utils_sebastian-achim-mueller

.. |BlackStyle| image:: https://img.shields.io/badge/code%20style-black-000000.svg
    :target: https://github.com/psf/black

.. |BlackPackStyle| image:: https://img.shields.io/badge/pack%20style-black-000000.svg
    :target: https://github.com/cherenkov-plenoscope/black_pack

.. |MITLicenseBadge| image:: https://img.shields.io/badge/License-MIT-yellow.svg
    :target: https://opensource.org/licenses/MIT
json-numpy-sebastian-achim-mueller 0.1.9
Dumps and loads numpy-arrays into or from json
Requires Python: >=3.0

##########
json-numpy
##########
|TestStatus| |PyPiStatus| |BlackStyle| |BlackPackStyle| |MITLicenseBadge|

Transparent ``dumps`` and ``loads`` of ``numpy-arrays``. If a list is loaded
from a ``json`` string it is given to ``numpy.array()``. If further, the
resulting array has a primitive type of either (``int``, ``float``) it is
returned by ``loads``.

*******
install
*******

.. code-block::

    pip install json-numpy-sebastian-achim-mueller


***********
``Encoder``
***********

to dump with ``json.dumps()``.

***************
``object_hook``
***************
to load with ``json.loads()``.

*******
example
*******

.. code-block:: python

    import numpy
    import json_numpy

    obj = json_numpy.loads(s='{"a": [1.0, NaN]}')
    assert isinstance(obj["a"], numpy.ndarray)

    json_numpy.dumps(obj)
    '{"a": [1.0, NaN]}'


.. |BlackStyle| image:: https://img.shields.io/badge/code%20style-black-000000.svg
    :target: https://github.com/psf/black

.. |TestStatus| image:: https://github.com/cherenkov-plenoscope/json_numpy/actions/workflows/test.yml/badge.svg?branch=main
    :target: https://github.com/cherenkov-plenoscope/json_numpy/actions/workflows/test.yml

.. |PyPiStatus| image:: https://img.shields.io/pypi/v/json_numpy_sebastian-achim-mueller
    :target: https://pypi.org/project/json_numpy_sebastian-achim-mueller

.. |BlackPackStyle| image:: https://img.shields.io/badge/pack%20style-black-000000.svg
    :target: https://github.com/cherenkov-plenoscope/black_pack

.. |MITLicenseBadge| image:: https://img.shields.io/badge/License-MIT-yellow.svg
    :target: https://opensource.org/licenses/MIT
fta-automl 0.1.0
Feel The Agi AutoML Library.

# FTA - AutoML Library

Example of usage:

```py
from fta_automl.dataset import FeelTheAgiDataset
from fta_automl.FTAutoML import FeelTheAgiAutoML

data = FeelTheAgiDataset('data/train.csv', 'target')
automl = FeelTheAgiAutoML(task='multi_classification', n_trials=7, timeout=900)
automl.train(data, optimize_hyperparams=True, max_models_for_blend=3, use_cv_training=True)

test_data = FeelTheAgiDataset('data/test.csv')
preds = automl.predict(test_data)
```
harp.syringepump 0.1.0a2
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: harp, python

# harp.syringepump

[![PyPI](https://img.shields.io/pypi/v/harp.syringepump)](https://pypi.org/project/harp.syringepump/)

This is a generated Harp device Python interface that interacts with the Harp protocol.

- **Github repository**: <https://github.com/fchampalimaud/harp.devices/>
- **Bug Tracker**: <https://github.com/fchampalimaud/harp.devices/issues>
- **Documentation**: <https://fchampalimaud.github.io/pyharp/harp.syringepump/>

# Installation
You can install the package using `uv` or `pip`:

```bash
uv add harp.syringepump
```
or

```bash
pip install harp.syringepump
```

# Usage example

```python
from harp.protocol import OperationMode
from harp.devices.syringepump import SyringePump

# Example usage of the SyringePump device
with SyringePump("/dev/ttyUSB0") as device: # For Windows, use "COM8" or similar
    device.info()

    # Set the device to active mode
    device.set_mode(OperationMode.ACTIVE)

    # Get the events
    try:
        while True:
            for event in device.get_events():
                # Do what you need with the event
                print(event.payload)
    except KeyboardInterrupt:
        # Capture Ctrl+C to exit gracefully
        print("Exiting...")
    finally:
        # Do what you need to do to clean up. Disconnect is automatically called with the "with" statement.
        pass
```
harp.synchronizer 0.1.0a2
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: harp, python

# harp.synchronizer

[![PyPI](https://img.shields.io/pypi/v/harp.synchronizer)](https://pypi.org/project/harp.synchronizer/)

This is a generated Harp device Python interface that interacts with the Harp protocol.

- **Github repository**: <https://github.com/fchampalimaud/harp.devices/>
- **Bug Tracker**: <https://github.com/fchampalimaud/harp.devices/issues>
- **Documentation**: <https://fchampalimaud.github.io/pyharp/harp.synchronizer/>

# Installation
You can install the package using `uv` or `pip`:

```bash
uv add harp.synchronizer
```
or

```bash
pip install harp.synchronizer
```

# Usage example

```python
from harp.protocol import OperationMode
from harp.devices.synchronizer import Synchronizer

# Example usage of the Synchronizer device
with Synchronizer("/dev/ttyUSB0") as device: # For Windows, use "COM8" or similar
    device.info()

    # Set the device to active mode
    device.set_mode(OperationMode.ACTIVE)

    # Get the events
    try:
        while True:
            for event in device.get_events():
                # Do what you need with the event
                print(event.payload)
    except KeyboardInterrupt:
        # Capture Ctrl+C to exit gracefully
        print("Exiting...")
    finally:
        # Do what you need to do to clean up. Disconnect is automatically called with the "with" statement.
        pass
```
harp.soundcard 0.1.0a2
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: harp, python

# harp.soundcard

[![PyPI](https://img.shields.io/pypi/v/harp.soundcard)](https://pypi.org/project/harp.soundcard/)

This is a generated Harp device Python interface that interacts with the Harp protocol.

- **Github repository**: <https://github.com/fchampalimaud/harp.devices/>
- **Bug Tracker**: <https://github.com/fchampalimaud/harp.devices/issues>
- **Documentation**: <https://fchampalimaud.github.io/pyharp/harp.soundcard/>

# Installation
You can install the package using `uv` or `pip`:

```bash
uv add harp.soundcard
```
or

```bash
pip install harp.soundcard
```

# Usage example

```python
from harp.protocol import OperationMode
from harp.devices.soundcard import SoundCard

# Example usage of the SoundCard device
with SoundCard("/dev/ttyUSB0") as device: # For Windows, use "COM8" or similar
    device.info()

    # Set the device to active mode
    device.set_mode(OperationMode.ACTIVE)

    # Get the events
    try:
        while True:
            for event in device.get_events():
                # Do what you need with the event
                print(event.payload)
    except KeyboardInterrupt:
        # Capture Ctrl+C to exit gracefully
        print("Exiting...")
    finally:
        # Do what you need to do to clean up. Disconnect is automatically called with the "with" statement.
        pass
```
harp.rgbarray 0.1.0a2
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: harp, python

# harp.rgbarray

[![PyPI](https://img.shields.io/pypi/v/harp.rgbarray)](https://pypi.org/project/harp.rgbarray/)

This is a generated Harp device Python interface that interacts with the Harp protocol.

- **Github repository**: <https://github.com/fchampalimaud/harp.devices/>
- **Bug Tracker**: <https://github.com/fchampalimaud/harp.devices/issues>
- **Documentation**: <https://fchampalimaud.github.io/pyharp/harp.rgbarray/>

# Installation
You can install the package using `uv` or `pip`:

```bash
uv add harp.rgbarray
```
or

```bash
pip install harp.rgbarray
```

# Usage example

```python
from harp.protocol import OperationMode
from harp.devices.rgbarray import RgbArray

# Example usage of the RgbArray device
with RgbArray("/dev/ttyUSB0") as device: # For Windows, use "COM8" or similar
    device.info()

    # Set the device to active mode
    device.set_mode(OperationMode.ACTIVE)

    # Get the events
    try:
        while True:
            for event in device.get_events():
                # Do what you need with the event
                print(event.payload)
    except KeyboardInterrupt:
        # Capture Ctrl+C to exit gracefully
        print("Exiting...")
    finally:
        # Do what you need to do to clean up. Disconnect is automatically called with the "with" statement.
        pass
```
harp.olfactometer 0.1.0a2
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: harp, python

# harp.olfactometer

[![PyPI](https://img.shields.io/pypi/v/harp.olfactometer)](https://pypi.org/project/harp.olfactometer/)

This is a generated Harp device Python interface that interacts with the Harp protocol.

- **Github repository**: <https://github.com/fchampalimaud/harp.devices/>
- **Bug Tracker**: <https://github.com/fchampalimaud/harp.devices/issues>
- **Documentation**: <https://fchampalimaud.github.io/pyharp/harp.olfactometer/>

# Installation
You can install the package using `uv` or `pip`:

```bash
uv add harp.olfactometer
```
or

```bash
pip install harp.olfactometer
```

# Usage example

```python
from harp.protocol import OperationMode
from harp.devices.olfactometer import Olfactometer

# Example usage of the Olfactometer device
with Olfactometer("/dev/ttyUSB0") as device: # For Windows, use "COM8" or similar
    device.info()

    # Set the device to active mode
    device.set_mode(OperationMode.ACTIVE)

    # Get the events
    try:
        while True:
            for event in device.get_events():
                # Do what you need with the event
                print(event.payload)
    except KeyboardInterrupt:
        # Capture Ctrl+C to exit gracefully
        print("Exiting...")
    finally:
        # Do what you need to do to clean up. Disconnect is automatically called with the "with" statement.
        pass
```
harp.loadcells 0.1.0a2
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: harp, python

# harp.loadcells

[![PyPI](https://img.shields.io/pypi/v/harp.loadcells)](https://pypi.org/project/harp.loadcells/)

This is a generated Harp device Python interface that interacts with the Harp protocol.

- **Github repository**: <https://github.com/fchampalimaud/harp.devices/>
- **Bug Tracker**: <https://github.com/fchampalimaud/harp.devices/issues>
- **Documentation**: <https://fchampalimaud.github.io/pyharp/harp.loadcells/>

# Installation
You can install the package using `uv` or `pip`:

```bash
uv add harp.loadcells
```
or

```bash
pip install harp.loadcells
```

# Usage example

```python
from harp.protocol import OperationMode
from harp.devices.loadcells import LoadCells

# Example usage of the LoadCells device
with LoadCells("/dev/ttyUSB0") as device: # For Windows, use "COM8" or similar
    device.info()

    # Set the device to active mode
    device.set_mode(OperationMode.ACTIVE)

    # Get the events
    try:
        while True:
            for event in device.get_events():
                # Do what you need with the event
                print(event.payload)
    except KeyboardInterrupt:
        # Capture Ctrl+C to exit gracefully
        print("Exiting...")
    finally:
        # Do what you need to do to clean up. Disconnect is automatically called with the "with" statement.
        pass
```
harp.ledarray 0.1.0a2
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: harp, python

# harp.ledarray

[![PyPI](https://img.shields.io/pypi/v/harp.ledarray)](https://pypi.org/project/harp.ledarray/)

This is a generated Harp device Python interface that interacts with the Harp protocol.

- **Github repository**: <https://github.com/fchampalimaud/harp.devices/>
- **Bug Tracker**: <https://github.com/fchampalimaud/harp.devices/issues>
- **Documentation**: <https://fchampalimaud.github.io/pyharp/harp.ledarray/>

# Installation
You can install the package using `uv` or `pip`:

```bash
uv add harp.ledarray
```
or

```bash
pip install harp.ledarray
```

# Usage example

```python
from harp.protocol import OperationMode
from harp.devices.ledarray import LedArray

# Example usage of the LedArray device
with LedArray("/dev/ttyUSB0") as device: # For Windows, use "COM8" or similar
    device.info()

    # Set the device to active mode
    device.set_mode(OperationMode.ACTIVE)

    # Get the events
    try:
        while True:
            for event in device.get_events():
                # Do what you need with the event
                print(event.payload)
    except KeyboardInterrupt:
        # Capture Ctrl+C to exit gracefully
        print("Exiting...")
    finally:
        # Do what you need to do to clean up. Disconnect is automatically called with the "with" statement.
        pass
```
harp.laserdrivercontroller 0.1.0a2
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: harp, python

# harp.laserdrivercontroller

[![PyPI](https://img.shields.io/pypi/v/harp.laserdrivercontroller)](https://pypi.org/project/harp.laserdrivercontroller/)

This is a generated Harp device Python interface that interacts with the Harp protocol.

- **Github repository**: <https://github.com/fchampalimaud/harp.devices/>
- **Bug Tracker**: <https://github.com/fchampalimaud/harp.devices/issues>
- **Documentation**: <https://fchampalimaud.github.io/pyharp/harp.laserdrivercontroller/>

# Installation
You can install the package using `uv` or `pip`:

```bash
uv add harp.laserdrivercontroller
```
or

```bash
pip install harp.laserdrivercontroller
```

# Usage example

```python
from harp.protocol import OperationMode
from harp.devices.laserdrivercontroller import LaserDriverController

# Example usage of the LaserDriverController device
with LaserDriverController("/dev/ttyUSB0") as device: # For Windows, use "COM8" or similar
    device.info()

    # Set the device to active mode
    device.set_mode(OperationMode.ACTIVE)

    # Get the events
    try:
        while True:
            for event in device.get_events():
                # Do what you need with the event
                print(event.payload)
    except KeyboardInterrupt:
        # Capture Ctrl+C to exit gracefully
        print("Exiting...")
    finally:
        # Do what you need to do to clean up. Disconnect is automatically called with the "with" statement.
        pass
```
harp.currentdriver 0.1.0a2
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: harp, python

# harp.currentdriver

[![PyPI](https://img.shields.io/pypi/v/harp.currentdriver)](https://pypi.org/project/harp.currentdriver/)

This is a generated Harp device Python interface that interacts with the Harp protocol.

- **Github repository**: <https://github.com/fchampalimaud/harp.devices/>
- **Bug Tracker**: <https://github.com/fchampalimaud/harp.devices/issues>
- **Documentation**: <https://fchampalimaud.github.io/pyharp/harp.currentdriver/>

# Installation
You can install the package using `uv` or `pip`:

```bash
uv add harp.currentdriver
```
or

```bash
pip install harp.currentdriver
```

# Usage example

```python
from harp.protocol import OperationMode
from harp.devices.currentdriver import CurrentDriver

# Example usage of the CurrentDriver device
with CurrentDriver("/dev/ttyUSB0") as device: # For Windows, use "COM8" or similar
    device.info()

    # Set the device to active mode
    device.set_mode(OperationMode.ACTIVE)

    # Get the events
    try:
        while True:
            for event in device.get_events():
                # Do what you need with the event
                print(event.payload)
    except KeyboardInterrupt:
        # Capture Ctrl+C to exit gracefully
        print("Exiting...")
    finally:
        # Do what you need to do to clean up. Disconnect is automatically called with the "with" statement.
        pass
```
harp.cameracontroller 0.1.0a2
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: harp, python

# harp.cameracontroller

[![PyPI](https://img.shields.io/pypi/v/harp.cameracontroller)](https://pypi.org/project/harp.cameracontroller/)

This is a generated Harp device Python interface that interacts with the Harp protocol.

- **Github repository**: <https://github.com/fchampalimaud/harp.devices/>
- **Bug Tracker**: <https://github.com/fchampalimaud/harp.devices/issues>
- **Documentation**: <https://fchampalimaud.github.io/pyharp/harp.cameracontroller/>

# Installation
You can install the package using `uv` or `pip`:

```bash
uv add harp.cameracontroller
```
or

```bash
pip install harp.cameracontroller
```

# Usage example

```python
from harp.protocol import OperationMode
from harp.devices.cameracontroller import CameraController

# Example usage of the CameraController device
with CameraController("/dev/ttyUSB0") as device: # For Windows, use "COM8" or similar
    device.info()

    # Set the device to active mode
    device.set_mode(OperationMode.ACTIVE)

    # Get the events
    try:
        while True:
            for event in device.get_events():
                # Do what you need with the event
                print(event.payload)
    except KeyboardInterrupt:
        # Capture Ctrl+C to exit gracefully
        print("Exiting...")
    finally:
        # Do what you need to do to clean up. Disconnect is automatically called with the "with" statement.
        pass
```
harp.behavior 0.1.0a2
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: harp, python

# harp.behavior

[![PyPI](https://img.shields.io/pypi/v/harp.behavior)](https://pypi.org/project/harp.behavior/)

This is a generated Harp device Python interface that interacts with the Harp protocol.

- **Github repository**: <https://github.com/fchampalimaud/harp.devices/>
- **Bug Tracker**: <https://github.com/fchampalimaud/harp.devices/issues>
- **Documentation**: <https://fchampalimaud.github.io/pyharp/harp.behavior/>

# Installation
You can install the package using `uv` or `pip`:

```bash
uv add harp.behavior
```
or

```bash
pip install harp.behavior
```

# Usage example

```python
from harp.protocol import OperationMode
from harp.devices.behavior import Behavior

# Example usage of the Behavior device
with Behavior("/dev/ttyUSB0") as device: # For Windows, use "COM8" or similar
    device.info()

    # Set the device to active mode
    device.set_mode(OperationMode.ACTIVE)

    # Get the events
    try:
        while True:
            for event in device.get_events():
                # Do what you need with the event
                print(event.payload)
    except KeyboardInterrupt:
        # Capture Ctrl+C to exit gracefully
        print("Exiting...")
    finally:
        # Do what you need to do to clean up. Disconnect is automatically called with the "with" statement.
        pass
```