semvec/pypi-packages huggingface dataset:
osprofiler 4.3.0
OpenStack Profiler Library
Requires Python: >=3.9

===================================================
 OSProfiler -- Library for cross-project profiling
===================================================

.. image:: https://governance.openstack.org/tc/badges/osprofiler.svg
    :target: https://governance.openstack.org/tc/reference/tags/index.html

.. Change things from this point on

.. image:: https://img.shields.io/pypi/v/osprofiler.svg
    :target: https://pypi.org/project/osprofiler/
    :alt: Latest Version

.. image:: https://img.shields.io/pypi/dm/osprofiler.svg
    :target: https://pypi.org/project/osprofiler/
    :alt: Downloads

OSProfiler provides a tiny but powerful library that is used by
most (soon to be all) OpenStack projects and their python clients. It
provides functionality to be able to generate 1 trace per request, that goes
through all involved services. This trace can then be extracted and used
to build a tree of calls which can be quite handy for a variety of
reasons (for example in isolating cross-project performance issues).

* Free software: Apache license
* Documentation: https://docs.openstack.org/osprofiler/latest/
* Source: https://opendev.org/openstack/osprofiler
* Bugs: https://bugs.launchpad.net/osprofiler
* Release notes: https://docs.openstack.org/releasenotes/osprofiler
llm-tools-memory 0.1.1
Memory tools for LLM
Requires Python: >=3.9

# llm-tools-memory

[![PyPI](https://img.shields.io/pypi/v/llm-tools-memory.svg)](https://pypi.org/project/llm-tools-memory/)
[![Changelog](https://img.shields.io/github/v/release/tombedor/llm-tools-memory?include_prereleases&label=changelog)](https://github.com/tombedor/llm-tools-memory/releases)
[![Tests](https://github.com/tombedor/llm-tools-memory/actions/workflows/test.yml/badge.svg)](https://github.com/tombedor/llm-tools-memory/actions/workflows/test.yml)
[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/tombedor/llm-tools-memory/blob/main/LICENSE)

Memory tools for LLM

## Installation

Install this plugin in the same environment as [LLM](https://llm.datasette.io/).
```bash
llm install llm-tools-memory
```
## Usage

To use this with the [LLM command-line tool](https://llm.datasette.io/en/stable/usage.html):

```bash
llm --tool Memory "Create memory: my name is Ted" --tools-debug
```

With the [LLM Python API](https://llm.datasette.io/en/stable/python-api.html):

```python
import llm
from llm_tools_memory import create_memory

model = llm.get_model("gpt-4.1-mini")

result = model.chain(
    "Example prompt goes here",
    tools=[create_memory]
).text()
```

## Development

To set up this plugin locally, first checkout the code. Then create a new virtual environment:
```bash
cd llm-tools-memory
python -m venv venv
source venv/bin/activate
```
Now install the dependencies and test dependencies:
```bash
llm install -e '.[test]'
```
To run the tests:
```bash
python -m pytest
```
styleio 0.0.3
A simple output styler in Python
Requires Python: >=3.6

# How to use

## Requirements
- Python 3.6 or more
- Windows*

## How to use
First install with pip
```commandline
pip install styleio
```
Now import
```python
import styleio
```

First, you need to think about how your text will look like.
You can have text styled. Just simply enter one of bold, dim, italic, underline, blink, inverse, hidden,  or strikethrough

Now, color your text. Color is optional, but you have four color mode choices: rgb**, 256 colors**, 16 colors, and bright colors***

*I have not tested on an operating system without windows, feel free to open an issue with the readme saying otherwise on github
**RGB and 256 color modes do NOT support styled text
***Only terminals that support the aixterm specification (mine did) support brightcolors

If you have rgb colors, the mode will be 'rgb' and the color will be a tuple of (r, g, b), where 0 <= r, g, b, <= 255, and the mode will be 'rgb'
If you have 256 colors, the mode will be 'colors256' and the color will be an id 0 <= id <= 255, where each id means these colors:
![](https://user-images.githubusercontent.com/995050/47952855-ecb12480-df75-11e8-89d4-ac26c50e80b9.png)
0-7: standard colors (as in ESC [ 30–37 m)
8–15: high intensity colors (as in ESC [ 90–97 m)
16-231: 6 × 6 × 6 cube (216 colors): 16 + 36 × r + 6 × g + b (0 ≤ r, g, b ≤ 5). Some interpret these as constant increments, while others have specific values for each one
232-255: grayscale from dark to light in 24 steps.

With 16 colors (normal, recommended), the mode will be 'colors16', and color will be one of
'black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white', 'default'
Bright colors are just like 16 colors, its just that they will look brighter on the terminal and the mode is 'brightcolors'

## Styling the text

First, specify the list of styles
```python
graphics = ['bold', 'italic']
```
Next, specify the color. Say I want bright red
```python
color = 'red'
mode = 'brightcolors'
```

Now, finally style the output for a italicized bold bright red "Hello, World" message to appear.

```python
string = style(
    text="Hello, World",
    graphics=graphics,
    color=color,
    mode=mode
)
print(string)
```
redisfacade 1.0.7
A package to implement a facade for accessing Redis databases
Requires Python: >=3.8

---

# Redis Facade

## Instalación

```bash
pip3 install redisfacade
```

## Manual de uso
1. **Variables de Entorno**

| Variable | Tipo de dato |
|:-|-:|
|REDIS_HOST|string|
|REDIS_PORT|int|
|REDIS_PASSWORD|string|

2. **Funciones**:
   - **`set_key_value(db: int, key:str, value: Any) -> bool`**: Este método permite guardar en redis un tipo de dato key - value.
   - **`get_key_value(db: int, key: str, ttl: timedelta) -> Any`**: Este método permite obtener un tipo de dato key - value.
   - **`set_list_str(db: int, list_name: str, intems: List[str]) -> bool`**: Este método permite guartar un tipo de dato lista de string.
   - **`get_list_str(db: int, list_name: str) -> List[str]`**: Este método permite obtener una lista de string completa.
   - **`pop_list_str(db: int, list_name: str) -> str`**: Este método permite hacer pop del primer elemento en una lista.
   - **`len_list(db: int, list_name: str) -> str`**: Este método permite ver el tamaño de una lista.
   - **`set_json_data(db: int, json_name, json_key, json_data: Any, ttl: timedelta) -> bool`**: Este método permite guardar un objeto de tipo json.
   - **`get_key_json_data(self, db: int, json_name: str, json_key: str) -> Any`**: Este método permite obtener una llave de objeto de tipo json.
   - **`def get_json_data(self, db: int, json_name: str) -> Any`**: Este método permite obtener un objeto de tipo json.

3. **Ejemplos de Uso**
```py

from redisfacade.facade import RedisFacade
from typing import Any

if __name__ == "__main__":
   # inicializar singleton
   redisdb = RedisFacade()

   # guardar datos de tipo clave - valor
   redisdb.set_key_value(0, "hola", "mundo", ttl=timedelta(days=3))

   # obtener datos de clave en especifico
   value: Any = redisdb.get_key_value(0, "hola")
   print(value)
   
   # guardar datos en lista
   is_save: bool = redisdb.set_list_str(0, "mylist", ["hola", "mundo", "beetmann"])
   print(is_save)
   
   # obtener datos de lista
   list = redisdb.get_list_str(0, "mylist")
   print(list)
   
   # pop del primer elemento de la lista
   list = redisdb.pop_list_str(0, "mylist")
   print(list)
   
   # tamaño de lista
   print(redisdb.len_list(0, "mylist"))
   
   # Guardar dato de tipo json
   is_saved: bool 
   is_saved = redisdb.set_json_data(0, "json_1", "1", "hola_mundo", ttl=timedelta(days=3))
   print(is_saved)
   # obtener dato de tipo json
   is_saved = redisdb.set_json_data(0, "json_1", "2", {"hola": "mundo"}, ttl=timedelta(days=3))
   print(is_saved)

   # obtine una llave de un json
   json_value_1 = redisdb.get_key_json_data(0, "json_1", "3", ttl=timedelta(days=3))
   print(json_value_1)
   
   # obtine un json completo
   json_value = redisdb.get_json_data(0, "json_1")
   print(json_value)

```

---

By: Alan Medina ⚙️
hydra-email-manager 0.1.37
Gerenciador de email office 365
Requires Python: >=3.12

# Hydra Email Manager

Hydra Email Manager é uma biblioteca Python que facilita o envio e recebimento de emails utilizando a API do Microsoft Graph. A classe `HydraEmailManager` permite gerenciar emails de forma eficiente, oferecendo funcionalidades como verificação de senha, envio de emails com anexos, download de emails e obtenção de IDs de pastas.

## Instalação

Para instalar o Hydra Email Manager, você pode usar o pip:

```
pip install hydra_email_manager
```

## Uso

### Importando a classe

```python
from hydra_email_manager import HydraEmailManager
```

### Inicializando o gerenciador de emails

```python
email_manager = HydraEmailManager()
```

### Verificando a senha do usuário

```python
is_valid = email_manager.verificar_senha("usuario@example.com", "senha")
```

### Enviando um email

```python
email_manager.enviar_email(
    user_email="destinatario@example.com",
    user_from="remetente@example.com",
    subject="Assunto do Email",
    body="Corpo do email",
    attachment="caminho/para/anexo.txt"
)
```

### Baixando emails

```python
email_manager.baixar_emails(user_email="usuario@example.com", folder_id="ID_da_pasta")
```

### Obtendo IDs das pastas

```python
email_manager.obter_id_pastas(user_email="usuario@example.com")
```

## Testes

Os testes para a classe `HydraEmailManager` estão localizados no diretório `tests`. Para executar os testes, você pode usar o seguinte comando:

```
pytest tests/test_hydra_email_manager.py
```

## Contribuições

Contribuições são bem-vindas! Sinta-se à vontade para abrir um problema ou enviar um pull request.

## Licença

Este projeto está licenciado sob a Licença MIT. Veja o arquivo `LICENSE` para mais detalhes.
kevinbotlib-deploytool 0.0.1a3
KevinbotLib Robot Deployment Tool
Requires Python: >=3.10

# KevinbotLib DeployTool

[![PyPI - Version](https://img.shields.io/pypi/v/kevinbotlib-deploytool.svg)](https://pypi.org/project/kevinbotlib-deploytool)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/kevinbotlib-deploytool.svg)](https://pypi.org/project/kevinbotlib-deploytool)
[![test](https://github.com/meowmeowahr/kevinbotlib-deploytool/actions/workflows/test.yml/badge.svg)](https://github.com/meowmeowahr/kevinbotlib-deploytool/actions/workflows/test.yml)
[![Codacy Badge](https://app.codacy.com/project/badge/Grade/6be6caaa88b040bc9d18171b6b079492)](https://app.codacy.com/gh/meowmeowahr/kevinbotlib-deploytool/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)

-----

Remotely update KevinbotLib-powered robot code

## Table of Contents

- [Installation](#installation)
- [License](#license)

## Installation

```console
pip install kevinbotlib-deploytool
```

## License

`kevinbotlib-deploytool` is distributed under the terms of the [LGPL-3.0-or-later](https://spdx.org/licenses/LGPL-3.0-or-later.html) license.
rtrimmer 0.1.0
Lightweight Python package to trim RTTM diarization files and audio files
Requires Python: >=3.8
Keywords: rttm, diarization, audio, trimming, pyannote

# rtrimmer

Lightweight Python package to trim RTTM diarization files and optionally audio files to a user-specified time range.

## Features
- Trim RTTM files to a specified time range
- Adjust segment durations if they overlap the max duration
- Optionally trim audio files using ffmpeg
- Batch support for folders
- CLI and Python API
- Logging and input validation

## Installation

```bash
pip install rtrimmer
```

## Usage

### CLI

Trim an RTTM file to the first 5 minutes (300 seconds):

```bash
rttm-trim --rttm input.rttm --output-rttm trimmed.rttm --duration 300
```

Trim both RTTM and audio file:

```bash
rttm-trim --rttm input.rttm --audio input.wav --output-rttm trimmed.rttm --output-audio trimmed.wav --duration 300
```

Batch trim all RTTM files in a folder:

```bash
rttm-trim --rttm-folder ./rttms --output-folder ./trimmed_rttms --duration 300
```

Trim starting from a specific time point (e.g., 60 seconds in) for 5 minutes:

```bash
rttm-trim --rttm input.rttm --output-rttm trimmed.rttm --start-time 60 --duration 300
```

### Python API

```python
from rtrimmer import trim_rttm, trim_audio, trim_rttm_folder

# Trim a single RTTM file
trim_rttm("session1.rttm", "session1_trimmed.rttm", max_duration=300)

# Trim starting from 60 seconds in
trim_rttm("session1.rttm", "session1_trimmed.rttm", max_duration=300, min_time=60)

# Trim audio file
trim_audio("session1.wav", "session1_trimmed.wav", duration=300, start_time=0)

# Batch process a folder of RTTM files
results = trim_rttm_folder("./rttms", "./trimmed_rttms", max_duration=300)
print(f"Processed {len(results)} files")
```

## How It Works

### RTTM Trimming Logic

The package handles various edge cases when trimming RTTM files:

1. **Segments fully within the target range**: Kept as is
2. **Segments starting before the target range but extending into it**: Start time adjusted to the beginning of the target range, duration shortened accordingly
3. **Segments extending beyond the target range**: Duration shortened to end at the target range boundary
4. **Segments outside the target range**: Excluded from the output

### Audio Trimming

Audio trimming is performed using ffmpeg, which must be installed and available in your PATH. The package attempts to use the copy codec for faster processing, but falls back to re-encoding if needed.

## Requirements
- Python 3.8+
- ffmpeg (for audio trimming, must be installed and in PATH)

## Example

Suppose you have a diarization RTTM file and a corresponding WAV file for a 1-hour meeting, but you only want the first 5 minutes:

```bash
rttm-trim --rttm meeting.rttm --audio meeting.wav --output-rttm meeting_5min.rttm --output-audio meeting_5min.wav --duration 300
```

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
icdmap 0.1.1
Offline ICD-9 and ICD-10 code mapping using SQLite
Requires Python: >=3.7

# ICDMap

A command-line and Python library for converting ICD codes using an offline SQLite database.

## Features

- ✅ Offline lookup via included `icd_mapping.db` and `death_cause_mapping.db`
- ✅ CLI and Python API support
- ✅ Structured JSON output with Chinese/English descriptions and mapping code
- ✅ Supports ICD-9 → ICD-10 and ICD-10 → ICD-9
- ✅ Auto-detect or manual specification of code type
- ✅ Supports cause-of-death mapping by ICD code or Cause code

## Usage

### 1. CLI

```bash
# Single code (auto-detect type)
icdmap 250.00

# Force as ICD-9 input
icdmap 250.00 --source icd9

# Force as ICD-10 input
icdmap I10 --source icd10

# Batch from CSV with column 'ICD9_CODE'
icdmap --csv input.csv -o output.json

# Batch with manual source type
icdmap --csv input.csv --source icd9 -o output.json

# Death cause mapping by ICD-9
icdmap 410 --mode death --source icd9

# Death cause mapping by CSV
icdmap --csv death.csv --mode death -o death_output.json
```

### 2. Python API

```python
from icdmap import ICDConverter, DeathCauseMapper

# ICD mapping
mapper = ICDConverter()
mapper.convert("250.00")
mapper.convert(["250.00", "I10"])

# Death cause mapping
death_mapper = DeathCauseMapper()
death_mapper.convert("41401", source="icd9")
death_mapper.convert(["41071", "431"], source="icd9")
```

### 3. Batch Mapping with Pandas (and tqdm progress)

```python
import pandas as pd
from icdmap import ICDConverter, DeathCauseMapper

# 建立範例資料（模擬 ICD-9 code）
df = pd.DataFrame({
    "ICD9_CODE": ["250.00", "41401", "0389", "431", "41071"]
})

# ICD mapping
icd_mapper = ICDConverter()
icd_results = icd_mapper.convert(df["ICD9_CODE"])

def get_icd_field(code, field):
    return icd_results[code][0][field] if icd_results[code] else pd.NA

df["ICD-10"] = df["ICD9_CODE"].map(lambda x: get_icd_field(x, "ICD-10"))
df["ICD-10 English"] = df["ICD9_CODE"].map(lambda x: get_icd_field(x, "ICD-10 English"))
df["ICD-9 English"] = df["ICD9_CODE"].map(lambda x: get_icd_field(x, "ICD-9 English"))

# Death cause mapping
death_mapper = DeathCauseMapper()
death_results = death_mapper.convert(df["ICD9_CODE"], source="icd9")

def get_death_field(code, field):
    return death_results[code][0][field] if death_results[code] else "Other causes"

df["CAUSE_CN"] = df["ICD9_CODE"].map(lambda x: get_death_field(x, "Cause_Chinese"))
df["CAUSE_EN"] = df["ICD9_CODE"].map(lambda x: get_death_field(x, "Cause_English"))
```

## LICENSE

MIT License

Copyright (c) 2025
currency-rate-bcv 0.1.0
Librería para obtener la tasa oficial del Euro y Dólar publicada por el Banco Central de Venezuela (BCV).
Requires Python: >=3.6

# currency_rate_bcv

LibrerÃ­a en Python para obtener la tasa oficial del Euro y DÃ³lar publicada por el Banco Central de Venezuela (BCV).

## DescripciÃ³n

`currency_rate_bcv` permite consultar de forma sencilla y programÃ¡tica el valor actual del Euro y el DÃ³lar segÃºn la tasa oficial publicada en la pÃ¡gina del BCV. Ideal para proyectos financieros, aplicaciones de conversiÃ³n de divisas o cualquier sistema que requiera la tasa oficial venezolana.

## InstalaciÃ³n

Puedes instalar la librerÃ­a usando pip:

```sh
pip install currency_rate_bcv
```

O bien, clona el repositorio y usa:

```sh
pip install .
```

## Requisitos

- Python >= 3.6
- requests
- beautifulsoup4

## Uso

```python
import asyncio
from currency_rate_bcv.currency import Currency

async def main():
    currency = Currency()
    euro = await currency.getEuro
    print(f"Tasa oficial del Euro: {euro}")
    dollar = await currency.getDollar
    print(f"Tasa oficial del DÃ³lar: {dollar}")

if __name__ == "__main__":
    asyncio.run(main())
```

## MÃ©todos

- `getEuro`: Devuelve la tasa oficial del Euro.
- `getDollar`: Devuelve la tasa oficial del DÃ³lar.

Ambos mÃ©todos son propiedades asÃ­ncronas.

## Licencia

MIT

## Autor

Jarvis Gabriel Huice Padron  
[jarvis.realg@gmail.com](mailto:jarvis.realg@gmail.com)
dsf-python 3.6.0
Python interface to access DuetSoftwareFramework
Requires Python: <4,>=3.7
Keywords: Duet3D, DuetSoftwareFramework, DSF, dsf-python

# Duet Software Framework Python Bindings

This is also availabe as a [pip package on pypi](https://pypi.org/project/dsf-python/)

Find out more about [Duet Software Framework](https://github.com/Duet3D/DuetSoftwareFramework).

Examples of the [Duet Software Framework Python Bindings](https://github.com/Duet3D/dsf-python/tree/main/examples).

Get in touch with the community at [Duet Software Framework Forum](https://forum.duet3d.com/category/31/dsf-development) for bug reports, discussion and any kind of exchange.

## Installation
This package contains a `setup.py` so it can be installed with `python3 setup.py install`.

## Usage
See included `examples/` folder for various use cases.