semvec/pypi-packages huggingface dataset:
esbmc_ai 0.5.2.dev15
LLM driven development and automatic repair kit.
Requires Python: >=3.12
Keywords: AI, LLM, automated code repair, esbmc

# ESBMC AI


[![Development](https://github.com/esbmc/esbmc-ai/actions/workflows/workflow.yml/badge.svg?branch=master)](https://github.com/esbmc/esbmc-ai/actions/workflows/workflow.yml)
[![Docker Repository on Quay](https://quay.io/repository/yiannis128/esbmc-ai/status "Docker Repository on Quay")](https://quay.io/repository/yiannis128/esbmc-ai)
[![GitHub All Releases](https://img.shields.io/github/downloads/esbmc/esbmc-ai/total.svg)](https://github.com/esbmc/esbmc-ai/releases)

Automated LLM Integrated Workflow Platform. Primarily oriented around Automated Program Repair (APR) research. There are different commands that can be executed with ESBMC-AI. There are different commands that ESBMC-AI can run, and can also be extended with Addons (see [below](#wiki)).

The basic repair implementation passes the output from ESBMC to an AI model with instructions to repair the code. As the output from ESBMC can be quite technical in nature.

![ESBMC-AI Visual Abstract](https://raw.githubusercontent.com/esbmc/esbmc-ai/master/website/content/docs/images/esbmc-ai_framework.png)

![ESBMC-AI Platform](https://raw.githubusercontent.com/esbmc/esbmc-ai/master/website/content/docs/images/platform_diag.png)

## Quick Start

```sh
hatch run esbmc-ai ...
```

## Demonstration

[![Fix Code Demo](https://img.youtube.com/vi/anpRa6GpVdU/0.jpg)](https://www.youtube.com/watch?v=anpRa6GpVdU)

More videos can be found on the [ESBMC-AI Youtube Channel](https://www.youtube.com/@esbmc-ai)

## Wiki

For full documentation, see the [ESBMC-AI Wiki](https://esbmc.github.io/esbmc-ai). Quick Links:

* [Initial Setup Guide](https://esbmc.github.io/esbmc-ai/docs/initial-setup/)
* [Built-in Commands](https://esbmc.github.io/esbmc-ai/docs/commands/)
* [Addons](https://esbmc.github.io/esbmc-ai/docs/addons/)

## Contributing

See [this page](https://esbmc.github.io/esbmc-ai/docs/contributing).

## License

> [!NOTE]
>This project is offered under a [dual-licence](https://github.com/esbmc/esbmc-ai/blob/master/LICENSE) model.
lazylinop 1.23.1
A package dedicated to lazy linear operators based on diverse backends/libraries.
Requires Python: >=3.10
Keywords: butterfly, lazy computation, signal processing

## Lazylinop

![License](https://img.shields.io/badge/License-BSD_2-blue.svg)
[![Downloads](https://static.pepy.tech/badge/lazylinop)](https://pepy.tech/project/lazylinop)
[![Downloads](https://static.pepy.tech/badge/lazylinop/month)](https://pepy.tech/project/lazylinop)
[![PyPI version](https://badge.fury.io/py/lazylinop.svg)](https://pypi.org/project/lazylinop/)

Lazylinop is a python toolbox to ease and accelerate computations with ("matrix-free") linear operators.
It provides glue to combine linear operators as easily as NumPy arrays, PyTorch/CuPy compatibility, standard signal/image processing linear operators, as well as advanced tools to approximate large matrices by efficient butterfly operators.

A `LazyLinOp` is a high-level linear operator based on an arbitrary underlying implementation, such as:

    - custom Python functions,
    - a [NumPy array](https://numpy.org/doc/stable/reference/generated/numpy.array.html),
    - a [SciPy matrix](https://docs.scipy.org/doc/scipy/reference/sparse.html),
    - a [CuPy array](https://docs.cupy.dev/en/stable/reference/generated/cupy.array.html),
    - a [torch tensor](https://docs.pytorch.org/docs/stable/tensors.html),
    - a [Faust](https://faustgrp.gitlabpages.inria.fr/faust/last-doc/html/classpyfaust_1_1Faust.html) object,
    - any Python linear operator.

Thanks to the Lazylinop API, this operator can be easily manipulated, transformed or aggregated with other linear operators to form more complex `LazyLinOp` objects.
Thus, many operations are available such as the addition, concatenation, adjoint etc.
These operations are all ruled by the **lazy paradigm**: their evaluation is delayed until the resulting `LazyLinOp` is actually applied to a vector (or to a collection of vectors, seen as a matrix).

## Get started with ``lazylinop``

Run the following command to install the ``lazylinop`` package from PyPI:

```bash
pip install lazylinop
```

Run the following commands to install from conda:

```bash
conda config --add channels conda-forge
conda config --add channels lazylinop
conda install lazylinop
```

## First steps

Build 2D FFT from 1D FFT and Kronecker product:

```python3
from lazylinop.signal import fft
from lazylinop.basicops import kron
fft2d = kron(fft(N), fft(N))
x = np.random.randn(fft2d.shape[1])
y = fft2d @ x
```

Build circular convolution from 1D FFT:

```python3
from lazylinop.signal import fft
from lazylinop.basicops import diag
DFT = fft(N) * np.sqrt(N)
D = diag(DFT @ filter, k=0)
L = (DFT / N).H @ D @ DFT
```

## Authors

- Pascal Carrivain
- Simon Delamare
- Hakim Hadj-Djilani
- Remi Gribonval

## Contribute to ``lazylinop``

You can contribute to ``lazylinop`` with bug report, feature request and merge request.

## Useful links

- Link to the documentation: [Gitlab pages](https://faustgrp.gitlabpages.inria.fr/lazylinop/index.html)

## Running unit tests

```bash
    cd tests
    python3 -m unittest TestLazyLinOp.py
    python3 -m unittest TestSignal.py
```
pact-auth 0.1.1
Sovereign Agent Authentication Protocol — Python SDK
Requires Python: >=3.10
Keywords: agent, ai, authentication, delegation, ed25519, pact

# pact-auth

**Sovereign Agent Authentication Protocol — Python SDK**

Cryptographic identity, delegation chains, and capability-based authorization for AI agents. Zero trust, zero registry — the public key IS the identity.

## Install

```bash
pip install pact-auth
```

## Quick Start

```python
import pact
from datetime import timedelta

# Create identities (Ed25519 keypairs)
human = pact.new_identity("human", "alice")
agent = pact.new_identity("agent", "my-agent")

# Delegate capabilities with expiry
delegation = pact.new_delegation(
    from_identity=human,
    to_identity=agent,
    capabilities=["storage:read", "storage:write"],
    ttl=timedelta(hours=24),
)

# Sign HTTP requests
req = pact.HttpRequest("GET", "https://api.example.com/data")
pact.sign_request(req, agent, [delegation])

# Verify (provider side)
result = pact.verify_request(req)
assert result.valid
```

## Features

- **Self-sovereign identity** — Ed25519 keypairs, `sha256:hex` IDs, no registry
- **Delegation chains** — Signed capability transfers with narrowing-only constraint
- **Capability URIs** — `resource:action,constraint=value` format with wildcard support
- **HTTP signing** — Content digest + signature headers compatible with RFC 9421
- **Session management** — Ephemeral session keys delegated from persistent root
- **Revocation** — Instant revocation with cryptographic proof
- **Zero dependencies** beyond `cryptography>=41.0`

## Protocol Spec

See [SPEC.md](https://github.com/anzal1/pact/blob/main/SPEC.md) for the full 968-line protocol specification.

## License

Apache 2.0