semvec/pypi-packages huggingface dataset:
yugioh-timeless 0.1.1b0
Custom format for the Yu-Gi-Oh! TCG
Requires Python: >=3.13
Keywords: yugioh, TCG, custom format, tournament

# Yu-Gi-Oh! TIMELESS

This repository provides a beginner-friendly command line tool for creating
pairings for a TIMELESS tournament.

> TIMELESS is a custom 4-player tournament format for the Yu-Gi-Oh! Trading
> Card Game. A TIMELESS tournament consists of four rounds. The three
> preliminary rounds, in which each duelist faces off against every other
> duelist, are followed up by a final play-off round. In each round, decks
> from a carefully constructed deck set of four are randomly assigned to the
> duelists. This is done in such a way that during the course of the tournament
> each duelist pilots each of the decks exactly once.


## Setup
(Requires Python 3.13 or newer.)
1. Install the *Yu-Gi-Oh! TIMELESS* package from PyPI:
~~~bash
pip install yugioh-timeless
~~~
2. The `timeless` command is now available in your shell. To create pairings,
   run it.
my-first-project-jhonny-navarrete 0.1.0
Una biblioteca para consultar cursos de hack4u

# Hack4U Academy Courses Library

Una biblioteca Python para consultar cursos de la academia Hack4U.
## Cursos disponibles:

- Introducción a Linux [15 horas]
- Personalizacion de Linux [3 horas]
- Introduccion al Hacking [53 horas]

## Instalación

Instala el paquete usando `pip3`:

```python3
pip3 install hack4u
```

## Uso básico

### Listar todos los cursos

```python
from hack4u import list_courses

for course in list_courses():
    print(course)
```

### Obtener un curso por nombre
```python
from hack4u import get_course_by_name

course = get_course_by_name("Introducción a Linux")
print(course)
```

### Calcular duración total de los cursos
```python3
from hack4u.utils import total_duration
```
walking-man 0.2.8
A friendly companion while you wait
Requires Python: >=3.12

# Walking Man

[![PyPI version](https://img.shields.io/pypi/v/walking-man.svg)](https://pypi.org/project/walking-man/)
[![Python versions](https://img.shields.io/pypi/pyversions/walking-man.svg)](https://pypi.org/project/walking-man/)
[![PyPI downloads](https://img.shields.io/pypi/dm/timecapsule.svg)](https://pypi.org/project/walking-man/)

This is Walking Man.

```
     .---.
    ( Hi! )
     '---'
         |
 <('-'<) v
 ```

A friendly companion while you wait.

## Installation

```bash
pip install walking-man
```

## Usage

Walking Man is designed to be simple and bring joy to your command-line applications. He's perfect for those moments when users need to wait for something to complete.

### Basic Usage

```python
from walking_man import walking_man

# As a context manager (recommended)
with walking_man():
    time.sleep(5)  # Your long-running operation here
```

### With Custom Message

```python
# Walking Man will display your message above the animation
with walking_man("Loading your data..."):
    time.sleep(5)
```

### Customizing Walking Man

```python
# Change his color (cyan is his favorite, but he looks good in yellow too)
with walking_man("Processing...", color="yellow"):
    # ...

# Make him walk faster or slower (lower values = faster)
with walking_man("Please wait...", speed=0.1):  # Speedy Walking Man!
    # ...
```

### Conditional Walking Man

Sometimes you only want Walking Man to appear based on certain conditions (like verbose mode):

```python
from walking_man import conditional_walking_man

verbose = True  # Or any condition

with conditional_walking_man(verbose, "Working on it..."):
    # Walking Man only appears if the condition is True
    # ...
```

### Clearing Walking Man

Walking Man is pretty good about cleaning up after himself, but if he ever gets stuck:

```python
# If there was loading text, clear the line above
WalkingMan.clear(line_above=True)

# Otherwise, just clear the current line
WalkingMan.clear()
```

### Using Walking Man Responsibly

Walking Man is a special friend who brings joy to tedious waiting times. But like any good thing, moderation is key:

- Don't overuse him on every loading screen
- Let him appear unexpectedly to bring surprise and delight
- Save him for those moments when users really need a smile
- Popping up infrequently is part of his magic ✨

Walking Man is most effective when he shows up just when you've forgotten about him, making you smile exactly when you needed it most.

### Extras

See [EXTRAS](EXTRAS.md) for a small bonus feature.

## License

Walking Man roams free under the [MIT license](LICENSE)! Use him wherever you like and add a little joy to your codebase!
love-protocol 0.3.2
Python implementation of the LOVE protocol based on JSON schemas
Requires Python: >=3.10

# ❤️ LOVE Protocol for Python

**LOVE (Lucy Open Voice Exchange)** is a universal messaging protocol for multimodal voice interaction.  
This library is the official Python implementation based on JSON schemas.

---

## 📦 Installation

```bash
pip install love-protocol
```

Requires: Python ≥ 3.10

---

## 🚀 Quick Start

### WebSocket Demo

```bash
python examples/websocket/server.py
# In a second terminal:
python examples/websocket/client.py
```

---

## 🔧 Features

- ✅ Full validation using Pydantic (generated models)
- ✅ Message encoding / decoding (JSON ⇄ Python)
- ✅ Async handler system with middleware support
- ✅ In-memory SessionStore
- ✅ Command-line tool `love-validate`

---

## 💬 LOVE Message Format

All messages follow the same base structure with a `type` field:

```json
{
  "protocol": "LOVE/1.0",
  "type": "HELLO",
  "device_id": "test-device",
  "timestamp": 1234567890.0
}
```

Supported message types include:

- `HELLO`, `HELLO_ACK`
- `AUDIO_START`, `AUDIO_CHUNK`, `AUDIO_STOP`
- `TRANSCRIPTION`, `INTENT_DETECTED`, `TTS_OUTPUT`
- `WAKEWORD_DETECTED`, `COMMAND`
- `MEDIA_CONTROL`, `MEDIA_PLAY`
- `SENSOR_EVENT`
- `ERROR`

All types are defined in `love_protocol.types`.

---

## 🧪 Run Tests

```bash
PYTHONPATH=. pytest tests
```

Tests use `pytest` and `pytest-asyncio`.

---

## 🧰 CLI: love-validate

Validate a raw message from file:

```bash
love-validate examples/data/hello.json
```

Output:

```
✅ Valid message of type HELLO
```

If invalid:

```
❌ Invalid message:
- protocol: expected format LOVE/X.Y
- type: unknown message type 'FOO'
```

---

## 🧠 Handler Example

```python
from love_protocol.handler.handler import LoveHandler

handler = LoveHandler()

@handler.on("HELLO")
async def handle_hello(ctx):
    print("📥 Message:", ctx.message)
    ctx.response = HELLOACK(
        protocol="LOVE/1.0",
        type="HELLO_ACK",
        device_id=ctx.message.device_id,
        timestamp=ctx.message.timestamp,
        session=ctx.message.session
    )
```

With middleware:

```python
from love_protocol.session.middleware import create_session_middleware

handler.use(create_session_middleware(session_store))
```

---

## 📁 Project Structure (Excerpt)

```
love_protocol/
├── core/         # encode / decode / validate
├── handler/      # dispatch + middleware
├── types/        # generated message types
├── session/      # SessionStore + lifecycle middleware
├── cli/          # love-validate CLI
├── examples/     # WebSocket demos
└── tests/        # pytest coverage
```

---

## 🧠 SessionStore Example

```python
from love_protocol.session.store import SessionStore

store = SessionStore()
session_id = store.create("kitchen-dot")
session = store.get(session_id)

store.update(session_id, { "state": "active" })
```

Sessions can be managed automatically via middleware.

---

## 📄 License

This project is licensed under the Apache 2.0 License.  
You may freely use, modify, and integrate it.