semvec/pypi-packages huggingface dataset:
prismiq 0.2.3
Open-source embedded analytics platform
Requires Python: >=3.10

# Prismiq

Open-source embedded analytics engine for Python.

## Installation

```bash
pip install prismiq
```

## Quick Start

```python
from prismiq import PrismiqEngine

# Connect to your database
engine = await PrismiqEngine.create(
    database_url="postgresql://user:pass@localhost/mydb",
    exposed_tables=["customers", "orders", "products"]
)

# Get schema
schema = await engine.get_schema()

# Execute a query
result = await engine.execute({
    "tables": [{"id": "t1", "name": "orders"}],
    "columns": [
        {"table_id": "t1", "name": "status"},
        {"table_id": "t1", "name": "total", "aggregation": "sum"}
    ],
    "group_by": [{"table_id": "t1", "column": "status"}]
})
```

## Features

- **Schema introspection** - Discover tables, columns, and relationships
- **Visual query building** - Build SQL from JSON query definitions
- **Async execution** - Non-blocking database operations with asyncpg
- **Type safe** - Full type hints with Pydantic models
- **Multi-tenant support** - Schema-based isolation with Alembic integration

## Multi-Tenant Integration

For applications with schema-based multi-tenancy, Prismiq provides SQLAlchemy declarative models and sync table creation:

```python
from sqlalchemy import create_engine
from prismiq import ensure_tables_sync, PrismiqBase

engine = create_engine("postgresql://user:pass@localhost/db")

# Create tables in a tenant-specific schema
with engine.connect() as conn:
    ensure_tables_sync(conn, schema_name="tenant_123")
    conn.commit()

# For Alembic integration, access the metadata:
# PrismiqBase.metadata.tables contains all Prismiq table definitions
```

See [Multi-Tenant Integration Guide](../../docs/multi-tenant-integration.md) for complete documentation.

## Documentation

See the [main repository](https://github.com/prismiq/prismiq) for full documentation.

## License

MIT
guardian-type-enforcer 2.0.0
Maximum performance runtime type enforcement using CPython C API.
Requires Python: >=3.10

# Guardian 🛡️

**Maximum performance runtime type enforcement for Python 3.10+**

Guardian is a C-optimized runtime type checker that ensures your Python functions receive and return exactly the types they expect. It operates at two levels: blazing-fast function boundary enforcement, and strict local-variable execution tracing.

Built directly on the CPython C-API using the Vectorcall protocol, Guardian delivers microsecond-level overhead.



## Features
* **`@guard`**: Enforces parameter and return types at the function boundary (~0.67µs overhead).
* **`@strictguard`**: Enforces boundaries *and* locks local variables to their annotated or initially assigned types dynamically (~13µs overhead).
* **Comprehensive Typing Support**: Supports `Union` (`|`), `Literal`, `Annotated`, `list[T]`, `dict[K, V]`, `set[T]`, `tuple[T, ...]`, Custom Classes, and Forward References.
* **C-Level Performance**: Pre-compiled type-check trees and zero Python-level lambda recursion.

## Installation

```bash
pip install guardian
(Note: Guardian utilizes a C extension. If installing from source on Windows, you will need the Visual Studio C++ Build Tools installed.)

Usage1. Function Boundary Enforcement (@guard)
Use @guard for maximum-speed input/output validation.Python

from guardian import guard

@guard
def process_data(data: list[int], limit: int | None = None) -> int:
    if limit is None:
        return sum(data)
    return sum(data[:limit])

process_data([1, 2, 3], limit=2)  # OK
process_data([1, "2", 3])         # GuardianTypeError: Parameter 'data' expected list[int]
2. Strict Internal Execution Tracing (@strictguard)
Use @strictguard for mathematically complex or security-sensitive functions where local variable mutation bugs would be catastrophic.Python

from guardian import strictguard

@strictguard
def strict_math(x: int) -> int:
    y = 10        # 'y' is dynamically locked to 'int'
    y = 20        # OK
    y = "bad"     # GuardianTypeError: Variable 'y' expected int, got str
    return x + y
```



## Performance BenchmarkMeasured on Python 3.13 (1,000,000 iterations)

| TargetTotal | Time (s) | Overhead/call (µs) |
|-------------|----------|--------------------|
| Plain Function | 0.1514 | – |
| Guardian C (@guard) | 0.8278 | ~0.67 µs |
| StrictGuard C (@strictguard) | 13.1459 | ~13.0 µs |
oelint-data 1.4.3
Data for oelint-adv
Requires Python: >=3.10

# oelint-data

This package provides data for [oelint-adv](https://github.com/priv-kweihmann/oelint-adv)

For more details see the [constants guide](https://github.com/priv-kweihmann/oelint-adv/blob/master/docs/constants.md)
wisent 0.7.1497
Monitor and influence AI Brains
Requires Python: >=3.8
Keywords: nlp, machine learning, language models, safety, guardrails, lm-evaluation-harness

<p align="center">
  <img src="banner.png" alt="Wisent Banner" width="100%">
</p>

<p align="center">
  <code>pip install wisent</code>
</p>



## Overview

Wisent allows you to control your AI by identifying brain patterns corresponding to responses you don't like, like hallucinations or harmful outputs. We use contrastive pairs of representations to detect when a model might be generating harmful content or hallucinating. Learn more at [wisent.ai/documentation](https://www.wisent.ai/documentation).  


## License

This project is licensed under the MIT License - see the LICENSE file for details.
gevent-runner 0.0.3
The greenlet launch tool
Requires Python: >=3.10

# Gevent Runner

**Gevent Runner** — это инструмент для управления задачами на основе гринлетов (greenlets) в Python с использованием библиотеки gevent.

## Возможности

- ✅ Запуск нескольких конкурентных задач одновременно
- ✅ Динамическое добавление и удаление задач в процессе работы
- ✅ Корректная обработка сигналов завершения (SIGTERM, SIGINT)
- ✅ Потокобезопасное управление задачами

## Установка

### Из исходников

```bash
pip install -e .
```

### Для разработки

```bash
pip install -e ".[dev]"
```

## Требования

- Python >= 3.10
- gevent == 24.11.1

## Быстрый старт

### Базовый пример

Создайте несколько задач и запустите их одновременно:

```python
import time
import gevent
from classic.gevent_runner.runner import GreenletRunner


def print_numbers():
    count = 0
    while True:
        count += 1
        print(f"[Numbers Task] Count: {count}")
        gevent.sleep(2)


def print_timestamp():
    while True:
        current_time = time.strftime("%H:%M:%S")
        print(f"[Timestamp Task] Current time: {current_time}")
        gevent.sleep(3)


def print_heartbeat():
    while True:
        print(f"[Heartbeat Task] System is alive!")
        gevent.sleep(5)


def main():
    print("Starting GreenletRunner with 3 concurrent tasks...")
    print("Press Ctrl+C to stop all tasks\n")
    
    # Создаём экземпляр runner
    runner = GreenletRunner()
    
    # Добавляем задачи в runner
    runner.add(print_numbers, print_timestamp, print_heartbeat)
    
    # Запускаем главный цикл (блокирует выполнение до получения SIGTERM или SIGINT)
    runner.run()
    
    print("\nAll tasks stopped gracefully.")


if __name__ == "__main__":
    main()
```

**Вывод:**
```
Starting GreenletRunner with 3 concurrent tasks...
Press Ctrl+C to stop all tasks

[Numbers Task] Count: 1
[Timestamp Task] Current time: 12:34:56
[Numbers Task] Count: 2
[Heartbeat Task] System is alive!
[Timestamp Task] Current time: 12:34:59
...
```

Нажмите `Ctrl+C` для корректной остановки всех задач.

## Использование

### Создание runner

```python
from classic.gevent_runner.runner import GreenletRunner

runner = GreenletRunner()
```

### Добавление задач

Вы можете добавить одну или несколько задач одновременно:

```python
# Добавление одной задачи
runner.add(my_task)

# Добавление нескольких задач
runner.add(task1, task2, task3)

# Добавление задачи с демоном
runner.add(task1, daemon=True)
```

**Важно:** Задача должна быть вызываемой функцией (callable). Каждая задача может быть добавлена только один раз.

### Удаление задач

Остановка и удаление задач с опциональным таймаутом:

```python
# Удаление одной задачи
runner.remove(my_task)

# Удаление нескольких задач с таймаутом
runner.remove(task1, task2, timeout=2.0)
```

При удалении задачи, гринлет будет корректно завершён.

### Запуск runner

```python
# Запуск основного цикла (блокирующий вызов)
runner.run()
```

Метод `run()` блокирует выполнение до получения сигнала `SIGTERM` или `SIGINT` (Ctrl+C).