semvec/pypi-packages huggingface dataset:
param-lsp 0.0.1b23
Param Language Server Protocol
Requires Python: >=3.10
Keywords: holoviz, lsp, param

# param-lsp

A Language Server Protocol (LSP) implementation for the HoloViz Param library, providing intelligent IDE support for Python codebases using Param.

## Demo

<!-- Video placeholder - replace with actual video URL or embed code -->

_Demo video coming soon_

## Features

- **Autocompletion**: Context-aware completions for Param class constructors, parameter definitions, and @param.depends decorators
- **Parameter checking**: Real-time validation of parameter types, bounds, and constraints with error diagnostics
- **Hover information**: Rich documentation for Param parameters including types, bounds, descriptions, and default values
- **Cross-file analysis**: Intelligent parameter inheritance tracking across local and external Param classes (Panel, HoloViews, etc.)

## Installation

```bash
pip install param-lsp
```

## Usage

Configure your IDE to use param-lsp as the language server for Python files containing Param code.

### VS Code

Install the param-lsp VS Code extension from the marketplace.

### Other IDEs

Configure your IDE's LSP client to use `param-lsp server` as the language server command.

## Development

```bash
# Clone the repository
git clone https://github.com/your-username/param-lsp.git
cd param-lsp

# Install dependencies
uv sync

# Run tests
pytest tests/

# Run linting
prek run --all-files
```
eunomia-sdk 0.3.10
Eunomia SDK for Python
Requires Python: >=3.10

# Eunomia SDK for Python

This package allows you to integrate [Eunomia][eunomia-github] inside your Python application, providing a client to interact with the Eunomia server.

## Installation

Install the `eunomia-sdk` package via pip:

```bash
pip install eunomia-sdk
```

## Usage

Create an instance of the `EunomiaClient` class to interact with the Eunomia server.

```python
from eunomia_sdk import EunomiaClient

client = EunomiaClient()
```

You can then call any server endpoint through the client. For example, you can check the access of a principal to a resource:

```python
response = client.check(
    principal_attributes={"role": "admin"},
    resource_attributes={"type": "confidential"},
)

print(f"Is allowed: {response.allowed}")
```

## Documentation

For detailed usage, check out the SDK's [documentation][docs].

[eunomia-github]: https://github.com/whataboutyou-ai/eunomia
[docs]: https://whataboutyou-ai.github.io/eunomia/api/sdks/python/
eunomia-langchain 0.3.10
Eunomia extension for LangChain
Requires Python: >=3.10

# Eunomia extension for LangChain

This package provides an extension of [Eunomia][eunomia-github] for [LangChain][langchain-website], allowing you to:

- Register documents loaded by any [LangChain's loader][langchain-loaders-docs] to the Eunomia server
- Enforce authorization policies on documents retrieved by any [LangChain retriever][langchain-retriever-docs]

## Installation

Install the `eunomia-langchain` package via pip:

```bash
pip install eunomia-langchain
```

## Usage

### Document Loader

The `EunomiaLoader` class is a wrapper around any loader class from LangChain that sends documents to the Eunomia server.

```python
from eunomia_langchain import EunomiaLoader
from langchain_community.document_loaders.csv_loader import CSVLoader

# Create a document loader
loader = CSVLoader("data.csv")

# Wrap the loader with Eunomia
wrapped_loader = EunomiaLoader(loader)

# Load documents and register them with the Eunomia server
docs = wrapped_loader.load(additional_metadata={"group": "financials"})
```

All loaded documents will be automatically sent to the Eunomia server which will assign an identifier to each document and store their metadata. The identifiers and metadata can then be used to configure or reference policies in the Eunomia server.

### Document Retriever

The `EunomiaRetriever` class wraps any LangChain retriever and filters allowed documents using the Eunomia server.

```python
from eunomia_core import schemas
from eunomia_langchain import EunomiaRetriever
from langchain_community.retrievers import BM25Retriever
from langchain_core.documents import Document

# Create a retriever with some documents
retriever = BM25Retriever.from_documents([
    Document(page_content="foo", metadata={"confidentiality": "public"}),
    Document(page_content="bar", metadata={"confidentiality": "public"}),
    Document(page_content="foo bar", metadata={"confidentiality": "private"}),
])

# Wrap the retriever with Eunomia
wrapped_retriever = EunomiaRetriever(
    retriever=retriever,
    principal=schemas.PrincipalCheck(uri="test-uri"),
)

# Only documents the principal has access to will be returned
docs = wrapped_retriever.invoke("foo")
```

## Documentation

For detailed usage, check out the SDK's [documentation][docs].

[eunomia-github]: https://github.com/whataboutyou-ai/eunomia
[docs]: https://whataboutyou-ai.github.io/eunomia/api/extensions/langchain/
[langchain-website]: https://www.langchain.com/
[langchain-loaders-docs]: https://python.langchain.com/docs/concepts/document_loaders/
[langchain-retriever-docs]: https://python.langchain.com/docs/concepts/retrievers/
eunomia-core 0.3.10
Shared functionalities for Eunomia packages
Requires Python: >=3.10

# Eunomia Core

Eunomia core package with minimal required dependencies.

## Overview

This package contains shared functionality across the main [Eunomia][eunomia-github] package and all Eunomia SDKs.

It includes common data models, utility functions, and types that ensure consistency across all Eunomia components.

## Installation

```bash
pip install eunomia-core
```

## Usage

```python
from eunomia_core import *
```

## Documentation

For detailed usage, check out the package [documentation][docs].

[eunomia-github]: https://github.com/whataboutyou-ai/eunomia
[docs]: https://whataboutyou-ai.github.io/eunomia/api/core/
boltz_client 0.3.0.post1
Boltz Swap library
Requires Python: >=3.10

# Boltz Client Python Bindings

Python bindings for the Boltz Rust library, enabling atomic swaps between Bitcoin, Lightning Network, and Liquid.

## Installation

```bash
pip install boltz_client
```

## Quick Start

> **⚠️ WARNING: All examples are only to be used in REGTEST.**

```python
import boltz_client
import asyncio

async def main():
    # Initialize for regtest (do NOT use this example in production)
    network = boltz_client.Network.REGTEST
    boltz_api = boltz_client.BoltzApiClientV2.default(network)

    # Example: Create a submarine swap (Lightning → Bitcoin)
    key_pair = boltz_client.KeyPair()
    btc_chain = boltz_client.btc_chain_from_network(network)

    invoice = "lightning-invoice-to-pay"

    request = boltz_client.CreateSubmarineRequest(
        _from=btc_chain,
        to=btc_chain,
        invoice=invoice,
        refund_public_key=key_pair.public(),
    )

    swap = await boltz_api.create_swap(request)
    print(f"Send {swap.expected_amount} sats to {swap.address}")

asyncio.run(main())
```

## Swap Types

- **Submarine swaps** - Lightning → On-chain Bitcoin/Liquid
- **Reverse swaps** - On-chain Bitcoin/Liquid → Lightning
- **Chain swaps** - Bitcoin ↔ Liquid atomic swaps

## Examples

Complete working examples are available in the `examples/` directory:

- [`submarine.py`](examples/submarine.py) - Lightning to Bitcoin
- [`reverse.py`](examples/reverse.py) - Bitcoin to Lightning
- [`chain.py`](examples/chain.py) - Bitcoin to Liquid (and vice versa)
iflow-mcp_mitmproxy-mcp 0.1.0
A MCP server project
Requires Python: >=3.11

# mitmproxy-mcp MCP server

A MCP server project

## Components

### Resources

The server implements a simple note storage system with:
- Custom note:// URI scheme for accessing individual notes
- Each note resource has a name, description and text/plain mimetype

### Prompts

The server provides a single prompt:
- summarize-notes: Creates summaries of all stored notes
  - Optional "style" argument to control detail level (brief/detailed)
  - Generates prompt combining all current notes with style preference

### Tools

The server implements one tool:
- add-note: Adds a new note to the server
  - Takes "name" and "content" as required string arguments
  - Updates server state and notifies clients of resource changes

## Configuration

[TODO: Add configuration details specific to your implementation]

## Quickstart

### Install

#### Claude Desktop

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

<details>
  <summary>Development/Unpublished Servers Configuration</summary>
  ```
  "mcpServers": {
    "mitmproxy-mcp": {
      "command": "uv",
      "args": [
        "--directory",
        "/Users/lucas/Coding/mitmproxy-mcp",
        "run",
        "mitmproxy-mcp"
      ]
    }
  }
  ```
</details>

<details>
  <summary>Published Servers Configuration</summary>
  ```
  "mcpServers": {
    "mitmproxy-mcp": {
      "command": "uvx",
      "args": [
        "mitmproxy-mcp"
      ]
    }
  }
  ```
</details>

## Development

### Building and Publishing

To prepare the package for distribution:

1. Sync dependencies and update lockfile:
```bash
uv sync
```

2. Build package distributions:
```bash
uv build
```

This will create source and wheel distributions in the `dist/` directory.

3. Publish to PyPI:
```bash
uv publish
```

Note: You'll need to set PyPI credentials via environment variables or command flags:
- Token: `--token` or `UV_PUBLISH_TOKEN`
- Or username/password: `--username`/`UV_PUBLISH_USERNAME` and `--password`/`UV_PUBLISH_PASSWORD`

### 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 /Users/lucas/Coding/mitmproxy-mcp run mitmproxy-mcp
```


Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.