semvec/pypi-packages huggingface dataset:
madrigalWeb 3.3.6
Python Madrigal Remote API
Requires Python: >=3.3

# madrigalWeb - a python API to access the Madrigal database

madrigalWeb is a pure python module to access data from any Madrigal database.  For documentation and examples go to any Madrigal site such as 
http://cedar.openmadrigal.org

The easiest way to use the Madrigal python remote data access API is to simply let the web interface write the script you need for you. Just choose the *Access data* pull-down menu and choose *Create a command to download multiple exps*. Then follow the instructions, and you will have the command you need to download whatever you want from Madrigal. Be sure to select python as the language you want to create the command with. You can choose to download files as they are in Madrigal in either column-delimited ascii, Hdf5, or netCDF4 formats, or you can choose the parameters yourself (including derived parameters), and optionally include filters on the data you get back.

This web interface will generate python commands using one of the following two Python scripts: globalDownload.py and globalIsprint.py. Use globalDownload.py if you want data as it is in Madrigal. Use globalIsprint.py to choose parameters and/or filters. These two scripts are documented below, for those who do not want to use the web interface to generate the needed arguments:

See the online documentation for the script globalCitation.py. This script is used to create a permanent citation to a group of Madrigal files.

For questions or comments, contact Bill Rideout at brideout@mit.edu or Katherine Cariglia at cariglia@mit.edu
fragua-sets 1.5
Package with fragua sets with reutilizable functions for ETL process.
Requires Python: >=3.10

# Fragua Sets

**Fragua Sets** is a Python package that complements the **Fragua framework** by providing a set of **pre-configured FraguaSets**.  
These sets can be used directly within a **Fragua environment**, enabling rapid development and testing of ETL workflows.

**Fragua** itself is a Python framework designed to orchestrate **ETL pipelines** using **FraguaAgents**, which execute **pipeline steps** and **functions** to efficiently process data.  
With **Fragua Sets**, you get ready-to-use FraguaSets, allowing you to start working in a Fragua environment without manual configuration.

---

## Features

* Pre-configured **FraguaSets** ready for ETL workflows.
* Includes basic **functions** for **extraction**, **transformation**, and **loading** for common data operations.
* Fully compatible with **FraguaAgents** for immediate execution.
* Minimal setup required – plug and play in your Fragua environment.

---

## Installation

Install via PyPI:

```bash
pip install fragua-sets
```

## Fragua Library

```bash
pip install fragua
```

> ⚠️ Fragua is published for educational and experimental purposes.  
> It is **not recommended for production use yet**.

For more information, visit:
https://pypi.org/project/fragua/

---

## Author

**Santiago Lanz**

* https://sagodev.github.io/My-Portfolio-Web/
* https://www.linkedin.com/in/santiagolanz/
* https://github.com/SagoDev

---

## License

MIT License
muuk-test-repair-mcp 0.1.7
MCP server for analyzing and repairing E2E test failures
Requires Python: >=3.10
Keywords: mcp, testing, playwright, e2e, test-repair, ai

# MuukTest Repair MCP

MCP server for analyzing and repairing E2E test failures (Playwright, Cypress, Selenium, etc).

## Requirements

- Python 3.10+
- [uv](https://github.com/astral-sh/uv)

## Configuration

### VS Code / GitHub Copilot

Open User MCP Configuration (`Cmd+Shift+P` → "MCP: Open User Configuration"):

```json
{
  "inputs": [
    {
      "id": "muuk_key",
      "type": "promptString",
      "description": "Muuk Key available at MuukTest account",
      "password": true
    }
  ],
  "servers": {
    "muuk-test-repair": {
      "command": "uvx",
      "args": ["muuk-test-repair-mcp"],
      "env": {
        "MUUK_KEY": "${input:muuk_key}",
      }
    }
  }
}
```

### Claude Desktop

Edit `~/.config/claude/claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "muuk-test-repair": {
      "command": "uvx",
      "args": ["muuk-test-repair-mcp"],
      "env": {
        "MUUK_KEY": "your-api-key",
      }
    }
  }
}
```

## Usage

Ask your AI agent:

```
Analyze the test failure in my project.
The test file is in ./test-files/ and failure data is in ./failure-data/
```

## Required Parameters

| Parameter | Description |
|-----------|-------------|
| `workspace_path` | Absolute path to project root (agent provides this automatically) |
| `test_file_path` | Path to test file or directory |
| `failure_info_path` | Path to failure info JSON |
| `dom_elements_path` | Path to DOM elements JSON |
| `screenshot_path` | Path to failure screenshot |

## Environment Variables

| Variable | Description |
|----------|-------------|
| `MUUK_KEY` | Your MuukTest key |

## Available AI Presets

- `claude` (default)
- `openai`
- `gemini`

## Troubleshooting

### "The command uvx needed to run muuk-test-repair was not found"

VS Code can't find `uvx` in the PATH. Run in terminal:

```bash
which uvx
```

Then add the path to your shell profile (`~/.zshrc` or `~/.bashrc`):

```bash
export PATH="$PATH:/path/from/which/uvx"
```

Restart VS Code after making changes.
abc-gp-ipm 0.0.1
A simple Python package for implenmenting customised ABC-PMC sampling method and GP models in IPMs.
Requires Python: >=3.8

# ABC GP IPM

The integration of Gaussian Process (GP) models with Approximate Bayesian Computation (ABC) has been explored as a flexible framework for constructing Integral Projection Models (IPMs), enabling non-parametric modelling of demographic relationships and the incorporation of population-level information without explicit likelihoods. However, the practical implementation of this framework - particularly the selection of ABC summary statistics and the execution of ABC-PMC samplers - remains non-trivial and can limit its broader adoption.

To address this gap, we introduce ABC_GP_IPM, a Python package that provides a streamlined and user-friendly interface for constructing GP- and ABC-based IPMs.
statecli 0.5.0
State Replay & Self-Debugging for AI Agents - Track, replay, undo, and checkpoint state changes
Requires Python: >=3.8
Keywords: agent-memory, ai-agent-tools, autogpt, autonomous-agents, checkpoint, crewai, langchain, mcp-server, model-context-protocol, rollback, self-debugging, state-management, state-replay, time-travel-debugging, undo

# StateCLI - Python Client

State Replay & Self-Debugging for AI Agents.

## Installation

```bash
pip install statecli
```

## Quick Start

```python
from statecli import StateCLI

# Initialize
cli = StateCLI()

# Track state changes
cli.track("order", "7421", {"status": "pending"}, actor="ai-agent")
cli.track("order", "7421", {"status": "processing"}, actor="ai-agent")

# Replay to see what happened
replay = cli.replay("order:7421")
print(f"Found {len(replay.changes)} changes")
for change in replay.changes:
    print(f"  Step {change.step}: {change.before} -> {change.after}")

# Create checkpoint before risky operation
cli.checkpoint("order:7421", "before-refund")

# Make risky change
cli.track("order", "7421", {"status": "refunded", "amount": 0})

# Undo if something went wrong
result = cli.undo("order:7421", steps=1)
print(f"Undid {result.steps_undone} step(s)")

# View history
log = cli.log("order:7421")
for change in log.changes:
    print(f"{change.timestamp}: {change.actor} -> {change.after}")
```

## Self-Debugging Pattern

```python
from statecli import StateCLI

class SelfHealingAgent:
    def __init__(self):
        self.cli = StateCLI()
    
    async def execute(self, task):
        entity = f"task:{task.id}"
        
        # Checkpoint before risky operation
        self.cli.checkpoint(entity, "before-execution")
        
        try:
            await self.run_task(task)
        except Exception as e:
            # Replay to see what happened
            replay = self.cli.replay(entity)
            print(f"Task failed. Replay: {replay.changes}")
            
            # Undo and retry
            self.cli.undo(entity)
            await self.retry_with_fix(task, replay)
```

## API Reference

### `StateCLI(db_path=None)`
Initialize client. Uses `~/.statecli/state.db` by default.

### `track(entity_type, entity_id, state, actor="ai-agent")`
Track a state change.

### `replay(entity, actor=None)`
Replay state changes for an entity.

### `undo(entity, steps=1)`
Undo the last N state changes.

### `checkpoint(entity, name)`
Create a named checkpoint.

### `log(entity, since=None, actor=None)`
View state change history.

### `restore_checkpoint(entity, name)`
Restore to a named checkpoint.

## Links

- **GitHub:** https://github.com/statecli/mcp-server
- **NPM (Node.js):** https://www.npmjs.com/package/statecli-mcp-server
- **MCP Registry:** io.github.charo360/statecli

## License

MIT
qoi-rs 4.0.3
Blazingly fast library for decoding and encoding QOI images
Requires Python: >=3.12
Keywords: qoi, image, rust

# qoi-rs

Python library made using [qoi](https://crates.io/crates/qoi) and [pyo3](https://crates.io/crates/pyo3).

## Usage

### With [Pillow](https://pillow.readthedocs.io/en/stable/)

```py
from PIL import Image
from qoi_rs import encode_pillow, decode_pillow

image: Image.Image = Image.open("./qoi_test_images/dice.png")

qoi_bytes: bytes = encode_pillow(image)
decoded: Image.Image = decode_pillow(qoi_bytes)

assert decoded.width == image.width
assert decoded.height == image.height

assert decoded.get_flattened_data() == image.get_flattened_data()

image.close()
decoded.close()
```
cdef-pil-080126-2235 0.1.0
Parental income loss analysis pipeline.
Requires Python: >=3.9

# Parental Income Loss

## Stacked Event-Study Outputs
The stacked example writes results to:
- `output/stacked_event_study/stacked_results.csv`
- `output/stacked_event_study/stacked_results.parquet`

Each row contains:
- `sample`, `chapter`, `component` (event_time or horizon_*),
- `reference_year`, `target_year`, `event_time`,
- `att`, `se`, `conf_low`, `conf_high`,
- `n_pairs`, `n_treated`, `n_control`, `convergence`,
- `bucket_periods`, `horizon_start`, `horizon_end`, `horizon_label`, `bucket_weight`.

Bucket weighting defaults to treated-weighted (`n_treated`). Override with:
- `STACKED_BUCKET_WEIGHT=pairs`

## Quickstart: Custom Components
- Implement one or more of: `PopulationAssembler`, `CohortSelector`, `ExposureDetector`, `MatchingEngine`.
- Wire them into the pipeline with `CohortWorkflow::with_components`.
- Use `docs/component_contracts.md` to ensure required columns are present.

Example wiring:
```rust
let workflow = CohortWorkflow::with_components(builder, selector, matcher);
let outputs = workflow.run(sources, &detector, &registries, &plan, None)?;
```

## Stacked Event Study CLI
- Run the standalone stacked event-study on a parquet file:
  `cargo run -- --stacked-input path/to/stacked_inputs.parquet --did-outcome perindkialt13`
- Optional flags: `--stacked-samples`, `--stacked-chapter-col`, `--stacked-icd-col`,
  `--stacked-output-dir`, plus the existing `--stacked-*` config flags.

## Docs
- Component contracts: `docs/component_contracts.md`
- Custom component example: `crates/pil/examples/custom_components.rs`
- Custom selector example: `crates/pil/examples/custom_selector.rs`
- Custom matcher example: `crates/pil/examples/custom_matcher.rs`
- Custom detector example: `crates/pil/examples/custom_detector.rs`