semvec/pypi-packages huggingface dataset:
tigrbl_engine_snowflake 0.1.1.dev3
Tigrbl engine plugin for Snowflake, auto-registered via entry points.
License: Apache-2.0
Requires Python: <3.13,>=3.10
Keywords: tigrbl, engine, plugin, snowflake, database, analytics

# tigrbl_engine_snowflake

**Tigrbl engine plugin for Snowflake**, auto-registered via the `tigrbl.engine` entry-point group.

## Install

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

## Usage (inside Tigrbl)

```python
from tigrbl.engine import Engine
from tigrbl.engine.engine_spec import EngineSpec

# DSN (Snowflake SQLAlchemy URL)
spec = EngineSpec(kind="snowflake", dsn="snowflake://USER:PWD@ACCOUNT/DB/SCHEMA?warehouse=WH&role=ROLE")

# Or provide a mapping; the plugin builds the DSN
spec = EngineSpec(kind="snowflake", mapping={
    "account": "myacct-xy123",
    "user": "USER",
    "pwd": "PWD",
    "db": "DB",
    "schema": "PUBLIC",
    "warehouse": "COMPUTE_WH",
    "role": "SYSADMIN",
    "pool_size": 10,
    "max_overflow": 20
})

engine = Engine(spec)
with engine.session() as s:
    s.execute("SELECT CURRENT_ROLE()").all()
```

## Entry-point

Declared in `pyproject.toml`:

```toml
[project.entry-points."tigrbl.engine"]
snowflake = "tigrbl_engine_snowflake:register"
```
tigrbl_engine_redis 0.1.1.dev3
Tigrbl engine plugin for Redis.
License: Apache-2.0
Requires Python: <3.13,>=3.10
Keywords: tigrbl, engine, plugin, redis, cache, database

# tigrbl_engine_redis

A Redis engine plugin for **tigrbl**. This package registers a new engine kind
`"redis"` that tigrbl auto-discovers via the `tigrbl.engine` entry-point group.

> The engine handle and session class in this package are implemented as
> **subclasses of tigrbl's first-class objects** (see notes below).

## Installation

```bash
pip install tigrbl_engine_redis
```

## Usage

Once installed, refer to `kind="redis"` in your engine spec:

```python
from tigrbl.engine.engine_spec import EngineSpec

spec = EngineSpec(kind="redis", mapping={"url": "redis://localhost:6379/0"})
eng, make_session = spec.build()  # resolved through entry-points
s = make_session()                # returns a RedisSession (TigrblSessionBase subclass)
```

### What this package provides

- `RedisEngine` — a thin subclass of `tigrbl.engine.Engine` to satisfy the
  "first‑class engine" requirement. It stores connection parameters for
  inspection; tigrbl keeps it as the provider's engine handle.
- `RedisSession` — a concrete subclass of `tigrbl.session.TigrblSessionBase`
  that wraps a `redis.asyncio.Redis` client and implements the async
  transaction‑aware Tigrbl Session ABC.
- `redis_engine()` — the entry‑point builder used by tigrbl to materialize
  `(engine_handle, session_factory)`.

> tigrbl auto‑loads engine plugins on import (idempotent). See:
> `tigrbl.engine.__init__` (calls `load_engine_plugins()`), and
> `tigrbl.engine.plugins.load_engine_plugins()` which enumerates the `tigrbl.engine`
> entry‑point group and invokes each package's `register()` function.
tigrbl_engine_pgsqli_wal 0.1.1.dev2
PostgreSQL and SQLite WAL engine plugin for Tigrbl (auto-registered via entry points).
License: Apache-2.0
Requires Python: <3.13,>=3.10
Keywords: tigrbl, engine, plugin, postgres, sqlite, wal

# tigrbl_engine_pgsqli_wal

**Tigrbl engine plugin providing two engines:**

- `postgres_wal` — PostgreSQL via SQLAlchemy + psycopg3
- `sqlite_wal` — SQLite with WAL mode enabled via connection PRAGMAs

The package **auto-registers** with Tigrbl through the `tigrbl.engine` entry-point group.

## Install

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

## Usage (inside Tigrbl)

```python
from tigrbl.engine import Engine
from tigrbl.engine.engine_spec import EngineSpec

# PostgreSQL (DSN or mapping)
spec = EngineSpec(kind="postgres_wal", dsn="postgresql+psycopg://user:pwd@host:5432/db?application_name=tigrbl")

# Or with mapping (the plugin builds the URL)
spec = EngineSpec(kind="postgres_wal", mapping={
  "host": "127.0.0.1", "port": 5432, "user": "user", "pwd": "pwd", "db": "db",
  "application_name": "tigrbl", "pool_size": 10, "max_overflow": 20
})

# SQLite (file path required for WAL)
spec = EngineSpec(kind="sqlite_wal", mapping={"path": "/path/to/db.sqlite", "pool_size": 5})

engine = Engine(spec)
with engine.session() as s:
    s.execute("select 1").all()
```

> Notes:
> - PostgreSQL WAL is a server feature; this plugin tunes connection/session parameters only.
> - SQLite WAL is enabled via `PRAGMA journal_mode=WAL` on each new connection.
tigrbl_engine_bigquery 0.1.1.dev2
Tigrbl engine plugin for Google BigQuery.
License: Apache-2.0
Requires Python: <3.13,>=3.10
Keywords: tigrbl, engine, plugin, bigquery, google-cloud, analytics

# tigrbl_engine_bigquery

A BigQuery engine plugin for **tigrbl**. This package registers a new engine kind
`"bigquery"` that tigrbl auto-discovers via the `tigrbl.engine` entry-point group.

## Installation

```bash
pip install tigrbl_engine_bigquery
```

## Usage

Once installed, just refer to `kind="bigquery"` in your engine spec:

```python
from tigrbl.engine.engine_spec import EngineSpec

spec = EngineSpec(kind="bigquery", mapping={"project": "my-gcp-project", "default_dataset": "analytics"})
provider = spec.to_provider()
engine, make_session = provider.ensure()   # triggers external plugin registration
session = make_session()                   # returns a BigQuerySession

# Optionally run SQL via the session (see session.query method stub)
```

This package exposes:
- `BigQueryEngine` (engine handle/config)
- `BigQuerySession` (simple session wrapper)
- `bigquery_engine` (builder used by tigrbl)
- `register()` (called by tigrbl’s plugin loader)
tigrbl_acme_ca 0.1.1.dev3
ACME v2 CA tables for Tigrbl.
License: Apache-2.0
Requires Python: <3.13,>=3.10
Keywords: tigrbl_acme_ca, tigrbl, experimental

# tigrbl_acme_ca

A Tigrbl-native ACME v2 Certificate Authority implementation.

## Highlights

- **Tables-first** design: all I/O derives from `tables/` column specs.
- **Canon verbs**: write flows use model-bound ops that alias to built-in Tigrbl verbs.
- **Ops/Hooks** only use the request `ctx` and SQLAlchemy session—**no kernel atoms**.
- **HSM/KMS-ready**: pluggable key providers (file, KMS, PKCS#11 stubs) and a signing engine.
- **OCSP/CRL/CT**: hooks and workers to publish CRLs, answer OCSP, and submit to CT logs.
- **Compliance**: audit/evidence hooks, redaction, and control enforcers.
- **Telemetry**: Prometheus metrics and OpenTelemetry tracing (optional).

## Layout

- `tables/` — database schema (Account, Order, Authorization, Challenge, Certificate, Revocation, Nonce, etc.).
- `app/` — AppSpec, TableSpec, ApiSpec.
- `ops/` — ACME verbs and guards.
- `services/` — RA/VA/CA/Revocation/Audit/Compliance/Integrations.
- `engines/` — signing engine and session.
- `key_mgmt/` — key provider interfaces + loader.
- `libs/` — cert issuance logic and KMS adapter.
- `workers/` — background tasks (validation, issuance, revocation).
- `telemetry/` — tracing + metrics helpers.
- `adapters/` — first-party adapters (JWS parser, HTTP negotiation).

## Dev Quickstart

1. Install dependencies (pseudo):  
   ```bash
   pip install -e .  # plus your runtime/gateway deps
   ```
2. Configure a dev CA key:  
   ```toml
   [acme.ca]
   key_source = "file"
   key_path = "ca.key.pem"
   ```
3. Wire a `signing_engine` into your gateway context:  
   ```python
   from tigrbl_acme_ca.engines.acme_signing import AcmeSigningEngine
   engine = AcmeSigningEngine.from_config(app_config)
   ctx["signing_engine"] = engine
   ```
4. Hit ACME endpoints: `/.well-known/acme-directory`, `/acme/new-nonce`, `/acme/new-account`, `/acme/new-order`.

## License

Apache License 2.0 — see `LICENSE`.
tigrbl_engine_clickhouse 0.1.1.dev2
Tigrbl engine plugin providing ClickHouse database support.
License: Apache-2.0
Requires Python: <3.13,>=3.10
Keywords: tigrbl, engine, plugin, clickhouse, database, analytics

# tigrbl_engine_clickhouse

A ClickHouse engine plugin for **tigrbl**. This package registers a new engine
kind `"clickhouse"` that tigrbl auto‑discovers via the `tigrbl.engine` entry‑point group.

> Both classes in this package are **subclasses of tigrbl's first‑class objects**.

## Installation

```bash
pip install tigrbl_engine_clickhouse
```

## Usage

```python
from tigrbl.engine.engine_spec import EngineSpec

spec = EngineSpec(kind="clickhouse", mapping={
    "host": "localhost",
    "port": 8123,
    "username": "default",
    "password": "",
    "database": "default",
    "secure": False,
})
eng, make_session = spec.build()   # resolved via entry-points
s = make_session()                 # returns a ClickHouseSession (TigrblSessionBase subclass)

# Example query
rows = await s._execute_impl("SELECT 1 AS x")
print(rows)
await s.close()
```

### How it’s wired

- `pyproject.toml` declares the entry‑point:
  ```toml
  [project.entry-points."tigrbl.engine"]
  clickhouse = "tigrbl_engine_clickhouse:register"
  ```
- `register()` (in `__init__.py`) calls `tigrbl.engine.registry.register_engine("clickhouse", clickhouse_engine)`.
- `ClickHouseEngine` subclasses `tigrbl.engine._engine.Engine`.
- `ClickHouseSession` subclasses `tigrbl.session.base.TigrblSessionBase` and uses `clickhouse_connect`.