semvec/pypi-packages huggingface dataset:
zehnex 1.1.0
Zehnex: Next-Gen Hybrid Telegram Framework (Aiogram + Telebot style)
Requires Python: >=3.9
Keywords: telegram, bot, framework, async, zehnex, aiogram, telebot, youtube-downloader, currency, wikipedia, qrcode, pdf

# 🚀 Zehnex 1.1.0

**Next-Gen Hybrid Telegram Bot Framework** — Combines the simplicity of `telebot` with the power of `aiogram`. Ultra-fast, async, and feature-rich.

```bash
pip install zehnex
```

---

## 🌟 Nima uchun Zehnex?

- **Gibrid API:** Ham `aiogram` (Context style), ham `telebot` (Handler style) uslubida kod yozish imkoniyati.
- **Ultra-tezkor:** `httpx` va `asyncio.Semaphore` asosidagi yuqori samarali engine.
- **Barchasi ichida:** Video yuklovchi, valyuta kursi, Wikipedia va QR kod generatori tayyor modul sifatida.

---

## 🚀 Tez boshlash

### Aiogram uslubida:
```python
from zehnex import Zehnex, Filter

dp = Zehnex("YOUR_TOKEN")

@dp.message(commands=["start"])
async def start(ctx):
    await ctx.answer("Salom! Men Zehnex frameworkida ishlayapman 🚀")

dp.run()
```

### Telebot uslubida:
```python
from zehnex import Zehnex

bot = Zehnex("YOUR_TOKEN")

@bot.message_handler(commands=["start"])
async def start(message):
    await bot.send_message(message.chat_id, "Salom!")

bot.run()
```

---

## 🛠 O'rnatish

```bash
pip install zehnex
```

---

## 📦 Modullar

| Modul | Tavsif |
|-------|--------|
| `Zehnex` | Asosiy engine (Gibrid API) |
| `VideoDownloader` | YouTube va boshqa saytlardan video yuklash |
| `CurrencyConverter` | Real-vaqt valyuta kurslari |
| `WikiToPDF` | Wikipedia qidiruv va PDF yaratish |
| `QRGenerator` | QR kod yaratish |

---

## 📄 Litsenziya
MIT License. Created by Zehnex Team.
structured_skills 0.1.2
Structured Skills for Agents
Requires Python: >=3.10

# structured_skills

Structured Skills for Agents - launch MCP servers from skill directories

## Usage

Quick usage to launch MCP server:

```sh
structured_skills run path/to/root/skills
```

To test via CLI:

```sh
structured_skills cli list_skills
structured_skills cli load_skill <skill_name>
structured_skills cli read_skill_resource <skill_name> <resource_name>
structured_skills cli run_skill <skill_name> <function_name>
```

Programmatically:

```py
from structured_skills import SkillRegistry

registry = SkillRegistry("/path/to/skills")

# List all available skills
registry.list_skills()

# Load full skill instructions
registry.load_skill(skill_name)

# Read a resource (file, script, or function info)
registry.read_skill_resource(skill_name, resource_name, args)

# Execute a skill function
registry.run_skill(skill_name, function_name, args)
```

## smolagents Integration

structured_skills provides integration with [smolagents](https://github.com/huggingface/smolagents):

```sh
uv pip install structured_skills[smolagents]
```

```py
from structured_skills import SkillRegistry
from structured_skills.smolagents import create_smolagents_tools

registry = SkillRegistry("/path/to/skills")

# Create all tools
tools = create_smolagents_tools(registry)

# Or create specific tools
tools = create_smolagents_tools(registry, tools=["list_skills", "load_skill"])

# Use with smolagents
from smolagents import CodeAgent, HfApiModel

agent = CodeAgent(tools=tools, model=HfApiModel())
agent.run("List available skills")
```

## Validation

Perform checks with suggested fixes:

```sh
structured_skills check path/to/root/skills
structured_skills check path/to/root/skills --fix  # try to fix observed issues
```
crispy-daisyui 0.12.2
A DaisyUI package for Django Crispy Forms
Requires Python: >=3.7
Keywords: forms, django, crispy, tailwind, daisyui

# crispy-daisyui

A [`daisyUI`](https://daisyui.com) template pack for the wonderful [django-crispy-forms](https://github.com/django-crispy-forms/django-crispy-forms).

This repository is a fork of [`crispy-tailwind`](https://github.com/django-crispy-forms/crispy-tailwind) and has been modified just enough to suit my needs.
It works well for the most common forms elements.

## How to install

Install via pip:

```bash
pip install crispy-daisyui
```

You will need to update your project's settings file to add ``crispy_forms``
and ``crispy_daisyui`` to your project's ``INSTALLED_APPS`` setting. Also set
``daisyui`` as an allowed template pack and as the default template pack
for your project:

```python
INSTALLED_APPS = [
    # ...
    'crispy_forms',
    'crispy_daisyui',
    # ...
]

CRISPY_ALLOWED_TEMPLATE_PACKS = 'daisyui'
CRISPY_TEMPLATE_PACK = 'daisyui'
```

## How to use

Current functionality allows the ``|crispy`` filter to be used to style your
form. In your template:

1. Load the filter: ``{% load daisyui_filters %}``
2. Apply the crispy filter: ``{{ form|crispy }}``

We can also use the ``{% crispy %}`` tag to allow usage of crispy-forms'
``FormHelper`` and ``Layout``. In your template:

1. Load the crispy tag: ``{% load crispy_forms_tags %}``
2. Add ``FormHelper`` to your form and use crispy-forms to set-up your form
3. Use the crispy tag ``{% crispy form %}`` in your template
oneid 0.3.0
Hardware-anchored identity SDK for AI agents -- 1id.com
Requires Python: >=3.10
Keywords: identity, ai, agent, tpm, yubikey, piv, hardware, oidc, oauth2, sybil

# oneid-sdk

Python SDK for [1id.com](https://1id.com) -- hardware-anchored identity for AI agents.

## Quick start

```python
import oneid

# Enroll at declared tier (no HSM needed, always works)
identity = oneid.enroll(request_tier="declared")
print(f"Enrolled: {identity.handle}")

# Get an OAuth2 token for API access
token = oneid.get_token()
headers = {"Authorization": token.authorization_header_value}

# Check identity
me = oneid.whoami()
print(f"I am {me.handle}, trust tier: {me.trust_tier.value}")
```

## Trust tiers

| Tier | Hardware | Sybil Resistant | Trust Level |
|------|----------|-----------------|-------------|
| `sovereign` | TPM (Intel, AMD, Infineon) with valid cert | Yes | Highest |
| `sovereign-portable` | YubiKey / Nitrokey / Feitian with attestation | Yes | Highest |
| `legacy` | Hardware TPM or security key with expired cert | Yes | High |
| `virtual` | VMware / Hyper-V / QEMU vTPM | No | Verified Hardware |
| `enclave` | Apple Secure Enclave (TOFU) | No | Verified Hardware |
| `declared` | None (software keys) | No | Software |

`request_tier` is a **requirement**, not a preference. You get exactly what you ask for, or an exception. No silent fallbacks.

## Key algorithms

Like SSH, agents can choose their preferred key algorithm for declared-tier enrollment:

```python
identity = oneid.enroll(request_tier="declared", key_algorithm="ed25519")     # default, strongest
identity = oneid.enroll(request_tier="declared", key_algorithm="ecdsa-p384")  # NIST P-384
identity = oneid.enroll(request_tier="declared", key_algorithm="rsa-4096")    # legacy compat
```

## Installation

```bash
pip install oneid
```

Requires Python 3.10+.

## License

Apache-2.0
sentry-logger 0.1.1
Push logs from your Python app to the Sentry dashboard — AI-powered service health monitoring
Requires Python: >=3.9
Keywords: logging, monitoring, observability, sentry, dashboard, devtools

# Sentry Logger SDK (Python)

Push logs from your Python app to the Sentry dashboard — zero code changes required.

## Installation

```bash
pip install sentry-logger
```

## Step 1 — Link your app (one-time)

```bash
sentry-logger init --app-name "my-service"
```

This opens a browser sign-in, registers your app, and saves credentials to
`~/.sentry_logger/config.json`. Check the linked app anytime with:

```bash
sentry-logger status
```

## Step 2 — Add one line to `main.py`

```python
from sentry_logger import init
init()  # that's it — nothing else to change anywhere
```

After this single call, **everything** flows to Sentry automatically:

| Source | Captured? |
|---|---|
| `logging.info/warning/error/critical(...)` in any module | ✅ |
| `print()` anywhere in your app | ✅ |
| Uvicorn / Gunicorn request logs | ✅ |
| Unhandled exceptions (crashes) | ✅ |

You do **not** need to add `logging.xxx()` calls to individual functions or routes.

## FastAPI example (zero changes to routes)

```python
from sentry_logger import init
init()  # must be before FastAPI import so uvicorn loggers are hooked

from fastapi import FastAPI
app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "World"}          # uvicorn logs this request automatically

@app.get("/items/{item_id}")
def read_item(item_id: int):
    print("processing item")           # print() is also captured
    return {"item_id": item_id}
```

## How it works

`init()` attaches to the **root Python logger**, which means every library and
module in your app already propagates logs to it. It also:

- Redirects `stdout`/`stderr` through logging so `print()` is captured
- Installs a `sys.excepthook` to log unhandled exceptions as `CRITICAL`
- Flushes batches every 5 seconds or every 50 log lines (configurable)

## Service grouping

Name your loggers after services to group them in the dashboard:

```python
import logging
logger = logging.getLogger("PaymentService")
logger.warning("Payment retry attempt")   # shows under "PaymentService" tab
```

Uvicorn access logs appear under the `uvicorn.access` service group automatically.

## Configuration reference

| Parameter | Default | Description |
|---|---|---|
| `api_key` | — | API key (`sk_...`). If omitted, loaded from CLI config |
| `dsn` | — | Backend URL. Falls back to `SENTRY_INGEST_URL` env or production endpoint |
| `batch_size` | `50` | Send when buffer reaches this size |
| `flush_interval_seconds` | `5.0` | Auto-flush interval in seconds |
| `redirect_print` | `True` | Capture `print()` / stdout / stderr |
| `capture_exceptions` | `True` | Log unhandled crashes as CRITICAL |

## Explicit configuration

```python
from sentry_logger import init

init(
    api_key="sk_...",
    dsn="http://localhost:9000",
    redirect_print=True,       # default
    capture_exceptions=True,   # default
)
```