semvec/pypi-packages huggingface dataset:
pyLegoMario 1.1
Module for handling connections with the Lego Mario toy
Requires Python: >=3.9
Keywords: lego, python, super mario, lego mario, bluetooth

# pyLegoMario
```pip install pyLegoMario```

pyLegoMario is a script that connects to Lego Mario and reads its acceleromter,
tile sensor, and pants data.
To connect, you have to turn Mario on and then press the Bluetooth Button.
See mario_sample.py for a nice sample.
To disconnect you have to await Mario.disconnect() or await Mario.turn_off(),
as well as set Mario.autoReconnect = False


## TL;DR; "just show me how to use it!"
### The Basics
```python
from pyLegoMario import Mario, MarioWindow, run
# Initialize Mario
mario = Mario()
# Create GUI
MarioWindow(mario)
# call run() at the end of your program to keep the asyncio loop running
run()
```
### Use Mario in Your Own Programs With Callback Functions
```python
def my_pants_hook(mario: Mario, powerup: str) -> None:
    print(f"I'm wearing {powerup} pants!")

mario.add_pants_hook(my_pants_hook)
```
### Use Mario as a Controller in Pygame!
```python
import pygame
from pyLegoMario import PygameMario, AsyncClock
from pyLegoMario import ACC_EVENT, PANTS_EVENT, RGB_EVENT

pygame.init()
mario = PygameMario()
# use AsyncClock instead of pygame.time.Clock
clock = AsyncClock()
screen = pygame.display.set_mode(1200,600)
font = pygame.font.SysFont(None, 48)

while True:
    clock.tick()
    pygame.display.update()
    for event in pygame.event.get():
        if event.type == RGB_EVENT:
            screen.fill((0,0,0))
            # write the current camera value onto the screen
            text = font.render(event.value, True, (255,255,255))
            screen.blit(text, (10,10))
# no need to call run() here, AsyncClock handles this
```
## You Can Do a Lot More!
Sample scripts can be found in the [Github Repository](https://github.com/Jackomatrus/pyLegoMario)

Tweet at me: [@Jackomatrus](https://www.twitter.com/Jackomatrus)

On Windows you will need Python 3.9 or higher for Bluetooth sockets to work properly.

I tested this on Mac and Windows. I have not tested this on Linux.
cliborg 0.1.2
A command-line tool for querying Ollama models
Requires Python: >=3.6


# Cliborg - A Command-Line Interface for Ollama Models

Cliborg is a simple command-line tool that lets you interact with locally hosted Ollama language models. You can ask questions to the model, configure the default model, and manage your preferences via a configuration file.

## Installation

To install Cliborg, make sure you have [Ollama](https://ollama.com) and `click` installed on your system.

```bash
pip install click ollama
```

## Usage

Once installed, you can use Cliborg to interact with your Ollama models. The following commands are available:

### Ask a Question

You can ask questions directly to the model by using the `ask` command:

```bash
cliborg ask "What is the capital of Japan?"
```

### Configure Default Model

To set the default model for future queries, use the `config` command:

```bash
cliborg config llama3.1
```

### Show Configuration

To view the current configuration, including the model being used:

```bash
cliborg show_config
```

## Configuration

Cliborg stores its configuration in a `.cliborg_config.json` file located in the user's home directory. This file allows you to save preferences like the default model, which is used across sessions.

## License

This project is licensed under the MIT License. See the LICENSE file for more details.
yolo2onnx-extended 0.2.2
YOLOv8 to ONNX Exporter with Pre and Post Processing
Requires Python: >=3.8
Keywords: yolo, onnx, preprocessing, postprocessing

# Exporting YOLO models to ONNX with embedded pre and post processing

This repository contains the code to export Yolo models to ONNX format using the runtime extensions to **add pre and post processing** to the exported ONNX.

Models supported (code examples on how to use in `examples` folder):

* [X] YOLOv8 Classification.
* [X] YOLOv8 Object Detection
* [X] YOLOv8 Segmentation.
  * [ ] Processing of resulting box coordinates only covered. Segmentation polygon not supported yet

## Python Installation

### YOLO2ONNX Extended package

Create a python environment and install using the wheel package file:

```
pip install yolo2onnx_extended-0.0.1-py3-none-any.whl
```

### Build from raw

Clone this repo and install the main requirements:

* [PyTorch](https://pytorch.org/get-started/locally/): `pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118`
* [Ultralyics](https://docs.ultralytics.com/quickstart/): `pip install ultralytics`
* [ONNX Runtime](https://onnxruntime.ai/docs/install/):
  * CPU: `pip install onnxruntime`
  * GPU (CUDA 11.8): `pip install onnxruntime-gpu`
* [ONNX Runtime Extensions](https://pytorch.org/get-started/locally/): `pip install onnxruntime-extensions`

## Use of exported model in other platforms (C/C#/C++/JavaScript/Android/iOS)

ONNX packages need to be installed. Check the supported versions for the platform you are using.

* ONNX Runtime installations for other platforms can be found in the [documentation](https://onnxruntime.ai/docs/install/).
* ONNX Extensions installations can be found in the [documentation](https://pytorch.org/get-started/locally/).

**[Inference install table for all languagues](Be aware of the supported versions of the extensions.)**

## Useful resources and Ideas

* [API - Python API documentation (onnxruntime.ai)](https://onnxruntime.ai/docs/api/python/api_summary.html)
* CUDA Optimization: [NVIDIA - CUDA | onnxruntime](https://onnxruntime.ai/docs/execution-providers/CUDA-ExecutionProvider.html)
* Model Quantization with ONNX
* ONNX Model Visualizer: [Netron](https://netron.app/)
* Processing [Segmentation YOLOV8 ONNX](https://github.com/ibaiGorordo/ONNX-YOLOv8-Instance-Segmentation/)
* [Python Packaging](https://packaging.python.org/en/latest/tutorials/packaging-projects/)

## Inference Benchmarks

* **CPU** (Intel(R) Core(TM) i7-10850H CPU @ 2.70GHz  6 cores, 12 virtual):
  * Object Detection `0.35 secs` per image
* **GPU** (NVIDIA Quadro T2000 with Max-Q Design):
  * Object Detection:  `4 - 5 secs` for first image. `0.068` for rest of images
multiversx-sdk-transaction-decoder 0.4.0
Deprecated. Instead, use multiversx-sdk.
Requires Python: >=3.8

[![No Maintenance Intended](http://unmaintained.tech/badge.svg)](http://unmaintained.tech/)

This package is **deprecated**. All the functionality has been moved to the [sdk-py](https://github.com/multiversx/mx-sdk-py/tree/main) package.
slumbernana-monkey 0.1.0
你，知道「睡蕉小猴」嗎？ 什麼？你不知道？那你有福了蕉！
Requires Python: >=3.6

蕉蕉🍌🍌長滿香蕉的小島🍌🍌
蕉蕉🍌🍌睡蕉小猴的愛巢🍌🍌
蕉蕉🍌🍌吃完香蕉就睡覺🍌🍌
蕉蕉🍌🍌快快樂樂沒煩惱🍌🍌
蕉蕉🍌🍌睡蕉小猴真是好🍌🍌
蕉蕉🍌🍌幸福美滿沒煩惱🍌🍌
lento 301024
Programmatically generate Lilypond scores, with ease and elegance of pure Python
Requires Python: >=3.5


Lento (current release: __v301024__) is a highly minimalist Python package (the entire API consists of a single class `Part` and a main processor function `proc`!) for compiling Lilypond sheet music.

For more information and examples please check the [Documentation]().

# Some Coding Tips
Convert a collection of durations into a progressing beats collection by utilizing `itertools.accumulate`:

```python
from random import choice
from itertools import accumulate

durs = [choice([.25, .5, .75, 1]) for _ in range(4)]
beats = list(accumulate(durs, initial=0))
print("Durations", durs)
print("Beats", beats)

# Durations: [0.25, 0.5, 0.5, 0.75]
# Beats: [0, 0.25, 0.75, 1.25, 2.0]
```

# Contributing

If you wish to contribute your code to this repository, please consider the following points:
- Packaging
  - Ensure to update the `src/lento/version.py` file and run `python prebuild.py` (and push the changes!) before initiating the build-upload process for each release with:

    ```
    python -m build && twine upload dist/*
    ```

_This README is generated by `prebuild.py`. Never edit it directly by hand! Instead, modify the `readme` variable in the
pre-build file._
tksel 1.1.3
Scrapper for Minet csvs on tiktok
Requires Python: >=3.7
Keywords: TikTok, minet, tksel, video

# tksel 

[![PyPI - Version](https://img.shields.io/pypi/v/tksel.svg)](https://pypi.org/project/tksel)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/tksel.svg)](https://pypi.org/project/tksel)

-----

**Table of Contents**

- [Installation](#installation)
- [License](#license)
- [Description](#description)
- [Usage](#usage)
  - [Example](#example)

## Installation

```console
pip install tksel
```

## License

`tksel` is distributed under the terms of the [AGPLv3 license](https://www.gnu.org/licenses/agpl-3.0.en.html).

## Description

`tksel` is a Python package that provides tool to recover videos from TikTok.
It is intended to be used on the csvs generated by [Minet](https://github.com/medialab/minet) but will work on any csv with the right columns:
- `video_id`, the id of the video (alias `id`)
- `author_id`, the id of the author (alias `author_unique_id`)

## Usage

```bash
tksel input.csv output_folder [--no-headless] [--no-verify] [--no-skip]
```

- `input.csv` is the csv generated by minet or any csv with the right columns
- `output_folder` is the folder where the videos will be downloaded, it will be created if it doesn't exist, the input csv will also be copied there

- `--no-headless` is an optional argument to display the browser while it is downloading the videos
- `--no-verify` is an optional argument to disable the verification of the requests.get()
- `--no-skip` is an optional argument to disable the skipping of the videos that are already downloaded
- `--sleep-min` is an optional argument to set the minimum sleep time between requests (randomized between `--sleep-min` and `--sleep-max`)
- `--sleep-max` is an optional argument to set the maximum sleep time between requests (randomized between `--sleep-min` and `--sleep-max`)

- `--help` is an optional argument to display the help message
- `--version` is an optional argument to display the version of the package

### Example

```bash
tksel to_collect.csv /path/to/saving/dir --no-headless --no-verify --no-skip --sleep-min 60 --sleep-max 120 
```
pdf-processing-lib 0.5.0
A library for processing PDF documents, images, extracting text, parsing TSV to JSON, and merging JSON files

# PDF Processing Library

This library provides tools for processing PDF documents, images, extracting text, parsing TSV files to JSON, and merging JSON files. It includes functionality for text extraction, image conversion, table detection, object detection using YOLO, CVAT task XML generation, TSV to JSON parsing, and JSON merging with hash generation.

## Installation

```bash
pip install pdf_processing_lib
```

## Usage

```python
from pdf_processing_lib import PDFProcessor, ImageProcessor, TextExtractor, TSVtoJSONParser, JSONMerger

# Process PDFs
pdf_processor = PDFProcessor('path/to/input/directory', 'path/to/output/directory')
pdf_processor.process_directory()

# Process images
image_processor = ImageProcessor('path/to/yolo/model.pt')
image_processor.process_directory('path/to/output/directory')

# Extract text and create CVAT task XML
text_extractor = TextExtractor('path/to/output/directory')
total_files, total_time, cvat_xml_path = text_extractor.process_directory_for_text_extraction()

# Parse TSV files to JSON
tsv_parser = TSVtoJSONParser('path/to/output/directory')
total_files, total_time, avg_time = tsv_parser.process_all_final_directories()

# Merge JSON files and add hash
json_merger = JSONMerger('path/to/json/directory')
output_file, total_entries = json_merger.run('path/to/output/merged.json')
```

## Features

- Extract text and tables from PDFs
- Convert PDF pages to JPG images
- Create versions of PDFs with tables covered
- Process multiple PDFs in parallel
- Perform object detection on images using YOLO
- Process images in batches for efficient memory usage
- Extract text from specific regions in PDFs
- Generate CVAT task XML for annotation purposes
- Parse TSV files to structured JSON format
- Merge multiple JSON files into a single file with added hash keys

## License

This project is licensed under the MIT License - see the LICENSE file for details.
localstack-extension-pod-on-shutdown 0.1.1
This LocalStack extension will create a cloud pod when LS is shutting down automatically

pod-on-shutdown
===============================

All the boilerplate you need to create a LocalStack extension.

## Install local development version

To install the extension into localstack in developer mode, you will need Python 3.10, and create a virtual environment in the extensions project.

In the newly generated project, simply run

```bash
make install
```

Then, to enable the extension for LocalStack, run

```bash
localstack extensions dev enable .
```

You can then start LocalStack with `EXTENSION_DEV_MODE=1` to load all enabled extensions:

```bash
EXTENSION_DEV_MODE=1 localstack start
```

## Install from GitHub repository

To distribute your extension, simply upload it to your github account. Your extension can then be installed via:

```bash
localstack extensions install "git+https://github.com/lukqw/pod-on-shutdown/#egg=pod-on-shutdown"
```