semvec/pypi-packages huggingface dataset:
zxc-compress 0.7.3
ZXC: Package for high-performance, lossless, asymmetric compressions

# ZXC Python Bindings

High-performance Python bindings for the **ZXC** asymmetric compressor, optimized for **fast decompression**.  
Designed for *Write Once, Read Many* workloads like ML datasets, game assets, and caches.

## Features

- **Blazing fast decompression** — ZXC is specifically optimized for read-heavy workloads.
- **Buffer protocol support** — works with `bytes`, `bytearray`, `memoryview`, and even NumPy arrays.
- **Releases the GIL** during compression/decompression — true parallelism with Python threads.
- **Stream helpers** — compress/decompress file-like objects.

## Installation (from source)

```bash
git clone https://github.com/hellobertrand/zxc.git
cd zxc/wrappers/python
python -m venv .venv
source .venv/bin/activate 
pip install .
teklia-line-image-extractor 0.8.0
A tool for extracting a text line image from the contour with different methods
Keywords: line transformation image extraction

# Line image extractor

This is a tool and a library to be used for extracting line images. Built by [Teklia](https://teklia.com) and freely available as open-source under the MIT licence.

It supports different extraction methods:
* boundingRect - bounding rectangle of the line polygon
* polygon - exact polygon
* min_area_rect - minimum area rectangle containing the polygon
* deskew_polygon - deskew the polygon
* deskew_min_area_rect - deskew the minimum area rectangle
* skew_polygon - skew the polygon (rotate by some angle)
* skew_min_area_rect - skew the minimum area rectangle (rotate by some angle)

Install the library using stable version from Pypi:

```bash
pip install teklia-line-image-extractor
```

Install the library in development mode:

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

Test extraction:

```bash
line-image-extractor -i tests/data/page_img.jpg -o out.jpg -p tests/data/line_polygon.json -e deskew_min_area_rect --color
```

How to use it?:

```python
from pathlib import Path
import numpy as np
from line_image_extractor.extractor import extract, read_img, save_img
from line_image_extractor.image_utils import polygon_to_bbox
from line_image_extractor.image_utils import Extraction

page_img = read_img(Path("tests/data/page_img.jpg"))
polygon = np.asarray([[241, 1169], [2287, 1251], [2252, 1190], [244, 1091], [241, 1169]])
bbox = polygon_to_bbox(polygon)
extracted_img = extract(
    page_img, polygon, bbox, Extraction.polygon
)
save_img("line_output.jpg", extracted_img)
```
testigo-recall-mcp 0.4.3
MCP server for querying testigo-recall knowledge bases
Requires Python: >=3.11

# testigo-recall-mcp

MCP server that exposes a pre-scanned codebase knowledge base to AI agents. Instead of reading source files directly, agents query pre-extracted facts about code behavior, design decisions, and assumptions — saving time and tokens.

Works with Claude Code, Cursor, Windsurf, and any MCP-compatible client.

## Installation

```bash
pip install testigo-recall-mcp
```

## Configuration

### Claude Code

Add to your Claude Code MCP settings (`~/.claude/mcp.json` or project-level):

```json
{
  "mcpServers": {
    "testigo-recall": {
      "command": "testigo-recall-mcp",
      "env": {
        "TESTIGO_RECALL_REPO": "owner/repo"
      }
    }
  }
}
```

### Cursor / Windsurf

Add to your MCP configuration:

```json
{
  "mcpServers": {
    "testigo-recall": {
      "command": "testigo-recall-mcp",
      "env": {
        "TESTIGO_RECALL_REPO": "owner/repo"
      }
    }
  }
}
```

## Environment Variables

| Variable | Description |
|----------|-------------|
| `TESTIGO_RECALL_REPO` | GitHub repo (e.g. `owner/repo`). Auto-downloads the knowledge base from the `knowledge-base` release tag. |
| `TESTIGO_RECALL_DB_PATH` | Explicit path to a local SQLite knowledge base file. Takes priority over repo sync. |
| `GITHUB_TOKEN` | GitHub token for private repos. Public repos work without auth. |

## Tools

The server exposes 5 tools to AI agents:

### `search_codebase`
Full-text search across the knowledge base. Returns facts ranked by relevance.

- `query` — search keywords (e.g. "authentication", "payment flow")
- `category` — optional filter: `behavior`, `design`, or `assumption`
- `min_confidence` — confidence threshold 0.0-1.0
- `limit` — max results (default: 20)

### `get_module_facts`
Deep dive into a specific module. Use `search_codebase` first to discover module IDs.

- `module_id` — e.g. `SCAN:backend/app/api` or `PR-123`

### `get_recent_changes`
Most recently extracted facts across the codebase.

- `category` — optional filter
- `limit` — number of results (default: 10)

### `get_component_impact`
Blast radius analysis — shows what depends on a component and what it depends on.

- `component_name` — file path or service name (e.g. `api_service.py`)

### `list_modules`
Lists all scanned modules in the knowledge base.

- `repo_name` — optional repository filter

## How It Works

The knowledge base contains pre-extracted facts organized by category:

- **behavior** — what the code does (triggers, outcomes)
- **design** — how it's built (decisions, patterns, trade-offs)
- **assumption** — what it expects (invariants, prerequisites)

Facts come from two sources:
- **SCAN facts** (`SCAN:module/path`) — current state of a module, refreshed automatically
- **PR facts** (`PR-123`) — what a specific PR changed, preserved as history

The server uses SQLite with FTS5 full-text search for fast, relevance-ranked queries.
pyTibber 0.36.0
A python3 library to communicate with Tibber
Requires Python: >=3.11

# pyTibber

[![PyPI version](https://badge.fury.io/py/pyTibber.svg)](https://badge.fury.io/py/pyTibber)
<a href="https://github.com/astral-sh/ruff">
  <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json" alt="Ruff">
</a>
<a href="https://github.com/pre-commit/pre-commit">
  <img src="https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=flat-square" alt="pre-commit">
</a>


Python3 library for [Tibber](https://tibber.com/).

Get electricity price and consumption.

If you have a Tibber Pulse or Watty you can see your consumption in real time.

[Buy me a coffee :)](http://paypal.me/dahoiv)


Go to [developer.tibber.com/](https://developer.tibber.com/) to get your API token.

## Install
```
pip3 install pyTibber
```

## Example:

```python
import tibber.const
import tibber
import asyncio


async def start():
  tibber_connection = tibber.Tibber(tibber.const.DEMO_TOKEN, user_agent="change_this")
  await tibber_connection.update_info()
  print(tibber_connection.name)

  home = tibber_connection.get_homes()[0]
  await home.fetch_consumption_data()
  await home.update_info()
  print(home.address1)

  await home.update_price_info()
  print(home.current_price_info)

  # await tibber_connection.close_connection()

loop = asyncio.run(start())
```


## Example realtime data:

An example of how to subscribe to realtime data (Pulse/Watty):

```python
import tibber.const
import asyncio

import aiohttp
import tibber

def _callback(pkg):
    print(pkg)
    data = pkg.get("data")
    if data is None:
        return
    print(data.get("liveMeasurement"))


async def run():
    async with aiohttp.ClientSession() as session:
        tibber_connection = tibber.Tibber(tibber.const.DEMO_TOKEN, websession=session, user_agent="change_this")
        await tibber_connection.update_info()
    home = tibber_connection.get_homes()[0]
    await home.rt_subscribe(_callback)

    while True:
      await asyncio.sleep(10)

loop = asyncio.run(run())
```

The library is used as part of Home Assistant.
cleopy 0.65.1
Python package for generating input and processing output of Cleo SDM
Requires Python: >=3.13

```
/*
 * ----- CLEO -----
 * File: README.md
 * project: CLEO
 * Created Date: Thursday 12th October 2023
 * Author: Clara Bayley (CB)
 * Additional Contributors:
 * -----
 * License: BSD 3-Clause "New" or "Revised" License
 * https://opensource.org/licenses/BSD-3-Clause
 * -----
 * Copyright (c) 2023 MPI-M, Clara Bayley
 */
```

# CLEO
Cleo is a library for Super-Droplet Model microphysics.

You can read more about Cleo in its
documentation: <https://yoctoyotta1024.github.io/CLEO/>.

### Developer Credit
Clara J. A. Bayley is Cleo's main developer.

Her principal co-developers, responsible for the YAC coupling and Cleo's MPI
domain decomposition, are:
- Wilton Loch,
- Aparna Devulapalli.

Clara also gives special thanks to these important people, who also greatly
contributed to Cleo's development:
- Tobias Kölling (Ideas behind using C++ Templates and Concepts, adaptive
timestepping algorithm, and many many other important discussions),
- Lukas Kluft (Python and GitHub CI help).
- Sergey Kosukhin (C++ and CMake help).
extradoc 0.3.0
File-based Google Docs representation library for LLM agents
Requires Python: >=3.10
Keywords: agent, docs, document, extrasuite, google, llm

# extradoc

File-based Google Docs representation library for LLM agents.

Part of the [ExtraSuite](https://github.com/think41/extrasuite) project.

## Overview

extradoc transforms Google Docs into a file-based representation optimized for LLM agents, enabling efficient "fly-blind" editing through the pull/diff/push workflow.

## Installation

```bash
pip install extradoc
# or
uvx extradoc
```

## Quick Start

```bash
# Authenticate (one-time)
uv run python -m extrasuite.client login

# Pull a document
uv run python -m extradoc pull https://docs.google.com/document/d/DOCUMENT_ID/edit

# Edit files locally...

# Preview changes (dry run)
uv run python -m extradoc diff ./DOCUMENT_ID/

# Push changes
uv run python -m extradoc push ./DOCUMENT_ID/
```

## CLI Commands

### pull

Download a Google Doc to local files:

```bash
uv run python -m extradoc pull <document_url_or_id> [output_dir]

# Options:
#   --no-raw    Don't save raw API responses to .raw/ folder
```

### diff

Preview changes (dry run, no API calls):

```bash
uv run python -m extradoc diff <folder>
# Output: batchUpdate JSON to stdout
```

### push

Apply changes to Google Docs:

```bash
uv run python -m extradoc push <folder>

# Options:
#   -f, --force    Push despite warnings (blocks still prevent push)
#   --verify       Re-pull after push and compare to verify correctness
```

## Folder Structure

After `pull`, the folder contains:

```
<document_id>/
  document.xml            # ExtraDoc XML (main content)
  styles.xml              # Factorized style definitions
  .raw/
    document.json         # Raw API response
  .pristine/
    document.zip          # Original state for diff comparison
```

## Development

```bash
cd extradoc
uv sync --all-extras
uv run pytest tests/ -v
uv run ruff check . && uv run ruff format .
uv run mypy src/extradoc
```

## License

MIT License - see LICENSE file for details.
microsoft-agents-hosting-fastapi 0.8.0.dev4
Integration library for Microsoft Agents with FastAPI
Requires Python: >=3.10

# Microsoft Agents Hosting FastAPI

This library provides FastAPI integration for Microsoft Agents, enabling you to build conversational agents using the FastAPI web framework.

## Release Notes
<table style="width:100%">
  <tr>
    <th style="width:20%">Version</th>
    <th style="width:20%">Date</th>
    <th style="width:60%">Release Notes</th>
  </tr>
  <tr>
    <td>0.7.0</td>
    <td>2026-01-21</td>
    <td>
      <a href="https://github.com/microsoft/Agents-for-python/blob/main/changelog.md#microsoft-365-agents-sdk-for-python---release-notes-v070">
        0.7.0 Release Notes
      </a>
    </td>
  </tr>
  <tr>
    <td>0.6.1</td>
    <td>2025-12-01</td>
    <td>
      <a href="https://github.com/microsoft/Agents-for-python/blob/main/changelog.md#microsoft-365-agents-sdk-for-python---release-notes-v061">
        0.6.1 Release Notes
      </a>
    </td>
  </tr>
  <tr>
    <td>0.6.0</td>
    <td>2025-11-18</td>
    <td>
      <a href="https://github.com/microsoft/Agents-for-python/blob/main/changelog.md#microsoft-365-agents-sdk-for-python---release-notes-v060">
        0.6.0 Release Notes
      </a>
    </td>
  </tr>
</table>

## Features

- FastAPI integration for Microsoft Agents
- JWT authorization middleware
- Channel service API endpoints
- Streaming response support
- Cloud adapter for processing agent activities

## Installation

```bash
pip install microsoft-agents-hosting-fastapi
```

## Usage

```python
from fastapi import FastAPI, Request
from microsoft_agents.hosting.fastapi import start_agent_process, CloudAdapter
from microsoft_agents.hosting.core.app import AgentApplication

app = FastAPI()
adapter = CloudAdapter()
agent_app = AgentApplication()

@app.post("/api/messages")
async def messages(request: Request):
    return await start_agent_process(request, agent_app, adapter)
```
wheezy.template 3.2.5
A lightweight template library
Requires Python: >=3.10
Keywords: html, markup, template, preprocessor

# wheezy.template

[![tests](https://github.com/akornatskyy/wheezy.template/actions/workflows/tests.yml/badge.svg)](https://github.com/akornatskyy/wheezy.template/actions/workflows/tests.yml)
[![Coverage Status](https://coveralls.io/repos/github/akornatskyy/wheezy.template/badge.svg?branch=master)](https://coveralls.io/github/akornatskyy/wheezy.template?branch=master)
[![Documentation Status](https://readthedocs.org/projects/wheezytemplate/badge/?version=latest)](https://wheezytemplate.readthedocs.io/en/latest/?badge=latest)
[![pypi version](https://badge.fury.io/py/wheezy.template.svg)](https://badge.fury.io/py/wheezy.template)

[wheezy.template](https://pypi.org/project/wheezy.template/) is a
[python](https://www.python.org) package written in pure Python code. It
is a lightweight template library. The design goals achived:

- **Compact, Expressive, Clean:** Minimizes the number of keystrokes
  required to build a template. Enables fast and well read coding. You
  do not need to explicitly denote statement blocks within HTML
  (unlike other template systems), the parser is smart enough to
  understand your code. This enables a compact and expressive syntax
  which is really clean and just pleasure to type.
- **Intuitive, No time to Learn:** Basic Python programming skills
  plus HTML markup. You are productive just from start. Use full power
  of Python with minimal markup required to denote python statements.
- **Do Not Repeat Yourself:** Master layout templates for inheritance;
  include and import directives for maximum reuse.
- **Blazingly Fast:** Maximum rendering performance: ultimate speed
  and context preprocessor features.

Simple template:

```txt
@require(user, items)
Welcome, @user.name!
@if items:
    @for i in items:
        @i.name: @i.price!s.
    @end
@else:
    No items found.
@end
```

It is optimized for performance, well tested and documented.

Resources:

- [source code](https://github.com/akornatskyy/wheezy.template),
  [examples](https://github.com/akornatskyy/wheezy.template/tree/master/demos)
  and [issues](https://github.com/akornatskyy/wheezy.template/issues)
  tracker are available on
  [github](https://github.com/akornatskyy/wheezy.template)
- [documentation](https://wheezytemplate.readthedocs.io/en/latest/)

## Install

[wheezy.template](https://pypi.org/project/wheezy.template/) requires
[python](https://www.python.org) version 3.10+. It is independent of
operating system. You can install it from
[pypi](https://pypi.org/project/wheezy.template/) site:

```sh
pip install -U wheezy.template
```

To build from source with optional C extensions, install Cython and build
without PEP 517 isolation so the build can see your environment:

```sh
pip install Cython setuptools
pip install -U --no-build-isolation --no-cache-dir wheezy.security[cython]
```

Note: compiling extensions requires a working C compiler toolchain.

If you run into any issue or have comments, go ahead and add on
[github](https://github.com/akornatskyy/wheezy.template).
django-hidp 2.0.0
Full-featured authentication system for Django projects
Requires Python: >=3.11

# Hello, ID Please

"Hello, ID Please" (HIdP) is a Django application that offers a
full-featured authentication system for Django projects. It is designed with
the OWASP best practices in mind and offers a secure and flexible solution for
registering and authenticating users in Django projects.

Please read the full documentation on https://leukeleu.github.io/django-hidp/