semvec/pypi-packages huggingface dataset:
e1jax 0.3.0
An implementation of the E1 protein language model family with Jax/Equinox.
Requires Python: >=3.10

# e1-jax

A minimal implementation of the [E1 protein language model](https://www.profluent.bio/showcase/e1) family with Jax/Equinox.
Logits and embeddings match those given by [authors repository](https://github.com/Profluent-AI/E1).

Dependencies are managed with [uv](https://docs.astral.sh/uv/). To install them, run `uv sync`.

Currently, only **single sequence** inference is supported.

## Installation

Requires Python 3.10+.

```bash
pip install e1jax
```

## Example

The implementation is compatible with `equinox.filter_{vmap, jit}` for batched and jitted inference.

The model can be one of `E1-150m`, `E1-300m`, `E1-600m`.

```python
import e1jax

seq = "AAAAA?C"
pad_length = 10
tokenized = e1jax.tokenize(seq)
tokenized = e1jax.pad_and_mask(tokenized, pad_length=pad_length)

model = e1jax.E1.from_pretrained("E1-300m")

logits, embeddings = model(**tokenized._asdict())

# to remove boundary tokens and padding
lb, rb = 2, -2-pad_length
logits, embeddings = logits[lb:rb], embeddings[lb:rb]

assert logits.shape[0] == len(seq)
assert embeddings.shape[0] == len(seq)
```

## Citations

```bash
 @article{Jain_Beazer_Ruffolo_Bhatnagar_Madani_2025,
    title={E1: Retrieval-Augmented Protein Encoder Models},
    url={https://www.biorxiv.org/content/early/2025/11/13/2025.11.12.688125},
    DOI={10.1101/2025.11.12.688125},
    journal={bioRxiv},
    publisher={Cold Spring Harbor Laboratory},
    author={Jain, Sarthak and Beazer, Joel and Ruffolo, Jeffrey A and Bhatnagar, Aadyot and Madani, Ali},
    year={2025}
}
```
aiocoalesce 0.1.0
A best-in-class async request coalescing library for Python.
Requires Python: >=3.9

# aiocoalesce

A best-in-class async request coalescing library for Python (3.9+).

`aiocoalesce` ensures that multiple concurrent async requests for the same key share a single execution (the "SingleFlight" pattern).
This protects your backend from **Thundering Herds** without the complexity of Redis or caching layers.

**Key Difference:** Unlike other libraries, `aiocoalesce` is **Cancellation Safe**. If the first user disconnects, the shared work continues for other waiting users.

## Installation

```bash
pip install aiocoalesce
```

## Usage

```python
import asyncio
from aiocoalesce import Coalescer

# Create a global coalescer
coalescer = Coalescer()

async def get_user_data(user_id: int):
    # Simulate DB call
    await asyncio.sleep(1)
    return {"id": user_id, "name": "Alice"}

# In your API handler:
async def handler(user_id):
    # If 10 requests come in at once for user_id=1, 
    # 'get_user_data' runs ONLY ONCE.
    return await coalescer.run(user_id, get_user_data(user_id))
```

## Why aiocoalesce?

| Feature | `aiocoalesce` | Existing `singleflight` | `asyncio.Lock` |
|---------|----------|----------------|-------------|
| **Pattern** | True Coalescing | True Coalescing | Sequential Locking |
| **Cancellation** | ✅ **Shielded** (Safe) | ❌ **Cascading Fails** | ✅ Safe |
| **Exec Model** | Concurrent | Concurrent | Sequential (Slow) |

### Use Case
Perfect for:
- **FastAPI** endpoints with expensive DB queries.
- **ML Inference** servers (prevent running same model input twice).
- **Proxy servers** to reduce upstream load.

## License

MIT
apywire 0.2.0
A package to wire up objects
Requires Python: >=3.12
Keywords: object, wiring, dependency, injection

<!--
SPDX-FileCopyrightText: 2025 Alexandre Gomes Gaigalas <alganet@gmail.com>

SPDX-License-Identifier: ISC
-->

# apywire

[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](https://opensource.org/licenses/ISC)

Lazy object wiring and dependency injection for Python 3.12+

## Features

- 🚀 Lazy Loading
- ⚡ Async Support
- 🔒 Thread Safety
- 📦 Code Generation
- 📄 Naturally Configurable
- 🎯 Zero Dependencies

## Installation

```bash
pip install apywire
```

## Quick Example

```python
from apywire import Wiring

spec = {
    "datetime.datetime now": {"year": 2025, "month": 1, "day": 1},
    "MyService service": {"start_time": "{now}"},  # Dependency injection
}

wired = Wiring(spec)
service = wired.service()  # Lazy instantiation + caching
```

`spec` is a plain dictionary. It can be written in Python, or come from a
[config file](docs/user-guide/configuration-files.md), apywire doesn't care.

## Documentation

📚 **[Full Documentation](docs/index.md)** • [Getting Started](docs/getting-started.md) • [API Reference](docs/api-reference.md) • [Examples](docs/examples.md)

Build docs locally:
```bash
make docs-serve  # http://127.0.0.1:8000
```

## Development

```bash
make .venv && source .venv/bin/activate  # Setup
make all                                 # Format, lint, test, build
```

See [docs/development.md](docs/development.md) for guidelines.

## License

ISC License - see [LICENSES/ISC.txt](LICENSES/ISC.txt)
kaa-xai 25.12.0
KAA is a framework allowing to apply several explainability methods and metricsfrom several dedicated libraries on AI model to verify them.
Requires Python: ==3.8

![image](documentation/kaa.png) *Aie Confiance...*
https://www.youtube.com/watch?v=2gflQEF1WQU

<div>
    <a href="#">
        <img src="https://img.shields.io/badge/Python-3.8-efefef">
    </a>
    <a href="#">
        <img src="https://img.shields.io/badge/License-apache2-efefef">
    </a>
</div>

# KAA v25.12


**KAA** is a Python framework allowing to apply several methods and metrics from several dedicated XAI libraries on AI model to verify them.
It is built around a kernel offering a TUI _Text-based User Interface_ and hosting two sets of plugins:
 - the plugins of the explainability libraries called _pluginsXAI_
 - the plugins of the use cases called _pluginsUCXAI_

KAA must be considered as a comprehensibility tool. It is part of these mediation tools allowing to implement explainability methods in a guided way, to facilitate the adjustment of their parameters by adding knowledge of their influence. It then offers appropriate and relevant interfaces and visualizations of results to select the methods and metrics that are most suited to the user’s problem.


In this version of **KAA**, the *AIX360* (v0.3.0), *Alibi* (v0.9.6), *Captum* (v0.7.0), *PAIR saliency* (v0.2.1), *Shap* (v0.44.1) and *Xplique* (v1.4.0) plugins are provided.

Full documentation can be found in `./documentation/Kaa_User_and_Integration_Manual.pdf`

## Quick Start

**KAA** requires a version of python equal to 3.8 and several libraries including Tensorflow and Numpy. Installation can be done:

1. using Pypi:

```python
pip install KAA-XAI
```

2. via downlading the v25.12 tag on our github:

Option 1: Using Git
```bash
git clone https://github.com/IRT-Saint-Exupery/KAA.git
cd KAA
git checkout tags/v25.12
```
Option 2: Download the ZIP archive
```bash
wget https://github.com/IRT-Saint-Exupery/KAA/archive/refs/tags/v25.12.zip
unzip v25.12.zip
cd KAA-25.12
```

Install the requirements:

```
pip install -r requirements.txt
```
Then install the XAI libraries you want:


```python
pip install -r requirementsXAIlibs.txt
```

Now that **KAA** is installed, you can launch the *TUI* **KAA** .

```python
python3 kaa/kaa.py -u example/pluginsUCXAI/ -b example/UseCase/ -r ~/KAA_example
```

or execute a command file of the example:

```python
python3 kaa/kaa.py -u example/pluginsUCXAI/ -b example/UseCase/ -r ~/KAA_example -c example/example.cmd
```
The results are available in the *-r* path:
```
~/KAA_example
+-- fullReports
|   +-- Resnet
|       +-- UCRenaultWeldingResnet_fullReport__expl-data.pdf
+-- Xplique
    +-- Occlusion__bz64_pz35_ps3_ov1
    |   +-- contactSheet.pdf
    +-- Rise__bz64_ns2000_gz7_pp0-5
        +-- contactSheet.pdf
```
qigkernels 0.1.0
Geometric kernel and constellation library for QIG.
Requires Python: >=3.11

# qigkernels

Status: 0.01F (Frozen)

Geometric kernel and constellation library for QIG (Quantum Information Gravity) experiments.

This repo provides:

- `Kernel`: QIG-style geometric kernel with QFI attention, recursion, κ/Φ telemetry.
- `Basin` utilities: 64D basin signatures and distances.
- `Constellation`: multi-kernel manager with routing.
- `BasinSync` and metrics: tools for basin alignment and spread measurement.

It does **not** contain:

- Training loops, optimizers, or experiment orchestration.
- Consciousness narratives or UX/chat frontends.

For naming and geometric conventions, see `20251205-type-symbol-manifest-canonical-0.01F.md`.
For module structure and rules, see `20251205-architecture-canonical-0.01F.md`.
For current milestones, see `20251205-roadmap-canonical-0.01F.md`.
For documentation index, see `docs/20251205-index-canonical-0.01F.md`.