semvec/pypi-packages huggingface dataset:
byte-prefix-tree 0.3.2
Tries with byte sequences as keys for Python and Rust
Requires Python: >=3.10
Keywords: utilities, trie, byte, rust, python, patricia, art, radix

## Byte tries in Rust with Python bindings

### Installation

Install from PyPI (only built for Python 3.10+ on Linux)

```
pip install byte-prefix-tree
```

### Manual installation

Make sure you have Rust installed, then do the following:

```bash
git clone https://github.com/bastiscode/byte-trie.git
cd byte-trie
pip install maturin[patchelf]
maturin develop --release
```

### Usage

Currently implemented tries:
- Patricia trie
- Adaptive radix trie

Key needs to be a bytes object, value can be anything.
Make sure that the key never contains a 255 byte, as it is used as a terminator internally. For utf8-encoded text this is always the case, but for other types of data you might need to encode it in a way that ensures this.

```python
from byte_trie import PatriciaTrie, AdaptiveRadixTrie

pt = PatriciaTrie()

# add key-value pairs
pt.insert(b"hello", 1)
pt.insert(b"world", 2)

# delete key
print(pt.delete(b"hello"))  # 1

# check for keys and prefixes
print(pt.contains(b"hello"))  # False
print(pt.contains(b"world"))  # True
print(pt.contains(b"wor"))  # False
print(pt.contains_prefix(b"hel"))  # False
print(pt.contains_prefix(b"wor"))  # True

# get values
print(pt.get(b"hello"))  # None
print(pt.get(b"world"))  # 2

# overwrite
print(pt.insert(b"world", 3))  # 2
print(pt.get(b"world"))  # 3

# continuations for prefix
print(pt.continuations(b"wo"))  # [(b'world', 3)]

# prefixes of some key, returns list of (prefix length, value) tuples
key = b"world cup"
prefix_matches = pt.prefix_matches(key)
print(prefix_matches)  # [(5, 3)]
print(
    [(key[:length].decode(), value) for length, value in prefix_matches]
)  # [('world', 3)]

# same for ART
art = AdaptiveRadixTrie()

art.insert(b"hello", 1)
art.insert(b"world", 2)

print(art.delete(b"hello"))  # 1

print(art.contains(b"hello"))  # False
print(art.contains(b"world"))  # True
print(art.contains(b"wor"))  # False
print(pt.contains_prefix(b"hel"))  # False
print(pt.contains_prefix(b"wor"))  # True

print(art.get(b"hello"))  # None
print(art.get(b"world"))  # 2

print(art.insert(b"world", 3))  # 2
print(art.get(b"world"))  # 3

print(art.continuations(b"wo"))  # [(b'world', 3)]

key = b"world cup"
prefix_matches = art.prefix_matches(key)
print(prefix_matches)  # [(5, 3)]
print(
    [(key[:length].decode(), value) for length, value in prefix_matches]
)  # [('world', 3)]
```
playlist-mixer 0.11.0
Playlist Mixer for Spotify
Requires Python: <4.0,>=3.13

# Playlist Mixer for Spotify

Playlist Mixer is a CLI tool for Spotify to achieve true randomness. Because bultin shuffle is not really random.
It works by using existing playlists to update other ones. Tracks ary randomly added to the playlist, which is designed to be played without shuffle/smart shuffle enabled.

## Install

1. Install playlist-mixer from pypi. Its recommended to use [pipx](https://pipx.pypa.io/stable/) instead of pip, to prevent any dependency conflicts.

```shell
# pipx
pipx install playlist-mixer

# pip
pip install playlist-mixer
```

2. Ensure playlist-mixer is installed successfully

```shell
playlist-mixer version
```

3. Create a new Spotify App in [Spotify Developer Dashboard](https://developer.spotify.com/dashboard)

- App name: _choose for yourself_
- App description: _choose for yourself_
- Redirect URIs: `http://localhost:8000`
- APIs intended to use: Web API

## Usage

1. Login with your Spotify account and App. You need to login only once, credentials are persisted in your home folder.
You need the following information:

- App ID (see Spotify Developer Dashboard)
- App Secret (see Spotify Developer Dashboard)
- Redirect URL: `http://localhost:8000`

```shell
playlist-mixer login
```
A browser will open and allow you to Login with your Spotify Account.

2. Create a playlist. This playlist will be filled with your tracks in a random order. Create it and setup your privacy, title etc.

After creating the playlist, copy a link to the playlist (share > link). This link is used as a playlist target.

3. Mix playlists

```shell
# Use a playlist as source, and mix all tracks in another playlist
playlist-mixer mix --source <source-playlist> --playlist <target-playlist>

# A source/playlist can be either a link to a playlist
# https://open.spotify.com/playlist/playlistid
# or a URI to playlist
# spotify:playlist:playlistid

# Mix a playlist with multiple sources
playlist-mixer mix --source <source-playlist> --source <source-playlist> --playlist <target-playlist>

# Focus on the last x days. Focussing means, that tracks that were added in the last x days, are on top of the mixed playlist.
playlist-mixer mix --source <source-playlist> --playlist <target-playlist> --focus 10
```
micromechanics-indentationGUI 0.1.33
GUI for nanoindentation data

[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.11563149.svg)](https://doi.org/10.5281/zenodo.11563149)

<h2 align = "center">
micromechanics-indentationGUI
</h2>
<p align="center">
  <img
  src="https://raw.githubusercontent.com/micromechanics/indentationGUI/main/micromechanics_indentationGUI/pic/logo.png" 
  width="314"
  title="micromechanics-indentationGUI" >
</p>

# Install
- Create a new environment (python >= 3.8) using **anaconda-navigator** (https://www.anaconda.com/). In Anaconda's documentation (https://docs.anaconda.com/free/navigator/) you will learn:
  - how to **install** anaconda-navigator in the section of "*Anaconda Navigator* => *Installation*" (reading takes ~5 min), 
  - how to **create and activate** a new environment in the section of "*Anaconda Navigator* => *Tutorials* => *How to create a Python 3.5 environment from Anaconda2 or Anaconda3*" (reading takes ~5 min).

- In the terminal of the environment created by Anaconda Navigator, keyboard type the following command and press Enter
``` bash
pip install micromechanics-indentationGUI
```
# Upgrade
In the terminal, keyboard type the following command and press Enter
``` bash
pip install --upgrade micromechanics-indentationGUI
```
# Usage
Users need to know:
- For fast reading using **HDF5** files:
  - Using the given original file (e.g. the XLSX file for G200X), the HDF5 file will be automatically generated at the first calibration/calculation (or when an HDF5 file with the same name as the XLSX file does not exist).
  - The automatically generated HDF5 file has the same file name as the original file (e.g. the XLSX file for G200X) except the file extension of ".h5" and locates in the same folder as the original file.
  - The original file extension (e.g. '.xlsx' for G200X) should be given in the path instead of the file extension of the HDF5 file (".h5").
  - **[Important]** If you changed the content of the original file, please delete the correspoding HDF5 file.

Running by keyboard typing the following command and pressing Enter in the terminal
``` bash
micromechanics-indentationGUI
``` 
# Uninstall
In the terminal, keyboard type the following command and press Enter
``` bash
pip uninstall micromechanics-indentationGUI
```

# More detailed descriptions for developers

# Prepare and create a new version
- Delete RecentFiles.txt in /indentationGUI/micromechanics_indentationGUI

- Delete *.hf in /indentationGUI/micromechanics_indentationGUI/Examples

- Set "# pylint: skip-file" for all files named "***_ui.py"

- Test the code: linting, documentation and then the tests from the project's main directory
``` bash
pylint micromechanics_indentationGUI/
make -C docs html
# python tests/testVerification.py
```

Then upload/create-pull-request to GitHub, via
``` bash
./commit.py 'my message'
```
media-thumbnailer 1.0.1
Creates a grid of thumbnails for a media file.
Requires Python: >=3.8

# media-thumbnailer

`media-thumbnailer` is a CLI tool that produces a grid of thumbnails for a media file in a similar manner to a [contact print](https://en.wikipedia.org/wiki/Contact_print).

![Demo of a thumbnail grid image](.github/artefacts/demo.png)

## Prerequisites

`media-thumbnailer` requires FFmpeg and FFprobe to be installed and available on your system so that it can handle a wide array of multimedia content. It's available via standard package managers on Linux (e.g. `apt` or `pacman`) or macOS (e.g. `brew`), and on Windows it is available via Chocolatey and `winget`.
If the above options do not work, or you need support for a different platform, you can check for available FFmpeg builds on their [website](https://www.ffmpeg.org/download.html).


## Installation

To install from PyPI:
```bash
pip install -U media-thumbnailer
```

To install for development and testing purposes, either install directly via git:
```bash
pip install -U "media-thumbnailer @ git+https://github.com/gotloaf/media-thumbnailer@main"
```

Or, clone the repository and install in editable mode:
```bash
git clone https://github.com/gotloaf/media-thumbnailer.git
cd media-thumbnailer
pip install -U -e .
```

## Usage

You can use the utility like so:
```bash
media_thumbnailer video.mp4 --output grid.png
```

There are more arguments available:

> #### `--output`
> Location of the file to output to, as PNG. You can pass `-` to have the image sent to stdout instead.
>
> #### `--include-info`/`--exclude-info`
> Whether to include the media summary text at the top or not. Defaults to including it.
>
> #### `--include-head`/`--exclude-head`
> Whether to include the first frame of the video in the grid. Defaults to including it.
>
> #### `--include-tail`/`--exclude-tail`
> Whether to include the last frame of the video in the grid. Defaults to excluding it.
>
> #### `--column-count`
> How many columns to include in the grid. The number of thumbnails is calculated automatically based on the row and column count.
>
> #### `--row-count`
> How many rows to include in the grid. The number of thumbnails is calculated automatically based on the row and column count.
>
> #### `--padding`
> Padding in pixels around the video frames and summary text.
>
> #### `--font-size`
> Font size in pixels to use for the summary and timestamp text.

## Acknowledgements

To guarantee consistent font rendering, `media-thumbnailer` includes a copy of [Iosevka Extended Extrabold](https://fontlibrary.org/en/font/iosevka-extended), which is licensed under the OFL (SIL Open Font License).
balto-core 0.1.7
With balto, data analysts and engineers can build analytics the way engineers build applications.
Requires Python: >=3.8

<p align="center">
  <img src="https://raw.githubusercontent.com/balto-data/balto/main/etc/balto-banner.png" alt="balto logo" width="750"/>
</p>

# Welcome to Balto

Build durable data pipelines directly in Snowflake with no external orchestrators. Effortlessly scale your dbt projects from proof of concept to production grade data pipelines running millions of model executions per day. Orchestrate ML pipelines, data exports, and deletions directly in Snowflake with zero external dependencies. 

## Getting Started

Ready to get started? Check out the [installation instructions](https://baltodatatool.com). If you're already familiar with [dbt](https://github.com/dbt-labs/dbt-core), check out [our guide](https://baltodatatool.com) on what's new in Balto.

## Installation
Clone the repo and install from source, or install with pip:
```
pip install 'git+https://github.com/balto-data/balto.git@v0.0.10#egg=balto&subdirectory=core'
```

## Overview

![architecture](https://github.com/balto-data/balto/blob/main/etc/balto-diagram.svg)

Balto is comprised of two pieces. The Balto CLI, a drop-in replacement for the [dbt-core](https://github.com/dbt-labs/dbt-core) CLI, and the Balto orchestrator, which is implemented as a Snowflake Native App.  Balto orginated as a fork of dbt-core that has been rebuilt from the ground up to run as a Snowflake Native app. The following are the major design differences:

### Compilation

Balto simplifies the parsing process when building your project. Any database interactions are deferred during compilation, this allows us push all database interactions to the Balto Snowflake Native App installed in your account. This means if you use our [Github Integation](https://baltodatatool.com/cicd/), you can enable automated deployments without having to manage any external accounts or connections.

### Orchestration

Balto implements a batteries included orchestration engine inside the Snowflake App. When you deploy your
compiled projects via our Gitub integration (or via a call to our stored procedure), the Balto orchestrator handles deploying your compiled project from directly inside your Snowflake account.

Under the hood, Balto's orchestration engine uses Snowflake triggered tasks and streams to implement a completely event driven scheduler that allows it to scale to zero when no models are being executed.

### dbt macro executor

Balto includes a lightweight re-implementation of dbt's Jinja `macro` extension that allows it to execute your model inside a stored procedure that runs on the same warehouse the underlying queries get run on.

## Reporting bugs and contributing code

- Want to report a bug or request a feature? Let us know and open [an issue](https://github.com/balto-data/balto/issues/new/choose)
rcmanyutils 0.2.0
Various utilities for making python development easier
Requires Python: >=3.13.1

# rcmanyutils

Utilities made to support my personal development, sort of a "catch all" package

## Structure

```
.
├── .coveragerc - Configure code coverage generation
├── .gitignore - Configure files ignores by git commands
├── .gitlab-ci.yml - Configure our gitlab CI pipeline
├── .pre-commit-config.yaml - Configure our pre-commit for code quality checks
├── .python-version - Set our python version, used for python selection in terminals
├── .vscode - Configure our vscode workspace
│   ├── launch.json - Settings used for debugging/running code
│   └── settings.json - Workspace settings
├── README.md - YOU ARE HERE
├── flake.lock - Stores the state of our nix flake
├── flake.nix - Configure our nix environment
├── pyproject.toml - Our project configuration
├── src - Source code to be packaged with the wheel
│   └── rclib - Package folder
│       └── utils - Contains utilities for different types
│           ├── __init__.py
│           ├── dictionary.py - Utilities for dictionaries
│           ├── errors - Utilities for handling or generating errors
│           │   ├── decorators.py - Decorators that help enforce code constraints
│           │   └── exceptions.py - Common Exceptions that can be raised
│           └── files
│               └── search.py - Utilities for searching files
└── uv.lock - Stores our installed python versions
```
terra-python 0.0.17
A python wrapper for the Terra API.
Requires Python: >=3.8.0

[![GitHub license](https://img.shields.io/github/license/tryterra/terra-client-python)](https://github.com/tryterra/terra-client-python/blob/master/LICENSE)
[![docs](https://github.com/tryterra/terra-client-java/actions/workflows/docs.yml/badge.svg)](https://tryterra.github.io/terra-client-python/)

# Terra Python Package

A wrapper in python for the Terra endpoints and models.

User Guide: https://docs.tryterra.co/docs/python-project-1


Install using

```sh
pip install terra-python
```

Then import the `Terra` class from terra.base_client

Initialise a new Terra instance with:

```py
from terra.base_client import Terra

# For user authentication
terra = Terra(api_key='YOUR API KEY', dev_id='YOUR DEV ID');

# For web hook endpoints
terra = Terra(api_key='YOUR API KEY', dev_id='YOUR DEV ID', secret='YOUR TERRA SECRET');
```

Now you can call the following functions from the instance:

- `from_user_id`
- `get_activity_for_user`
- `get_body_for_user`
- `get_daily_for_user`
- `get_sleep_for_user`
- `get_athlete_for_user`
- `get_menstruation_for_user`
- `get_nutrition_for_user`
- `generate_widget_session`
- `generate_authentication_url`
- `get_user_info`
- `deauthenticate_user`
- `list_users`
- `list_providers`
- `check_terra_signature`
- `handle_flask_webhooks`
- `handle_webhooks`

The documentation for the wrapper is available here: https://tryterra.github.io/terra-client-python/

In addition, all the data models documented on [https://docs.tryterra.co/docs/data-models] are available to import and use.

The models support autocompleting the types to manipulate data coming from Terra
pattan-mongo-survey 1.1.2
Support a surveyJS frontend with a mongodb backend
Requires Python: >=3.10
Keywords: mongo, surveyJS

### PATTAN-MONGO-SURVEY

Support a surveyJS frontend with a mongodb backend.

## Configuration
    
# crete an instance of a the pattan-mongo-survey class with a dictionary containing the following keys.
1. MONGDB_USER
2. MONGDB_PASSWD
3. MONGDB_HOST
4. MONGDB_DB
5. MONGDB_SURVEY_COLLECTION - collection used to store survey questions
6. MONGDB_DB_RESPONSE_COLLECTION - collection used to store survey responses

## Documentation
[Docs](https://github.com/pattan-net/pattan-mongo-survey/tree/main/docs)

## Logging
pattan-mongo-survey creates its own logger (of the same name) which the calling application can configure.

```python
from pattan_mongo_survey import MongoSurveyService
import logging

mongo_logger = logging.getLogger('pattan_mongo_survey')
mongo_logger.addHandler(logging.FileHandler('example.log'))
mongo_logger.setLevel(logging.DEBUG)
```
sensivalidate 1.0.0
A module to find credit card, UK bank account, sort code and postcode in text


  

# Sensivalidate

  

`Sensivalidate` is a Python package designed to help identify sensitive data in text, including credit card numbers, UK bank account numbers, UK sort codes, and UK postcodes. It uses regular expressions for pattern matching, and performs real validation for credit card numbers using the `creditcard` Python package.

  

## Features

  

-  **Credit Card Validation**: Validates credit card numbers by checking for valid formats and using the `creditcard` package to verify the card's authenticity.

-  **UK Bank Account Number Detection**: Identifies UK bank account numbers (8-digit numbers).

-  **UK Sort Code Detection**: Detects UK sort codes in formats like `xx-xx-xx`, `xxxxxxxx`, and `xx xx xx`.

-  **UK Postcode Detection**: Matches UK postcodes based on standard patterns.

  

**Note**: The package performs pattern matching for bank account numbers, sort codes, and postcodes, but only credit card numbers are validated for authenticity.

  

## Installation

  

You can install the package using pip:

  

```bash

pip install sensivalidate

```

  

Or, if you've downloaded the package:

  

```bash

pip install sensivalidate-0.1.tar.gz

```

  

## Usage

  

```python

from sensivalidate import is_sensitive_data

result = is_sensitive_data("your text here")

if result:
	print("Sensitive data detected.")
else:
	print("No sensitive data found.")

```

  

The `is_sensitive_data` function checks the provided text for sensitive data and returns `True` if any of the following are detected:

- Valid credit card number

- UK bank account number

- UK sort code

- UK postcode

  

## Code Overview

  

-  **`_is_credit_card(text)`**: Detects and validates credit card numbers using regex and the `creditcard` package.

-  **`_is_uk_bank_account_and_sort_code(text)`**: Matches UK bank account numbers and sort codes.

-  **`_is_uk_postcode(text)`**: Matches UK postcodes.

-  **`is_sensitive_data(text)`**: The main function that checks for sensitive data by calling the individual validator functions.

  

## Contributing

  

Feel free to fork this repository and contribute. If you find any bugs or have ideas for improvements, please create an issue or submit a pull request.

  

## License

  

This project is licensed under the MIT License.
skillit 0.2.0
A package that lets you chef up new skills for KOS-compatible robots
Requires Python: >=3.11

# skillit

A package that lets you chef up new skills for KOS-compatible robots

> ⚠️ **Warning**  
 This package is under development and currently only supports joint skills.


## Installation

```bash
pip install skillit
```

## Setup
```bash
pip install -e ".[dev]"
```

See the [examples](examples) directory for examples of how to use skillit.

To quickly get your robot standing in place, take the following steps:

1. Record a standing position using the record functionality:
```bash
python examples/play_record_example.py record --ip YOUR_ROBOT_IP --skill-name standing
```

2. When prompted, physically move your robot into a stable standing position. The process will be:
   - Press Ctrl+C to start recording
   - Hold the robot steady in the standing position for a few seconds
       - Note that *all* actuators will be disabled, so it will be completely limp
   - Press Ctrl+C again to stop recording

3. Play back the recorded standing position:
```bash
python examples/play_record_example.py play --ip YOUR_ROBOT_IP --file standing.json
```

This will create a basic standing skill that you can use as a foundation for more complex movements. See the [examples](examples) directory for more advanced skill demonstrations.
diha 0.1.0
Diagramas de Interacción para elementos de barra Hormigón Armado
Requires Python: >=3.7

# diha

Diagramas de Interacción para elementos de Hormigón Armado

Paquete para el diseño de secciones de hormigón armado

## Installation

### Install from PyPi:

`pip install diha`

Para usar desde la línea de comandos:

`pip install "diha[cli]"`


## Ejemplo de uso por linea de comando:

`diha --help`
```
Usage: diha [OPTIONS] COMMAND [ARGS]...

Options:
  --help  Show this message and exit.

Commands:
  plot  diha plot Commandline
```

### Imprimir un diagrama
`diha plot --help`
```
Usage: diha plot [OPTIONS] INPUT_FILE

  diha plot Commandline

  Grafica un diagrama de interacción en 2D para una sección predefinida.

Options:
  --output_file TEXT  Nombre del archivo de salida con el grafico del diagrama
  --theta FLOAT       Rotación del vector de momentos en grados respecto del
                      eje +Z  [default: 0]
  --points INTEGER    Numero de puntos a calcular sobre la curva de
                      interacción  [default: 32]
  --debug
  --help              Show this message and exit.

```

Imprimir un diagrama con los valores por defecto

`diha plot section.json`
rpa-scada 1.0.2
Scraper of SCADAs without browser
Keywords: Scraper SCADA

# RPA
Scraper para obtener los datos desde el acceso web del SCADA sin la necesidad de un navegador

## Build
para construir el paquete:
```
python setup.py sdist bdist_wheel
```

para subir el paquete a pypi:
```
python -m twine upload dist/*
```

## instalacion
para instalar el paquete local
```
pip install PATH_MODULE/dist/mipaquete-0.1.tar.gz
```