semvec/pypi-packages huggingface dataset:
dataset_handler 0.0.1
Utility package for managing dataset
Requires Python: <4.0,>=3.9

# DatasetHandler

## Introduction

DatasetHandler is a generic helper package for downloading datasets and performing any necessary preprocessing.
This CLI program provides two main commands: `download` and `extract`, enabling easy management of datasets.

```shell
$ datasets
Usage: datasets [OPTIONS] COMMAND [ARGS]...

Options:
  --help  Show this message and exit.

Commands:
  download
  extract
```

## Performance

DatasetHandler leverages multiprocessing to significantly enhance performance by utilizing multiple CPU cores.
This parallel processing capability ensures **faster execution** of time-consuming tasks, making the tool **efficient for handling large datasets**.

### Key Areas Utilizing Multiprocessing:

- _Downloading Files_: The `download_multiprocess` function employs multiple processes to download files concurrently, reducing the time required to fetch large datasets from the internet.
- _Unarchiving Files_: The `unarchive_multiprocess` function unpacks multiple archive files simultaneously, speeding up the extraction process of downloaded data.
- _Extracting Images from Videos_: The `extract_multiprocess` function processes multiple video files in parallel to extract frames, which is especially useful for large collections of video data.

> By parallelizing these tasks, DatasetHandler ensures that data preparation steps are performed efficiently, saving valuable time and computational resources.

## Scripts

You can use the following script to run the cli in background

```shell
nohup bash bin/background.sh >> /data/logs/dataset_handler.log &
```

## Contributing

- We use poetry for managing dependencies, please make sure you have poetry installed.

```shell
poetry version
```

- Install the dependencies using `poetry`

```shell
poetry install --with dev
```

- Before you commit and push your changes please run the following

```shell
poetry run ruff check
poetry run ruff format
poetry run mypy
poetry run pytest
```

## TODO

- [documentation] Add badges to `README.md`.
- [refactor] Add error handling.
- [refactor] Add logging.
- [test] Try to minimize fixtures by using more of pytest-mock.
- [test] Increase code coverage to 40%.
- [fix] Triage why coverage data is different on certain versions of python
lazypimp 0.1.0
A Python package to lazy import modules and functions.
Requires Python: >=3.8
Keywords: lazy, import, module, function, package, python, lazypimp

# Lazypimp
Lazypimp stands for lazy python import. It is a python package that allows you to setup an importing system that loads all imports on demand. This is useful for large projects where you don't want to load all the imports at once.

## Installation
using pip:
```bash
pip install lazypimp
```
using conda:
```bash
conda install -c conda-forge lazypimp
```

## Usage
Let's say we have a file structure as follows:
```
mymodule/
    __init__.py
    submod1.py
    submod2.py
    submod3.py
    subpackage/
        __init__.py
        submod4.py
    class1.py
    functions.py
```
And we want to have the following imports in the `__init__.py` file:
```python
# imports of submodules
from mymodule import submod1, submod2, submod3 as sm3
from mymodule.subpackage import submod4

# imports of classes, functions, etc.
from mymodule.class1 import MyClass1
from mymodule.functions import my_function
```

To set up the module `mymodule` to load submodules on demand, we can use the following code:
```python

from lazypimp import setup

all_modules_by_origin = {
    "mymodule": ["submod1", "submod2", {"sm3": "submod3"}], 
    "mymodule.subpackage": ["submod4"]
}

all_imports_by_origin = {
    "mymodule.class1": "MyClass1",
    "mymodule.functions": "my_function"
}

setup(__name__, all_modules_by_origin, all_imports_by_origin)
```
accentnotifications 0.0.12
Sending various forms of notifications such as smtp
Requires Python: >=3.9

[![Test](https://github.com/accentdesign/accentnotifications/actions/workflows/test.yml/badge.svg)](https://github.com/accentdesign/accentnotifications/actions/workflows/test.yml)

---
**Source Code**: <a href="https://github.com/accentdesign/accentnotifications" target="_blank">https://github.com/accentdesign/accentnotifications</a>
---

## Installation

For smtp:
```bash
pip install accentnotifications[smtp]
```

For twilio sms:
```bash
pip install accentnotifications[twiliosms]
```
accentdatabase 0.0.16
Handling sqlalchemy connection and test helpers including
Requires Python: >=3.9

[![Test](https://github.com/accentdesign/accentdatabase/actions/workflows/test.yml/badge.svg)](https://github.com/accentdesign/accentdatabase/actions/workflows/test.yml)

---
**Source Code**: <a href="https://github.com/accentdesign/accentdatabase" target="_blank">https://github.com/accentdesign/accentdatabase</a>
---
mqtt_text2speech 0.1.1
A simple MQTT audio client for synthesizing text messages published to an MQTT broker
Requires Python: <4.0.0,>=3.10.12

## Simple MQTT Text2Speech Client 

This MQTT client subscribes to an 'OutputTopic' where text messages can be published, which the client will then speak using pyttsx3. 
The start of the speech output by the MQTT client is signaled on the 'StartedTopic'. Once the speech output is finished, the MQTT client signals this on the 'FinishedTopic'.

## Environment Variables

The parameters of the MQTT Text2Speech client are read as environment variables from a `.env` file. 
The following environment variables need to be defined inside the `.env` file:

```
OUTPUT_TOPIC = "/output-topic-msgs-are-published-to"
STARTED_TOPIC = "/started-topic"
FINISHED_TOPIC = "/finished-topic"

MQTT_BROKER_HOST = "host-ip-address"
MQTT_BROKER_PORT = "1883"
MQTT_BROKER_USERNAME = "mqtt-broker-username"
MQTT_BROKER_PASSWORD = "mqtt-broker-password"

RATE = 150 
VOLUME = 1.0 
VOICE = 0
```

## Starting the MQTT Text2SpeechClient

```python
import logging
from mqtt_text2speech.client import Text2SpeechClient

# Logging configuration to see output (optional)
logging.basicConfig(format='%(asctime)s %(levelname)-8s %(message)s',
                    level=logging.INFO,
                    datefmt='%Y-%m-%d %H:%M:%S')

# Start MQTT Text2SpeechClient with environment variables configured in .env file
client = Text2SpeechClient()
client.start()

# Do stuff (Loop to keep main thread busy)
while True: 
    pass

# Connection to MQTT Broker will be closed if main thread ends
client.stop()
```