semvec/pypi-packages huggingface dataset:
openlayer-mcp 0.2.0
MCP server for the Openlayer platform
Requires Python: >=3.10

# Openlayer MCP

[MCP](https://github.com/modelcontextprotocol) (Model Context Protocol) server for
the Openlayer platform. This allows MCP clients (such as Cursor, VSCode,
Claude Desktop, etc.) to interact with the Openlayer platform.

## Installation

```bash
uv add openlayer-mcp
```
or

```bash
pip install openlayer-mcp
```

## Usage

To use the Openlayer MCP server in your IDE or desktop app, you need to add it
to the MCP configuration file.

```json
{
    "mcpServers": {
        "openlayer": {
            "command": "uvx",
            "args": [
                "openlayer-mcp"
            ],
            "env": {
                "OPENLAYER_API_KEY": "YOUR_OPENLAYER_API_KEY_HERE"
            }
        }
    }
}
```

You can alternatively run it as a standalone server with:

```bash
uv run -m openlayer_mcp
```
pyodide-py 0.29.3
A Python package providing core interpreter functionality for Pyodide
Requires Python: >=3.13

# Pyodide Python package

A Python package providing core interpreter functionality for Pyodide.

This package is an integral part of the Pyodide runtime which cannot start
without it. Install in a native Python for type checking or testing purposes.
Some of the functionality is missing when imported in a native Python, but for
the APIs we either provide reimplementations or nonfunctional type stubs.

## License

Pyodide uses the [Mozilla Public License Version
2.0](https://choosealicense.com/licenses/mpl-2.0/).

## Design information for Pyodide contributors

This directory consists of two Python packages py/\_pyodide and py/pyodide. The
difference between these packages is when they are imported. They are both
imported by core/pyodide as a part of setting up the Pyodide/javascript foreign
function interface.

py/\_pyodide is imported as the first step after initializing
the CPython interpreter. py/\_pyodide cannot have any import time dependencies
other than the CPython stdlib.

py/pyodide is imported as the final step of core/pyodide. It has an import time
dependency on `_pyodide_core` which is a Python C extension assembled by
core/pyodide to serve the needs of py/pyodide.
onnx-cse 0.1.1
Common subexpression elimination for ONNX graphs
Requires Python: >=3.10

# onnx-cse

[![CI](https://github.com/cbourjau/onnx-cse/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/cbourjau/onnx-cse/actions/workflows/ci.yml)

`onnx-cse` is a tiny library for [common subexpression elimination](https://en.wikipedia.org/wiki/Common_subexpression_elimination) (CSE) from ONNX models.

## Example usage

The `onnx_cse` package provides a single function:

```python
from onnx_cse import eliminate_common_subexpressions
import onnx

model = onnx.load_model("model.onnx")
# Update model in-place
eliminate_common_subexpressions(model)
```

## Comparisons

It is written in pure Python with minimal dependencies and focuses on being safe, fast, and simple.
It differs from similar tools such as [onnxoptimizer](https://github.com/onnx/optimizer), [onnx-simplifier](https://github.com/daquexian/onnx-simplifier), and [onnxruntime](https://github.com/microsoft/onnxruntime)s own CSE-pass in the following ways:

### Simplicity

`onnx-cse` does one thing (CSE) but does it well.
The entire library is less then a couple of hundred lines of code and easy to understand for anybody interested.

### Performance

From personal experience `onnx-cse` handily outperforms onnxruntime's CSE pass on very large graphs with small weights (~10k nodes with nested subgraphs) while `onnxoptimizer` fails to finish its operation on such graphs at all.

### Optimization across subgraph boundaries

`onnx-cse` eliminates subexpressions in subgraphs if they can be replaced with expressions found in the enclosing scope.

## Installation

### pypi

```
pip install onnx-cse
```

### conda-forge

Using pixi:

```
pixi add onnx-cse
```

or using conda:

```
conda install onnx-cse
```

### Development

You can install the package in development mode using:

```bash
git clone https://github.com/cbourjau/onnx-cse
cd onnx-cse
pixi run pre-commit-install
pixi run postinstall
pixi run test
```
bumplot 0.2.1
Easily create and customize bump charts in Python
Requires Python: >=3.10
Keywords: bump, bump plot, bump charts, matplotlib, data, visualization, bezier, curve

# `bumplot`: easily create and customize bump charts in Python

<!-- Automatically generated, uses README.qmd to modify README.md -->

<img src="https://github.com/JosephBARBIERDARNAL/static/blob/main/python-libs/bumplot/image.png?raw=true" alt="bumplot logo" align="right" width="180px"/>

`bumplot` is a small Python package made to facilitate the creation of
**bump charts** using matplotlib and Bézier curves. It has high
customization capabilities too!

Bump charts are useful when the focus is on comparing **relative
rankings**—who is ahead of whom—rather than the exact magnitude of the
differences.

Check out the [online
documentation](https://y-sunflower.github.io/bumplot/)

<br> <br>

## Get started

```python
import matplotlib.pyplot as plt
import pandas as pd

from bumplot import bumplot

data = pd.DataFrame(
    {
        "x": [2020, 2021, 2022, 2023],
        "A": [10, 50, 20, 80],
        "B": [40, 30, 60, 10],
        "C": [90, 20, 70, 40],
    }
)

fig, ax = plt.subplots(figsize=(8, 4))
bumplot(
    x="x",
    y_columns=["A", "B", "C"],
    data=data,
    curve_force=0.5,
    plot_kwargs={"lw": 4},
    scatter_kwargs={"s": 150, "ec": "black", "lw": 2},
    colors=["#ffbe0b", "#ff006e", "#3a86ff"],
)
ax.legend()
ax.spines[["top", "right", "left", "bottom"]].set_visible(False)
ax.grid(alpha=0.4)
```

![](README_files/figure-commonmark/cell-3-output-1.png)

[See more examples](https://y-sunflower.github.io/bumplot/examples/)

<br> <br>

## Installation

    pip install bumplot

<br><br>

## Features

- Automatic ranking of your data (with support for both `pandas` and
  `polars`)
- Accept categorical data for x-axis
- Infinite customization capabilities
- Easy control of the curvature intensity
grpcvcr 0.1.1
Record and replay gRPC interactions for testing
Requires Python: >=3.11

# grpcvcr

[![CI](https://github.com/tboser/grpcvcr/actions/workflows/ci.yml/badge.svg)](https://github.com/tboser/grpcvcr/actions/workflows/ci.yml)
[![codecov](https://codecov.io/gh/tboser/grpcvcr/graph/badge.svg)](https://codecov.io/gh/tboser/grpcvcr)
[![PyPI version](https://img.shields.io/pypi/v/grpcvcr.svg)](https://pypi.org/project/grpcvcr/)
[![Python versions](https://img.shields.io/pypi/pyversions/grpcvcr.svg)](https://pypi.org/project/grpcvcr/)

**Record and replay gRPC interactions for testing** - like [VCR.py](https://vcrpy.readthedocs.io/) but for gRPC.

## Installation

```bash
pip install grpcvcr
```

## Quick Start

```python
from grpcvcr import recorded_channel, RecordMode

# Record on first run, replay on subsequent runs
with recorded_channel("tests/cassettes/my_test.yaml", "localhost:50051") as channel:
    stub = MyServiceStub(channel)
    response = stub.GetUser(GetUserRequest(id=1))
    assert response.name == "Alice"
```

## Features

- **Record & Replay**: Automatically record gRPC interactions and replay them in tests
- **All RPC Types**: Supports unary, server streaming, client streaming, and bidirectional streaming
- **Async Support**: Full support for `grpc.aio` async clients
- **pytest Integration**: Built-in fixtures and markers for easy test integration
- **Flexible Matching**: Match requests by method, metadata, body, or custom logic
- **Multiple Formats**: Store cassettes as YAML or JSON

## Recording Modes

| Mode | Description |
|------|-------------|
| `NEW_EPISODES` | Play existing, record new (default) |
| `NONE` | Playback only - fail if no match |
| `ALL` | Always record, overwrite existing |
| `ONCE` | Record if cassette missing, then playback |

## Async Support

```python
from grpcvcr import AsyncRecordingChannel, Cassette, RecordMode

cassette = Cassette("test.yaml", record_mode=RecordMode.ALL)

async with AsyncRecordingChannel(cassette, "localhost:50051") as recording:
    stub = MyServiceStub(recording.channel)
    response = await stub.GetUser(GetUserRequest(id=1))
```

## pytest Integration

```python
import pytest
from grpcvcr import RecordMode

@pytest.mark.grpcvcr(cassette="user_test.yaml", record_mode=RecordMode.NONE)
def test_get_user(grpcvcr_cassette):
    from grpcvcr import RecordingChannel

    with RecordingChannel(grpcvcr_cassette, "localhost:50051") as rc:
        stub = MyServiceStub(rc.channel)
        response = stub.GetUser(GetUserRequest(id=1))
        assert response.name == "Alice"
```

Run in record mode:

```bash
pytest --grpcvcr-record=new_episodes
```

Run in strict playback mode (CI):

```bash
pytest --grpcvcr-record=none
```

## Request Matching

```python
from grpcvcr import recorded_channel, MethodMatcher, RequestMatcher, MetadataMatcher

# Match on method + request body
matcher = MethodMatcher() & RequestMatcher()

with recorded_channel("test.yaml", "localhost:50051", match_on=matcher) as channel:
    ...

# Ignore certain metadata keys
matcher = MethodMatcher() & MetadataMatcher(ignore_keys=["x-request-id"])
```

## License

MIT