semvec/pypi-packages huggingface dataset:
agentape 0.1.0
Record/replay testing for LLM agents - VCR.py but for LLM SDKs
Requires Python: >=3.10
Keywords: anthropic, llm, openai, record, replay, testing, vcr

# agentape

Record/replay testing for LLM agents. Think "VCR.py but for LLM SDKs" with semantic matching.

## Installation

```bash
pip install agentape
```

## Quick Start

```python
import agentape
from openai import OpenAI

# Wrap the client
client = agentape.wrap(OpenAI())

# Record interactions
with agentape.record("tapes/my_flow.yaml"):
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": "Hello"}]
    )

# Replay interactions (no API calls made)
with agentape.replay("tapes/my_flow.yaml"):
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": "Hello"}]
    )
```

## pytest Integration

```python
import agentape

@agentape.use_tape("tapes/{test_name}.yaml")
def test_my_feature(openai_client):
    response = openai_client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": "Hello"}]
    )
    assert "hello" in response.choices[0].message.content.lower()
```

Run tests with:

```bash
pytest tests/ --tape-mode=record   # Record new tapes
pytest tests/ --tape-mode=replay   # Replay existing (default)
pytest tests/ --tape-mode=off      # Pass-through, no taping
```

## License

MIT
bisheng-ragas-lc1 2.0.0
Bisheng Ragas - A RAG evaluation framework compatible with the latest LangChain
Requires Python: >=3.9

# Bisheng Ragas LC1

Fork of bisheng-ragas updated for LangChain v0.3+.

## Description

This project provides RAG (Retrieval-Augmented Generation) evaluation metrics and test set generation, updated to be compatible with the latest LangChain ecosystem (`langchain-core`, `langchain-community`, `langchain-openai`).

## Installation

```bash
pip install bisheng-ragas-lc1
```

## Usage

(See original bisheng-ragas documentation for detailed usage, ensuring you use updated LangChain imports).

## Development

1. Install dependencies:
   ```bash
   pip install -e .
   ```

2. Run tests:
   ```bash
   pytest tests/
   ```
alphabit 0.1.2
Hardware-accelerated symbolic stream processing
Requires Python: >=3.7

# alphabit 🧬

**Hardware-accelerated symbolic stream processing**  
*The fundamental unit of symbolic computation*

> **alphabit** = **alpha** (alphabet, symbols) + **bit** (hardware, efficiency)

Process strings, DNA sequences, logs, and tokens **10x faster** with hardware acceleration.

## Installation
```bash
pip install alphabit
practiso-mcp 0.1.3
MCP server to generate Practiso archives
Requires Python: >=3.12

# Practiso MCP

Set of tools to utilize LLMs as Practiso archive generators.

## Get started

Dozens of MCP clients are available. They are probably the same.

Here is an OpenCode configuration example:

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "practiso-mcp": {
      "type": "local",
      "command": ["uvx", "practiso-mcp"]
    }
  },
}
```
mipcandy-bundles 0.1.0
Bundles for MIP Candy
Requires Python: >=3.12

# MIPCandy Bundles

![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/ProjectNeura/mipcandy-bundles)
![PyPI](https://img.shields.io/pypi/v/mipcandy-bundles)
![GitHub Release](https://img.shields.io/github/v/release/ProjectNeura/mipcandy-bundles)
![GitHub Release Date - Published_At](https://img.shields.io/github/release-date/ProjectNeura/mipcandy-bundles)

Bundles for MIP Candy

This is a submodule of [MIP Candy](https://github.com/ProjectNeura/MIPCandy).
textual-tty 0.2.4
A tty for Textual UIs
Requires Python: >=3.10

# textual-tty

A terminal emulator for Textual apps, using `bittty`, my pure Python terminal
emulator.

Currently buggy and a bit slow, but it's still somewhat usable.

## Demo

```bash
uvx textual-tty
```

## Usage

1. `TextualTerminal`, a bittty.Terminal subclass for textual.
2. `TerminalApp`, a terminal emulator in a window.

Read the demo code for more info.

## Links

* [🏠 home](https://ttygroup.github.io/textual-tty)
* [🗔  bittty](https://bitplane.net/dev/python/bittty)
* [🐍 pypi](https://pypi.org/project/textual-tty)
* [🐱 github](https://github.com/ttygroup/textual-tty)

## License

WTFPL with one additional clause

1. Don't blame me

Do wtf you want, but don't blame me when it rips a hole in your trousers.
practiso-sdk 1.0.0
Practiso Software Development Kit
Requires Python: >=3.10

# Practiso SDK

> [!TIP]
> Check out [Practiso](https://github.com/PractisoDevelopers/Practiso), a local intelligent study utility.

To create Practiso archive for importing, use this Python SDK to

- create questions programmatically,
- parse other formats like Excel sheets or RTF documents,
- use generative AI to categorize the questions.

## Getting started

SDK is available via PyPi. To get it with pip, run:

```shell
pip install practiso-sdk
```

## Frames

Questions are composed of several frames, either representing its content
or the answerable sections. Following is a possible question model and its
Practiso rendering.

```python
from practiso_sdk import archive

archive.Text('This is Cat Walker')
archive.Image(filename='cat_walker.jpg', width=479, height=200, alt_text="People's favour cat DJ")
archive.Options([
    archive.OptionItem(archive.Text('pretty cool'), is_key=True)
])
```

![frames](assets/frames.png)

## Tag

Your categories will be the primary factor on which Practiso decides how to
recommend new questions or combinations. In Practiso, categorization is described in
dimensions, what knowledge point a question is related to and how much so,
so that the system can comprehend them in a hyper dimension line space.

## use generative AI

### 1. for tagging

Generative AI can be utilized to make decisions on how much a category a
question falls into.

Required extra: `googleai`. Install with:

```bash
pip install practiso-sdk[googleai]
```

Example code snippet:

```python
import os

import practiso_sdk

agent = practiso_sdk.google.ai.GeminiAgent(api_key=os.environ['GEMINI_API_KEY'])
dimensions = await agent.get_dimensions(quiz)
print(dimensions)
```

### 2. for generaing content

An MCP server is available at [PractisoDevelopers/mcp](https://github.com/PractisoDevelopers/mcp).