semvec/pypi-packages huggingface dataset:
jupyter-printer 0.1.0
Jupyter Notebook Cell Execution Monitor with colored output
License: MIT
Requires Python: >=3.7

# Jupyter Printer

Jupyter Notebook Cell Execution Monitor with colored output for cell execution events.

## Features
- Pre-run cell content display (blue)
- Real-time output (green)
- Post-run summary (yellow)

## Usage
```python
import jupyter_printer
jupyter_printer.activate()
```

## License
MIT
starsgraceAPI 1.0.0
Python client for the Fragment API
License: MIT
Requires Python: >=3.7
Keywords: fragment api telegram stars premium ton

# Fragment API Python Client

A Python client library for interacting with the Fragment API, which provides programmatic access to Telegram Stars, Premium, and TON services.

## Installation

```bash
pip install starsgraceAPI
```

## Usage

```python
from fragment_api import FragmentAPI

# Initialize client
client = FragmentAPI()

# Create authentication session
auth_response = client.create_auth(
    wallet_mnemonic="word1 word2 word3 ...",
    cookies="cookie1=value1; cookie2=value2",
    hash_value="121ff4016366e2a38f"
)

# Check balance
balance = client.get_balance()

# Buy stars
stars_response = client.buy_stars("@username", quantity=50, show_sender=False)

# Gift premium
premium_response = client.gift_premium("@username", months=3, show_sender=False)

# Top up TON
ton_response = client.topup_ton("@username", amount=1, show_sender=False)

# Search users
stars_user = client.get_user_stars("@username")
premium_user = client.get_user_premium("@username")

# Check API health
health = client.health_check()

# Close session
client.close()
```

## Features

- Session management with persistent auth_key
- Support for all Fragment API endpoints
- Error handling for API responses
- Type hints for better code completion
- Clean and intuitive interface

## Requirements

- Python 3.7+
- requests>=2.28.0

## License

MIT License
mirrorhour 0.1.0
Utilities to detect and work with mirror hours (HH:HH) in local time or arbitrary timezones.
License: MIT
Requires Python: >=3.9
Keywords: datetime, hora espejo, mirror hour, time

# mirrorhour

Utilities to detect and work with **mirror hours** (when hour and minute are equal, e.g., `11:11`, `22:22`) in local time or any IANA timezone. Provides a tiny **Python API** and a **CLI**.

## Features
- `is_mirror_time(dt)` — check if a datetime is a mirror hour.
- `next_mirror_time(dt)` — compute the next mirror hour.
- `all_mirror_times()` — list all mirror hours in a day.
- Optional 12-hour mode (`01:01` … `12:12`).
- Timezone-aware via `zoneinfo` (stdlib) and optional `tzdata`.

## Installation

```bash
pip install mirrorhour[cli]
# If your OS lacks a timezone database (common on Windows):
pip install tzdata
```

## Quick Start (CLI)

```bash
# Installed script
mirrorhour --tz Europe/Madrid

# Run via Python module
python -m mirrorhour.cli --tz Europe/Madrid

# 12-hour mode
mirrorhour --tz Europe/Madrid --twelve
```

**Options**
- `--tz <ZONE>`: IANA timezone (e.g., `Europe/Madrid`).
- `--twelve`: Use 12-hour mirror mode (`01:01` to `12:12`).

## Quick Start (Python)

```python
from mirrorhour import is_mirror_time, next_mirror_time, all_mirror_times
from datetime import datetime

now = datetime.now()

if is_mirror_time(now):
    print("It's a mirror hour!")
else:
    print("Next mirror hour:", next_mirror_time(now))

print("All mirror hours (24h):", all_mirror_times())
```

## API

- `is_mirror_time(dt: datetime | None = None, *, tz: str | None = None, use_24h: bool = True) -> bool`  
  Returns `True` if `dt` is a mirror hour.  
  - `tz`: IANA timezone name (e.g., `Europe/Madrid`).  
  - `use_24h`: if `True`, checks `HH == MM` in 24-hour clock; if `False`, checks 12-hour mirror set (`01:01`–`12:12`).

- `next_mirror_time(dt: datetime | None = None, *, tz: str | None = None, use_24h: bool = True) -> datetime`  
  Returns the next mirror hour (timezone-aware if `tz` provided). If `dt` is exactly on a mirror minute, returns `dt`.

- `all_mirror_times(day: date | None = None, *, use_24h: bool = True) -> list[datetime.time]`  
  Returns all mirror times for a day (naive `time` objects).  
  - 24h: `00:00, 01:01, …, 23:23` (24 items).  
  - 12h: `01:01, …, 12:12` (12 items).

## Requirements
- Python ≥ 3.9
- `tzdata` (only if your OS lacks an IANA timezone database)

## Testing

```bash
# Recommended for development
python -m pip install -e .[cli]
pytest -q
```

## Troubleshooting
- **Timezone errors**: install `tzdata` and pass `--tz <ZONE>`.
- **CLI not found**: ensure the environment is active (`.venv`) and that `mirrorhour` is on PATH, or run `python -m mirrorhour.cli`.

## License & Credits
- License: MIT  
- Author: **XaviDev41** (<4152@xavi.com.es>)  
- Repository: https://github.com/XaviDev41/mirrorhour
framedirect 0.6.1
Una librería para dibujar píxeles usando el framebuffer de Linux en Python.
License: MIT
Requires Python: >=3.6

# FrameDirect

**FrameDirect** es una librería en Python para dibujar píxeles directamente en el framebuffer de Linux. Perfecta para proyectos que necesitan control directo del hardware gráfico sin depender de entornos gráficos como X11 o Wayland.


## Características

- Acceso directo al framebuffer `/dev/fb0`
- Dibujo de píxeles a bajo nivel
- Compatible con pantallas de 32 bits de color
- Colores predefinidos para facilitar el uso
- Colores en formato ARGB (en hexadecimal)
- Simple, ligera y sin dependencias pesadas


## Requisitos

- Linux con framebuffer habilitado y acceso a `/dev/fb0`
- Python 3.6 o superior


## Instalación

Puedes instalar la libreria desde PyPi:
```bash
pip install FrameDirect
```

O directamente desde GitHub:

```bash
pip install git+https://github.com/gneval9/FrameDirect.git
```

## Uso básico

```python
import framedirect

framedirect.init()                                              # Inicializa el framebuffer
framedirect.resolution()                                        # Imprime la resolución de la pantalla (Variables: screen_width y screen_height)
                                                                 
framedirect.draw_pixel(100, 100, framedirect.RED)               # Dibuja un píxel rojo en (100, 100)
framedirect.draw_line(200, 200, 300, 300, framedirect.GREEN)    # Dibuja una línea verde de (200, 200) a (300, 300)
framedirect.draw_circle(400, 400, 50, 0xFF0000FF)               # Dibuja un circulo azul en (400, 400) con radio 50px
framedirect.fill(framedirect.BLACK)				# Llena la pantalla con el color negro

framedirect.update()						# Actualiza el framebuffer

framedirect.close()                                             # Cierra el framebuffer
```

## Licencia

MIT License


## Autor

Hecho con amor por gneval9 Software <3       Contacto: gneval99@gmail.com