semvec/pypi-packages huggingface dataset:
findllm 0.1.2
Detect AI-generated text using GPT-2 token prediction analysis
Requires Python: >=3.11

# findllm - Detect AI-generated text by analyzing token prediction patterns using GPT-2.
https://github.com/user-attachments/assets/89d03001-7cef-4b9e-878d-c991bd520f18

## Installation

> [!IMPORTANT]
> This project was 99% vibe coded using gemini 3 Pro, sonnet 4.5 and opus 4.5.
> The model tends to identify AI text as human text more often than the reverse. 
> The metrics can't be fully trusted though, so use everything with caution!

```bash
# Run directly with uv
uvx findllm document.md

# With document conversion support (PDF, DOCX, PPTX, etc.)
uvx 'findllm[markitdown]' document.pdf

# Or install into your environment
pip install findllm

# With document conversion support
pip install 'findllm[markitdown]'
```

## Usage

```bash
# Analyze a text file (sentence mode by default)
findllm document.md

# Analyze documents (PDF, DOCX, PPTX, XLSX, etc.) - requires markitdown extra
findllm paper.pdf
findllm presentation.pptx
findllm report.docx

# Use token-level analysis
findllm document.md --mode token

# Chunk sentences into smaller batches (e.g., 10 tokens per chunk)
findllm document.md --max-sentence-tokens 10

# Skip short sentences (e.g., less than 5 tokens, default is 3)
findllm document.md --min-sentence-tokens 5

# Use different aggregation methods (mean, max, l2, rmse, median, default is l2)
findllm document.md --aggregation max

# JSON output for programmatic use
findllm document.md --json
```

## Document Support

With the `markitdown` extra installed, findllm can analyze various document formats:

- **PDF** (.pdf)
- **Microsoft Office** (.docx, .pptx, .xlsx)
- **HTML** (.html, .htm)
- **Rich Text** (.rtf)
- **And more** - see [markitdown](https://github.com/microsoft/markitdown) for full format support

Documents are automatically converted to markdown in-memory before analysis.

## How It Works

The tool analyzes how predictable each token in the text is according to GPT-2:

- **Green** = Low probability (unpredictable, human-like)
- **Yellow** = Moderate probability
- **Orange** = Higher probability
- **Red** = High probability (predictable, AI-like)

AI-generated text tends to follow predictable patterns that language models can easily anticipate. Human writing is more variable and surprising.

### Metrics

- **Perplexity**: How "surprised" the model is overall (lower = more predictable)
- **Burstiness**: Variation in complexity (humans tend to write with more variation)
- **Color Distribution**: Percentage of green/yellow/orange/red tokens

### Evaluation
Evaluation on 150 samples from https://www.kaggle.com/datasets/shanegerami/ai-vs-human-text

<img width="223" height="176" alt="Image" src="https://github.com/user-attachments/assets/ffe96501-548f-4868-90d0-f8b33d55619d" />
autohive-integrations-sdk 1.0.2
Integrations SDK for Autohive
Requires Python: >=3.13

# Integrations SDK for Autohive

##  Overview

This is the SDK for building integrations into Autohive's AI agent platform.

### SDK

The SDK code lives in [src/autohive_integrations_sdk](https://github.com/Autohive-AI/integrations-sdk/tree/master/src/autohive_integrations_sdk).

### Documentation

Basic API docs can be found in [docs/apidocs](https://github.com/Autohive-AI/integrations-sdk/tree/master/docs/apidocs).

More verbose documentation lives in [docs/manual](https://github.com/Autohive-AI/integrations-sdk/tree/master/docs/manual), including a [tutorial to build your first integration](docs/manual/building_your_first_integration.md).

### Samples

The [samples directory](https://github.com/Autohive-AI/integrations-sdk/tree/master/samples) contains a very basic "API Fetch" integration as a sample starting point.

## Additional information

[Release Notes](https://github.com/Autohive-AI/integrations-sdk/blob/master/RELEASENOTES.md)

## Error Reporting

The SDK includes integration with Raygun4Py for error reporting and crash tracking. To enable error reporting:

1. Set the `RAYGUN_API_KEY` environment variable with your Raygun API key
2. The SDK will automatically send exception reports to Raygun when errors occur

The setup for error reporting will be done automatically for you by the Autohive application and helps us with monitoring and debugging integration issues in production environments.
tap-belvo 0.3.5
Singer tap for Belvo, built with the Meltano SDK for Singer Taps.
Requires Python: >=3.11
Keywords: Belvo, ELT, singer.io

# tap-belvo

Singer tap for Belvo.

Built with the [Meltano Singer SDK](https://sdk.meltano.com).

## Capabilities

* `catalog`
* `state`
* `discover`
* `about`
* `stream-maps`
* `schema-flattening`

## Settings

| Setting             | Required | Default | Description |
|:--------------------|:--------:|:-------:|:------------|
| secret_id           | True     | None    | Belvo API secret ID. |
| password            | True     | None    | Belvo API password. |
| start_date          | False    | None    | Earliest datetime to get data from |
| base_url            | False    | https://development.belvo.com | Base URL for the Belvo API |
| stream_maps         | False    | None    | Config object for stream maps capability. For more information check out [Stream Maps](https://sdk.meltano.com/en/latest/stream_maps.html). |
| stream_map_config   | False    | None    | User-defined config values to be used within map expressions. |
| flattening_enabled  | False    | None    | 'True' to enable schema flattening and automatically expand nested properties. |
| flattening_max_depth| False    | None    | The max depth to flatten schemas. |

A full list of supported settings and capabilities is available by running: `tap-belvo --about`

### Source Authentication and Authorization

See https://developers.belvo.com/reference/authentication-1.

## Usage

You can easily run `tap-belvo` by itself or in a pipeline using [Meltano](https://meltano.com/).

### Executing the Tap Directly

```bash
tap-belvo --version
tap-belvo --help
tap-belvo --config CONFIG --discover > ./catalog.json
```

## Developer Resources

### Initialize your Development Environment

```bash
uv tool install --with tox-uv tox
```

### Create and Run Tests

Run all tests:

```bash
tox run-parallel
```

### Testing with [Meltano](https://www.meltano.com)

_**Note:** This tap will work in any Singer environment and does not require Meltano.
Examples here are for convenience and to streamline end-to-end orchestration scenarios._

Your project comes with a custom `meltano.yml` project file already created. Go ahead and [install Meltano](https://docs.meltano.com/getting-started/installation/) if you haven't already.

1. Install all plugins

   ```bash
   meltano install
   ```

1. Check that the extractor is working properly

   ```bash
   meltano invoke tap-belvo --version
   ```

1. Execute an ELT pipeline

   ```bash
   meltano run tap-belvo target-jsonl
   ```
bpo 0.4.0
CLI to optimize prompts with AWS Bedrock
Requires Python: >=3.10

<h3 align="center">
    Bedrock Prompt Optimizer (bpo)
</h3>

<p align="center">
<img style="border-radius:8px;" alt="demo" src="docs/bpo.gif"/>
</p>

A CLI wrapper around the Amazon Bedrock Agents Runtime `optimize_prompt` method, which optimizes prompts for the given model. Checkout available models [here](https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-management-optimize.html). 

## Installation

To install the Bedrock Prompt Optimizer cli, run:

```bash
pip install bpo
```

## Usage

### Arguments

- `--prompt`: Path to the input prompt file
- `--output`: Path to the output file where the optimized prompt will be saved (default: optimized_prompt.txt)
- `--model-id`: Bedrock model ID (default: will prompt to select from a list of models)
- `--region`: AWS region (default: us-east-1)
- `--stdout`: Print the optimized prompt to stdout instead of saving to a file
- `--clip`: Use the last thing copied to clipboard as the input text to optimize

### Example

```bash
bpo optimize --prompt input.txt --model-id amazon.nova-pro-v1:0 --region us-east-1
```

This command will:
1. Read the prompt from `input.txt`
2. Optimize it
3. Save the optimized prompt to `optimized_prompt.txt`

```bash
bpo optimize --clip --stdout
```

This command will:
1. Read the text from the last copied item in the clipboard
2. Provide a select input to pick a model from (just a subset of available models)
2. Optimize it
3. Output the optimized prompt to standard output

## Notes

- Ensure you have the necessary AWS credentials configured to access the Bedrock service.
hummingbird-ai 0.0.6
Hummingbird AI - chatbot LLM and training infrastructure for Forager AI
Requires Python: >=3.12.12

% hummingbird_ai(3) Version 0.0.3 | Hummingbird AI - chatbot and LLM backend API for Forager AI

Name
====

**Hummingbird AI** - chatbot and LLM backend API for Forager AI


Synopsys
========


Description
===========


See Also
========
<a href='https://pr3d4t0r.github.io/SSScoring/ssscoring.html' target='_blank'>Humming AI API documentation (placeholder)</a> - github.io
hummingbird_docker(3)
rtcpstream 1.6.3
fix http error for python 3.11+ 

# rtcpstream

**rtcpstream** is a simple and powerful Python module for building real-time communication applications. Inspired by the rtcpstream standard, it allows you to handle audio, video, and P2P data with low latency and minimal syntax.

---

## Features

* **P2P Communication**: Direct data exchange between clients without a central server.
* **Audio & Video**: Real-time transmission with low latency.
* **Data Channels**: Send and receive text or JSON messages instantly.
* **Event Handling**: Simple callbacks for `on_connect`, `on_message`, `on_disconnect`.
* **Secure**: Built-in DTLS/SRTP encryption.
* **Interoperable**: Compatible with browsers and other rtcpstream clients.

---

## Installation

```bash
pip install rtcpstream
```



---

## Basic Usage

### Create a client and connect

```python
from rtcpstream import rtcpstreamClient

# Initialize the client
client = rtcpstreamClient(username="Alice")

# Event triggered when a message is received
@client.on("message")
def handle_message(sender, content):
    print(f"{sender} says: {content}")

# Connect to a peer
client.connect("bob_peer_id")

# Send a message
client.send("bob_peer_id", "Hi Bob!")

# Listen for events
client.listen()
```

### Audio/Video example

```python
client.connect_audio()
client.connect_video()
```

---

## Use Cases

* Real-time audio and video chats
* P2P multiplayer games
* Streaming and data sharing
* Collaborative tools (drawing, shared documents)

---