semvec/pypi-packages huggingface dataset:
iflow-mcp-maorfr-ocm-mcp 0.1.6
MCP server for Red Hat OpenShift Cluster Manager
Requires Python: >=3.11

# ocm-mcp

MCP server for Red Hat OpenShift Cluster Manager

## Running with Podman or Docker

You can run the ocm-mcp server in a container using Podman or Docker. Make sure you have a valid OCM token, which you can obtain by logging into https://console.redhat.com/openshift/token:

Example configuration for running with Podman:

```json
{
  "mcpServers": {
    "ocm-mcp": {
      "command": "podman",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e", "ACCESS_TOKEN_URL",
        "-e", "OCM_CLIENT_ID",
        "-e", "OCM_OFFLINE_TOKEN",
        "-e", "MCP_TRANSPORT",
        "quay.io/redhat-ai-tools/ocm-mcp"
      ],
      "env": {
        "ACCESS_TOKEN_URL": "https://sso.redhat.com/auth/realms/redhat-external/protocol/openid-connect/token",
        "OCM_CLIENT_ID": "cloud-services",
        "OCM_OFFLINE_TOKEN": "REDACTED",
        "MCP_TRANSPORT": "stdio"
      }
    }
  }
}
```

## Running with non-stdio transport

To run the server with a non-stdio transport (such as SSE), set the `MCP_TRANSPORT` environment variable to a value other than `stdio` (e.g., `sse`).

Example configuration to connect to a non-stdio MCP server:

```json
{
  "mcpServers": {
    "slack": {
      "url": "https://ocm-mcp.example.com/sse",
      "headers": {
        "X-OCM-Offline-Token": "REDACTED"
      }
    }
  }
}
```

Replace `REDACTED` with the value from https://console.redhat.com/openshift/token.
fastbencode 0.3.9
Implementation of bencode with optional fast Rust extensions
Requires Python: >=3.10

fastbencode
===========

fastbencode is an implementation of the bencode serialization format originally
used by BitTorrent.

The package includes both a pure-Python version and an optional Rust extension
based on PyO3. Both provide the same functionality, but the Rust extension
provides significantly better performance.

Example:

    >>> from fastbencode import bencode, bdecode
    >>> bencode([1, 2, b'a', {b'd': 3}])
    b'li1ei2e1:ad1:di3eee'
    >>> bdecode(bencode([1, 2, b'a', {b'd': 3}]))
    [1, 2, b'a', {b'd': 3}]

The default ``bencode``/``bdecode`` functions just operate on
bytestrings. Use ``bencode_utf8`` / ``bdecode_utf8`` to
serialize/deserialize all plain strings as UTF-8 bytestrings.
Note that for performance reasons, all dictionary keys still have to be
bytestrings.

License
=======
fastbencode is available under the Apache License, version 2.

Copyright
=========

* Original Pure-Python bencoder © Petru Paler
* Split out from Bazaar/Breezy by Jelmer Vernooĳ
* Rust extension © Jelmer Vernooĳ
textimp2 0.1.0
A Python library for interacting with iMessage data, built using Rust and Apache Arrow.
Requires Python: >=3.12

# TextImp2

A Python library for interacting with iMessage data, built using Rust and Apache Arrow.

## Features

- **Fast & Efficient**: Built with Rust and `imessage-database` crate.
- **Arrow Integration**: Returns data as Apache Arrow RecordBatches, ensuring zero-copy or efficient conversion to Polars and Pandas.
- **Strict Typing**: Uses `imessage-database` structs for reliable parsing.

## Installation

```bash
git clone ...
cd textimp2
uv sync
```

## Usage

### Typed Getters

The library provides convenient getters for different DataFrames:

```python
import textimp2

# Get Polars DataFrames
df_msgs = textimp2.get_messages_polars()
df_handles = textimp2.get_handles_polars()

# Get Pandas DataFrames
df_msgs_pd = textimp2.get_messages_pandas()
df_handles_pd = textimp2.get_handles_pandas()

# Get Arrow RecordBatch
batch_msgs = textimp2.get_messages_arrow()
```

### Specifying a Database Path

All functions accept an optional `path` argument:

```python
df = textimp2.get_messages_polars("/path/to/chat.db")
```

## Permissions (macOS)

Accessing `~/Library/Messages/chat.db` requires **Full Disk Access**.
py-cursor-hooks 0.1.1
A typed Python SDK for building Cursor hooks
Requires Python: >=3.14

# py-cursor-hooks

A typed Python Library for building [Cursor hooks](https://cursor.com/docs/agent/hooks).

## Why use this?

Cursor runs hooks as subprocesses and communicates via JSON on stdin/stdout. Without this SDK, you'd need to write shell scripts that manually parse JSON, validate inputs, and format responses. With it, you get to write Python and:

- **Pydantic models** for all hook inputs and outputs
- **Type-safe interfaces** that catch errors before runtime
- **A CLI** that works out of the box with Cursor

## Quick Start

### 1. Install

```bash
uv add py-cursor-hooks
```

### 2. Write your hooks

Create a module with your hook implementations:

```python
from hooks.interfaces import CursorHooks
from hooks.models import BeforeReadFileInput, BeforeReadFileOutput


class MyHooks(CursorHooks):
    def before_read_file(
        self, input: BeforeReadFileInput
    ) -> BeforeReadFileOutput:
        # Block reading .env files
        if input.file_path.endswith(".env"):
            return BeforeReadFileOutput(
                permission="deny",
                user_message="Cannot read .env files",
                agent_message="Reading .env files is not allowed",
            )
        return BeforeReadFileOutput(permission="allow")


hooks = MyHooks()
```

### 3. Register your hooks

In your `pyproject.toml`, add an entry point so the CLI can find your implementation:

```toml
[project.entry-points."py_cursor_hooks.hooks"]
default = "my_package.my_hooks:hooks"
```

Then install your project:

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

### 4. Configure Cursor

Add your hooks to `~/.cursor/hooks.json`:

```json
{
  "version": 1,
  "hooks": {
    "beforeReadFile": [
      { "command": "uvx --from /absolute/path/to/your/project python -m hooks.run --hook beforeReadFile" }
    ]
  }
}
```

That's it! Cursor will now run your hooks automatically.