semvec/pypi-packages huggingface dataset:
harp-syringepump 0.1.0a4
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: python, harp

# 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.0a4
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: python, harp

# 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.0a4
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: python, harp

# 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.0a4
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: python, harp

# 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.0a4
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: python, harp

# 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.0a4
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: python, harp

# 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.0a4
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: python, harp

# 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.0a4
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: python, harp

# 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.0a4
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: python, harp

# 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.0a4
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: python, harp

# 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.0a4
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: python, harp

# 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
```
harp-audioswitch 0.1.0a4
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: python, harp

# harp.audioswitch

[![PyPI](https://img.shields.io/pypi/v/harp.audioswitch)](https://pypi.org/project/harp.audioswitch/)

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.audioswitch/>

# Installation
You can install the package using `uv` or `pip`:

```bash
uv add harp.audioswitch
```
or

```bash
pip install harp.audioswitch
```

# Usage example

```python
from harp.protocol import OperationMode
from harp.devices.audioswitch import AudioSwitch

# Example usage of the AudioSwitch device
with AudioSwitch("/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-analoginput 0.1.0a4
This is a generated Harp device Python interface that interacts with the Harp protocol.
Requires Python: <4.0,>=3.9
Keywords: python, harp

# harp.analoginput

[![PyPI](https://img.shields.io/pypi/v/harp.analoginput)](https://pypi.org/project/harp.analoginput/)

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.analoginput/>

# Installation
You can install the package using `uv` or `pip`:

```bash
uv add harp.analoginput
```
or

```bash
pip install harp.analoginput
```

# Usage example

```python
from harp.protocol import OperationMode
from harp.devices.analoginput import AnalogInput

# Example usage of the AnalogInput device
with AnalogInput("/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
```
AUMCdb-MEDS 0.0.3
A template ETL pipeline to extract AUMCdb data into the MEDS format.
Requires Python: >=3.11

# AUMCdb MEDS Extraction ETL

This pipeline extracts the AUMCdb dataset into MEDS format. The AUMCdb dataset is a publicly available dataset from the
Amsterdam University Medical Centers (AUMC) that contains clinical data from the hospital. You first need to request
access [here](https://lifesciences.datastations.nl/dataset.xhtml?persistentId=doi:10.17026/dans-22u-f8vd).

## Usage:

```
pip install AUMCdb_MEDS
MEDS_extract-AUMCdb input_dir=$RAW_DATA_DIR output_dir=$MEDS_DIR
```

If you want, you can also use the `do_download` flag to download the data directly from the AUMCdb repository.
You need to set the `AUMCDB_API_KEY` environment variable to your API key.
Please get it from
here: [AUMCdb API Key](https://lifesciences.datastations.nl/dataverseuser.xhtml?selectTab=dataRelatedToMe)

```
export AUMCDB_API_KEY=your_api_key
MEDS_extract-AUMCdb input_dir=$RAW_DATA_DIR output_dir=$MEDS_DIR
```

This will download the dataset automatically for you.