semvec/pypi-packages huggingface dataset:
RuletaCasino 1.0.0
La ruleta de casino más chuli.
Requires Python: >=3.8

Bienvenido a la ruleta de este casino

Esto funciona de forma muy sencilla:
    1º. Introduces un dinero base que simula tu liquidez real, en otras palabras son los ahorros totales que tienes.
    2º. En base a ese dinero eliges cuanto apostar. No puedes apostar por encima de tu base.
    3º. Se mostrara un pintoresco menú de selección donde deberás elegir el tipo de apuesta. Debes seguir atentamente las instrucciones de cada una. 

        3.1. Colores: Al rojo o al negro nada mas y nada menos.
        3.2. Tercios: Primer, segundo o tercer tercio. Solo uno de ellos te llevará al ansiado premio.
        3.3. Números: el hombre que caza dos conejos con caza ninguno, el hombre que apuesta a toda la rule tampoco. 
        3.4. Pares e impares: Como los colores pero con menos connotaciones racistas y comunistas. 
        
    4º. Si tu saldo base llega a 0 pierdes, pero no hay limite superior.


IMPORTANTE: para hacer funcionar el código simplemente ejecuta el programa main.py

Un sabio de España dijo una vez:
                                        "Puedes perder el cien por cien.
                                            Pero puedes ganar el mil por cien."
                                                                ~ Maestro Gooning ~
pydropsonde 0.5.2
Tools to process dropsonde data
Requires Python: >3.12


![Logo](docs/source/_static/pydropsonde_logo.svg)
# pydropsonde


The documentation is hosted at [atmdrops.github.io/pydropsonde/](https://atmdrops.github.io/pydropsonde/).
It is built with [sphinx](https://www.sphinx-doc.org/) and deployed with [github pages](https://pages.github.com/).
filefisher 1.2.0
find and parse file and folder names
Requires Python: >=3.11
Keywords: path folder parse

# Filefisher

_A handy tool to find and parse file and folder names._

Filefisher is a python package that can create or find file and folder names according
to a pattern you define. This is handy if you have many folders or files that follow a
predefined naming structure.

## Documentation

Learn more about filefisher in its official documentation at [https://filefisher.readthedocs.io](https://filefisher.readthedocs.io)

## Get in touch

Don't hesitate to ask usage questions, report bugs, suggest features or view the source
code on GitHub under [mpytools/filefisher](https://github.com/mpytools/filefisher).

## License

filefisher is published under a MIT license.
akaibu 0.5.0
Add your description here
Requires Python: >=3.14

# Akaibu

Akaibu reads arXiv RSS feed and finds papers that match your requirements by using LLMs.


## Setup

### Install

```sh
uv tool install akabu
```


### Set your LLM provider

If you have ollama running on your machine, just do,

```sh
akaibu set-endpoint http://localhost:11434/v1 ollama
```

The first argument is the url for the LLM API endpoint, the second is the key. For local ollama, you don't need a key, so it can actually be anything.


### Create a feed

A feed is composed of three things,

- Name: Can be any string. This is just to identify the feed.
- URL: This is a URL for the arXiv RSS feed you want to subscribe. Check [this page](https://info.arxiv.org/help/rss.html) to know how it works. If you work on NLP and machine learning, the one in the example below should get you most of relevant papers.
- Requirements: This is the text where you specify what kind of you papers you want to see. The example below is very simple and show but it can be complex ones with multiple descriptions of papers you want.

```sh
akaibu create-feed "awesome-llms" "https://rss.arxiv.org/rss/cs.LG+cs.CL" "I want any papers about LLMs."
```

Can be more complex

```sh
akaibu create-feed "llm-agent-memory" "https://rss.arxiv.org/rss/cs.LG+cs.CL" "Papers that that explore the use of LLMs as Agents. Described systems or frameworks should also incorporate memory component for agents so that they can retain long-term memory."
```


## Use it

After setting up everything, finally, you can run the command to get the papers, simply run the following command

```sh
akaibu <number-of-papers-to-consider> <model-name> -l <library-name>
```

So, an example that corresponding the previous one would be something like,

```sh
akaibu 25 qwen3:4b -l awesome-llms
```

This will download 25 most recent papers from arXiv RSS feed, and filter the ones that match your requirements and present with a short summary.
The result would look like,

![](./assets/screenshot.png)

`akaibu` saves which papers have been scanned with an LLM, so you cannot have the same papers recommended.


## Read past papers

All the previously found relevant papers are saved in a database (locally on your machine ofc), you can see them by running,

```sh
akaibu show-past-papers <library-name>
```

You can also print them as markdown file which makes it easier to keep in your note or share with your colleagues,

```sh
akaibu show-past-papers <library-name> --in-markdown
```

## Road map

### It takes time to consume many papers

Currently all of the papers are checked by an LLM. If you are digesting many papers at once, this can take time. I am planning to pre-filter with a ligher model before LLM check.
forged-client 0.2.0
Forged.dev Client library
Keywords: api, client, database, embedded

# Forged Python Client

This package is a client to interface with the forged.dev manufacturing/provisioning service.

When used in the automated Forged provisioner UI, uploading data blocks can be accomplished as
simply as:

```py
import forged

def main():
    # Upload a single block value for the current device.
    forged.upload_value("my_block_name", 10.0)
```

Forged also supports async code natively:
```py
from forged import Forged

async def main():
    await Forged.upload_value("my_block", 10.0)
    blocks = await Forged.blocks()
    assert blocks["my_block"] == 10.0
```
lazyreq 0.1.1
A library for manage dependencies.
Requires Python: >=3.9

<p align="center">
  <img src="https://img.shields.io/badge/-lazyreq-blue?style=for-the-badge&logo=python&logoColor=white" alt="lazyreq"/>
</p>

---

<p align="center">
  🐍 Lightweight and convenient Python library for LazyImport.
</p>

<p align="center">
  <a href="https://pypi.org/project/lazyreq/">
    <img src="https://img.shields.io/pypi/v/lazyreq?color=blue&label=PyPI&style=flat-square" alt="PyPI version">
  </a>
  <a href="https://github.com/INetrois/lazyreq/actions/workflows/pypi-publish.yml">
    <img src="https://img.shields.io/github/actions/workflow/status/INetrois/lazyreq/pypi-publish.yml?branch=main&label=CI&style=flat-square" alt="CI">
  </a>
  <a href="https://github.com/INetrois/lazyreq/blob/main/LICENSE">
    <img src="https://img.shields.io/github/license/INetrois/lazyreq?style=flat-square" alt="License">
  </a>
</p>


## 🔹 Features

- LazyImport
- AutoInstall package with pip

## 💻 Installation

```bash
pip install lazyreq
```

## 🚀 Usage

```
from lazyreq import require

np = require("numpy")
print(np.arange(5))
```

<p align="center"> Made with ❤️ by <a href="https://github.com/INetrois">INetrois</a> </p>
stt-aligner 0.1.0
A minimalistic library to align openai whisper word timestamps with the original text.
Requires Python: >=3.9
Keywords: stt, whisper, alignment, speech-to-text, transcription

# STT Aligner

A minimalistic Python library to align OpenAI Whisper word-level timestamps with the original transcription text. This is useful for applications that need precise word timing in speech-to-text outputs.

## Features

- Aligns Whisper's timestamped words with the full text using sequence matching.
- Handles Unicode normalization for better matching.
- Provides preview methods to visualize alignments.
- Lightweight with minimal dependencies (only Pydantic).

## Installation

Install from PyPI:

```bash
pip install stt-aligner
```

Or install from source:

```bash
git clone https://github.com/mishapankin/stt-aligner.git
cd stt-aligner
pip install .
```

## Usage

First, obtain Whisper's transcription output with word-level timestamps. For example, using the Whisper API or CLI with `--word_timestamps True`.

### Basic Example

```python
from stt_aligner import UnprocessedTranscription, Transcription

# Example Whisper output (simplified)
whisper_data = {
    "text": "Hello world, this is a test.",
    "words": [
        {"start": 0.0, "end": 0.5, "word": "Hello"},
        {"start": 0.5, "end": 1.0, "word": "world,"},
        {"start": 1.0, "end": 1.5, "word": "this"},
        {"start": 1.5, "end": 2.0, "word": "is"},
        {"start": 2.0, "end": 2.5, "word": "a"},
        {"start": 2.5, "end": 3.0, "word": "test."},
    ]
}

unprocessed = UnprocessedTranscription(**whisper_data)
transcription = Transcription(unprocessed)

# Print aligned preview
transcription.dump_preview()
```

This will output something like:

```
Hello world, this is a test.
^^^^^ ^^^^^^ ^^^^ ^^ ^ ^^^^^
```

### API Reference

#### `normalize_word(word: str) -> str`

Normalizes a word by lowercasing, stripping whitespace, and removing diacritics.

#### `UnprocessedTranscription`

Pydantic model for raw Whisper output.

- `text: str`: The full transcription text.
- `words: list[UnprocessedTimestamp]`: List of word timestamps.

#### `Transcription(unprocessed: UnprocessedTranscription)`

Main class to align timestamps.

- `text: str`: The original text.
- `timestamps: list[Timestamp]`: Aligned timestamps with text indices.

Methods:

- `get_word_by_timestamp(timestamp: Timestamp) -> str`: Get the word at a timestamp.
- `dumps_preview() -> str`: Get a string preview of alignments.
- `dumps_preview_wrapped(width: int) -> str`: Wrapped preview for terminals.
- `dump_preview(width: Optional[int] = None)`: Print the preview.

#### `Timestamp`

Dataclass for aligned timestamps.

- `start_index: int`, `end_index: int`: Indices in the text.
- `start_time: Optional[float]`, `end_time: Optional[float]`: Timestamps in seconds.

## Requirements

- Python >= 3.9
- Pydantic >= 2.10

## License

MIT License. See [LICENSE](LICENSE) for details.

## Contributing

Contributions are welcome! Please open issues or pull requests on [GitHub](https://github.com/mishapankin/stt-aligner).
to-do-list-Jhon 0.0.1
Pequeño gestor de tareas en Python
Requires Python: >=3.8


# To Do List de Jhon

Pequeño gestor de tareas en Python pensado para demostrar estructuras de control:
- Selección: `if`, `elif`, `else`
- Repetición: `for`, `while`, `break`, `continue`
- Excepciones: `try`, `except`, `else`, `finally`


Este proyecto es una aplicación sencilla de **To-Do List** para guardar tareas en local.
Utiliza un archivo **JSON** para almacenar los datos y un **dict** de Python para manejarlos internamente.

---

## Características

- Ver tareas
- Agregar tarea
- Marcar tareas como completadas
- Eliminar tareas
- Listar todas las tareas
- Guardado automático en **JSON**
- Manejo interno mediante **dict**

---

## Almacenamiento y estructura

### Archivo JSON (`tareas.json`)

Las tareas se guardan en un archivo JSON con una estructura como esta:

```json
{
  "tasks": [
    {
      "titulo": "Limpiar",
      "prioridad": "alta",
      "hecho": true
    },
    {
      "titulo": "Comer",
      "prioridad": "alta",
      "hecho": false
    }
  ]
}

El proyecto está pensado para empaquetarse y subirse a TestPyPI
ansys-api-lumerical 0.1.1
Low level Python API for Ansys Lumerical
Requires Python: >=3.10

ansys-api-lumerical
###################

Low level Python API for Ansys Lumerical.

Looking for the recommended Python API for Ansys Lumerical? Check out `PyLumerical <https://github.com/pyansys/pylumerical>`_.
dwh-oppfolging 0.1.96
Oppfolging python package for DWH ETL
Requires Python: ==3.12.*

# dwh-oppfolging
Public repository for the development of the dwh-oppfolging python package.

## Installation
`pip install dwh-oppfolging`

## Inquiries
Questions pertaining to the codebase may be opened as GitHub issues using the `question` label.

### For NAV employees
Internal inquiries may be posted to #dv-oppfølging.

### Code Generated by GitHub Copilot
This repository uses GitHub Copilot to generate code.