semvec/pypi-packages huggingface dataset:
pearsonify 0.1.0
A lightweight package for computing confidence intervals for classification tasks using conformal prediction and Pearson residuals.
Requires Python: >=3.9
Keywords: classification, confidence intervals, conformal prediction, machine learning, pearson residuals

# 💡 Pearsonify
## Probabilistic Classification with Conformalized Intervals

**Pearsonify** is a lightweight 🐍 Python package for generating **classification intervals** around predicted probabilities in binary classification tasks.

It uses **Pearson residuals** and **principles of conformal prediction** to quantify uncertainty without making strong distributional assumptions.

![Image](ims/Slide_1.jpeg)

### 🚀 Why Pearsonify?

* 📊 **Intuitive Classification Intervals**: Get reliable intervals for binary classification predictions.
* 🧠 **Statistically Grounded**: Uses Pearson residuals, a well-established metric from classical statistics.
* ⚡ **Model-Agnostic**: Works with any model that provides probability estimates.
* 🛠️ **Lightweight**: Minimal dependencies, easy to integrate into existing projects.

### 📦 How to install?

Use `pip` to install the package from GitHub:

```bash
pip install pearsonify
# or from GitHub:
pip install git+https://github.com/xRiskLab/pearsonify.git
```

### 💻 How to use?

```python
import numpy as np
from pearsonify import Pearsonify
from sklearn.svm import SVC
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

# Generate synthetic classification data
np.random.seed(42)
X, y = make_classification(
    n_samples=1000, n_features=20, n_informative=10, n_classes=2, random_state=42
)

# Split data into train, calibration, and test sets
X_train, X_temp, y_train, y_temp = train_test_split(X, y, test_size=0.4, random_state=42)
X_cal, X_test, y_cal, y_test = train_test_split(X_temp, y_temp, test_size=0.5, random_state=42)

# Initialize Pearsonify with an SVC model
clf = SVC(probability=True, random_state=42)
model = Pearsonify(estimator=clf, alpha=0.05)

# Fit the model on training and calibration sets
model.fit(X_train, y_train, X_cal, y_cal)

# Generate prediction intervals for test set
y_test_pred_proba, lower_bounds, upper_bounds = model.predict_intervals(X_test)

# Calculate coverage
coverage = model.evaluate_coverage(y_test, lower_bounds, upper_bounds)
print(f"Coverage: {coverage:.2%}")

# Plot the intervals
model.plot_intervals(y_test_pred_proba, lower_bounds, upper_bounds)
```

Running `example.py` will generate the following plot:

![Image](ims/Figure_1.png)

This plot shows predicted probabilities with 95% confidence intervals, sorted by prediction score.

### 📖 References

Hosmer, D. W., Lemeshow, S., & Sturdivant, R. X. (2013). Applied Logistic Regression. John Wiley & Sons.

Tibshirani, R. (2023). Conformal Prediction. Advanced Topics in Statistical Learning, Spring 2023.

### 📝 License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
hocon2 0.5.0
HOCON parser for python
Requires Python: >=3.11

# HOCON parser with json-like interface

[![codecov](https://codecov.io/github/myjniak/hocon/graph/badge.svg?token=ZY5KK0BSJY)](https://codecov.io/github/myjniak/hocon)

## Usage

Just like in python json module, you can load from a file or from a string to python dictionary/list:

```python
import hocon

data = """
animal.favorite: badger
key : ${animal.favorite} is my favorite animal
"""
dictionary = hocon.loads(data)
```

And you can dump it back to string:

```pycon
>>> import json
>>> print(json.dumps(dictionary, indent=4))
{
    "animal": {"favorite": "badger"},
    "key": "badger is my favorite animal"
}
```

## Specification

The library has NOT YET been tested according to each and every statement in
the [hocon specification](https://github.com/lightbend/config/blob/v1.4.3/HOCON.md).
Check [FEATURES.md](https://github.com/myjniak/hocon/blob/main/FEATURES.md) to see which HOCON functionalities are already implemented and tested.
iflow-mcp_mlaugharn-cli 0.1.0
cli bridge
Requires Python: >=3.11

# cli MCP server

cli bridge

<img width="870" alt="image" src="https://github.com/user-attachments/assets/a7b78531-c681-40fc-bd65-044980547629">

Pretty much a remix of the demo notes app.

## Components

### Resources

The server implements a simple system for working with arbitrary clis with:
- Custom cli:// URI scheme for accessing individual notes
- Each cli resource has a name, help menu subtree, and text/plain mimetype

### Tools

The server implements one tool:
- add (cmd): Recursively parses cli help menu subtrees and stores definition
  - Takes "cmd" 
  - Updates server state and notifies clients of resource changes
- help (cmd): Return subtrees definition
- run (cmd, cmd_args | None): Run a known command
## Quickstart

### Install

#### Claude Desktop
Note: I had to use `/opt/homebrew/bin/uv` instead of just `uv` in the command field in this json:

On MacOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`

On Windows: `%APPDATA%/Claude/claude_desktop_config.json`



```
{"mcpServers": {
  "cli": {
    "command": "uv",
    "args": [
      "run",
      "--directory",
      "\<path to repo folder\>",
      "cli"
    ]}
  }
}
```


By design, you have to explicitly 'add' a command before it can be run.

### Debugging

Since MCP servers run over stdio, debugging can be challenging. For the best debugging
experience, we strongly recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector).


You can launch the MCP Inspector via [`npm`](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) with this command:

```bash
npx @modelcontextprotocol/inspector uv --directory <path to repo> run cli
```


Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.
shepherd-client 2026.2.2
Web-Client for the Shepherd-Testbed
Requires Python: >=3.10
Keywords: testbed, beaglebone, pru, batteryless, energyharvesting, solar

# Schepherd-Client

[![PyPIVersion](https://img.shields.io/pypi/v/shepherd_client.svg)](https://pypi.org/project/shepherd_client)
[![PyVers](https://img.shields.io/pypi/pyversions/shepherd_client.svg)](https://pypi.python.org/pypi/shepherd-client)
[![QA-Tests](https://github.com/nes-lab/shepherd-webapi/actions/workflows/quality_assurance.yaml/badge.svg)](https://github.com/nes-lab/shepherd-webapi/actions/workflows/quality_assurance.yaml)

**Shepherd Nova Testbed**: https://testbed.nes-lab.org/

**Testbed-WebAPI**: <https://shepherd.cfaed.tu-dresden.de:8000>

**Source Code**: <https://github.com/nes-lab/shepherd-webapi>

**Main Project**: <https://github.com/nes-lab/shepherd>

---

The Testbed-Client links the user to the testbed.
It's written in Python and uses http-requests to communicate with the web-API.
As the source is open, you can modify and extend it as you like.
You could also write your own tools based on these few hundred lines of code.

## Features

- register & delete an account
- query user information
- create, schedule, query state of experiments
- download results

In the near future, the functionality will be extended to:

- list content like available energy environments, firmwares, virtual power sources (currently hardcoded in shepherd-core)
- query the testbed data-model (currently hardcoded in shepherd-core)
- query state of the observers (last seen alive)
- query statistics on the scheduler-queue
- CLI

## Getting started

### Install

You can install the client by using the package-manager of your choice. In the following example we show pip and uv:

```Shell
pip3 install shepherd-client -U
# or modern uv with automatic virtual environment
uv pip install shepherd-client -U
```

Newest features can be obtained by directly installing from GitHub:

```shell
uv pip install git+https://github.com/nes-lab/shepherd-webapi.git@main#subdirectory=shepherd_client
```

### Usage

The current interface is introduced in 5 short examples in the example-directory.
neurones 0.1.0
AI Agent Orchestrator — delegate tasks across Claude Code, Gemini CLI, and Codex CLI
Requires Python: >=3.11

# Neurones

<p align="center">
  <img src="https://raw.githubusercontent.com/Nisabatech/neurones/main/assets/logo.png" alt="Neurones logo" width="700" />
</p>

Neurones is a multi-model orchestrator for developer-focused AI CLIs.  
It coordinates Claude Code, Gemini CLI, and Codex CLI from a single interface.

## Highlights

- Orchestrated workflow: analyze, delegate, collect, synthesize
- Direct run mode per agent
- Parallel compare mode across agents
- Terminal UI dashboard with live per-agent panels
- Retry handling for rate-limited agent calls

## Installation

```bash
pip install neurones
```

Or from source:

```bash
git clone https://github.com/Nisabatech/neurones.git
cd neurones
pip install -e .
```

## Requirements

- Python 3.11+
- At least one installed AI CLI:
  - `claude`
  - `gemini`
  - `codex`

## Usage

Run orchestration with a prompt:

```bash
nr "Plan and implement a FastAPI auth module with tests"
```

Run a prompt directly on one agent:

```bash
nr run codex "Refactor this function for readability"
```

Compare answers from multiple agents:

```bash
nr compare "Explain this architecture"
```

Show detected agents and active config:

```bash
nr status
nr config show
```

Launch TUI:

```bash
nr --tui
```

## Configuration

Configuration file is created at:

```text
~/.neurones/config.toml
```

Example:

```toml
primary = "claude"
parallel_timeout = 600
json_output = true

[agents.codex]
auto_approve = true
timeout = 300
extra_args = ["--skip-git-repo-check"]
```

## Project Links

- Repository: https://github.com/Nisabatech/neurones
- Issues: https://github.com/Nisabatech/neurones/issues
raw-docx 0.12.0
A package for processing and analyzing raw document formats
Requires Python: >=3.8

# Raw DOCX

A Python library that extends [python-docx](https://python-docx.readthedocs.io/) to convert Word documents into structured, traversable Python objects with export to dictionary, HTML, and plain text formats.

## Installation

```bash
pip install raw_docx
```

## Features

- **Document hierarchy** - Automatic section numbering with multi-level headings (1-6)
- **Rich text** - Colors, highlighting, bold, italic, superscript, and subscript
- **Tables** - Full support for merged cells (row and column spans)
- **Nested lists** - Arbitrary nesting depth with level tracking
- **Bookmarks and cross-references** - Bookmark anchors and field-based references
- **Image extraction** - Extracts embedded images with base64 HTML embedding
- **Multiple export formats** - Dictionary, HTML, and plain text
- **Search** - Find text across sections, tables, and the full document
- **Error tracking** - Integrated logging via [simple_error_log](https://pypi.org/project/simple-error-log/)

## Quick Start

```python
from raw_docx import RawDocx

# Load and process a document
docx = RawDocx("path/to/document.docx")

# Access the structured document
document = docx.target_document

# Export to dictionary
data = docx.to_dict()

# Work with sections
section = document.section_by_title("Introduction")
paragraphs = section.paragraphs()
tables = section.tables()
lists = section.lists()

# Search for content
results = section.find("keyword")

# Generate HTML
html = section.to_html()
```

## Key Classes

| Class | Description |
|-------|-------------|
| `RawDocx` | Main entry point; loads and processes a .docx file |
| `RawDocument` | Top-level container managing sections and hierarchy |
| `RawSection` | A document section/heading with its content |
| `RawParagraph` | A paragraph containing runs and bookmarks |
| `RawRun` | A text run with formatting attributes |
| `RawTable` / `RawTableRow` / `RawTableCell` | Table structure with merged cell support |
| `RawList` / `RawListItem` | Nested list structure |
| `RawImage` | Embedded image handling |

## Requirements

- Python >= 3.8
- [python-docx](https://pypi.org/project/python-docx/) >= 1.1.2
- [simple_error_log](https://pypi.org/project/simple-error-log/) >= 0.6.0

## License

MIT - see [LICENSE](LICENSE) for details.

## Build and Release

```bash
pytest
ruff format
ruff check
python3 -m build --sdist --wheel
twine upload dist/*
```