semvec/pypi-packages huggingface dataset:
mzgeohash 1.1.0
Mapzen Geohash
Requires Python: >=3.8

# Mapzen Geohash

[![Circle CI](https://circleci.com/gh/transitland/mapzen-geohash.png?style=badge)](https://circleci.com/gh/transitland/mapzen-geohash)

A geohash is a convenient method for encoding geographic coordinates, where each character in the geohash adds additional precision. This makes geohashes well suited for indexing mechanisms, grouping geographically located entities, and compactly encoding coordinates based on the level of detail required.

More information about Geohashes:

 * http://www.movable-type.co.uk/scripts/geohash.html
 * http://en.wikipedia.org/wiki/Geohash
 * http://geohash.org/

This Python package contains simple tools for encoding and decoding geohashes.

## Installation

Installation using pip:

```
pip install mzgeohash
```

Alternatively, [download from PyPi](https://pypi.python.org/pypi/mzgeohash) or clone this repository, and install using setup.py:

```
python ./setup.py install
```

## Example usage

```
>>> import mzgeohash
>>> mzgeohash.decode('xn76urwe1g9y')
(139.76608408614993, 35.681382017210126)
>>> mzgeohash.encode((139.76608408614993, 35.681382017210126))
'xn76urwe1g9y'
>>> mzgeohash.neighbors('xn76urwe1g9y')
{'c': 'xn76urwe1g9y',
 'e': 'xn76urwe1gdn',
 'n': 'xn76urwe1g9z',
 'ne': 'xn76urwe1gdp',
 'nw': 'xn76urwe1g9x',
 's': 'xn76urwe1g9v',
 'se': 'xn76urwe1gdj',
 'sw': 'xn76urwe1g9t',
 'w': 'xn76urwe1g9w'}
```

## Contributing

Please [open a Github issue](https://github.com/transitland/mapzen-geohash/issues/new) with as much of the following information as you're able to specify, or [contact us](#contact) for assistance.

## Contact

Transitland is sponsored by [Mapzen](http://mapzen.com). Contact us with your questions, comments, or suggests: [hello@mapzen.com](mailto:hello@mapzen.com).
kafka-mcp-server 0.1.1
Add your description here
Requires Python: >=3.13

# Kafka MCP Server

A Message Context Protocol (MCP) server that integrates with Apache Kafka to provide publish and consume functionalities for LLM and Agentic applications.

## Overview

This project implements a server that allows AI models to interact with Kafka topics through a standardized interface. It supports:

- Publishing messages to Kafka topics
- Consuming messages from Kafka topics

## Prerequisites

- Python 3.8+
- Apache Kafka instance
- Python dependencies (see Installation section)

## Installation

1. Clone the repository:
   ```bash
   git clone <repository-url>
   cd <repository-directory>
   ```

2. Create a virtual environment and activate it:
   ```bash
   python -m venv venv
   source venv/bin/activate  # On Windows, use: venv\Scripts\activate
   ```

3. Install the required dependencies:
   ```bash
   pip install -r requirements.txt
   ```

   If no requirements.txt exists, install the following packages:
   ```bash
   pip install aiokafka python-dotenv pydantic-settings mcp-server
   ```

## Configuration

Create a `.env` file in the project root with the following variables:

```
# Kafka Configuration
KAFKA_BOOTSTRAP_SERVERS=localhost:9092
TOPIC_NAME=your-topic-name
IS_TOPIC_READ_FROM_BEGINNING=False
DEFAULT_GROUP_ID_FOR_CONSUMER=kafka-mcp-group

# Optional: Custom Tool Descriptions
# TOOL_PUBLISH_DESCRIPTION="Custom description for the publish tool"
# TOOL_CONSUME_DESCRIPTION="Custom description for the consume tool"
```

## Usage

### Running the Server

You can run the server using the provided `main.py` script:

```bash
python main.py --transport stdio
```

Available transport options:
- `stdio`: Standard input/output (default)
- `sse`: Server-Sent Events

### Integrating with Claude Desktop

To use this Kafka MCP server with Claude Desktop, add the following configuration to your Claude Desktop configuration file:

```json
{
    "mcpServers": {
        "kafka": {
            "command": "python",
            "args": [
                "<PATH TO PROJECTS>/main.py"
            ]
        }
    }
}
```

Replace `<PATH TO PROJECTS>` with the absolute path to your project directory.

## Project Structure

- `main.py`: Entry point for the application
- `kafka.py`: Kafka connector implementation
- `server.py`: MCP server implementation with tools for Kafka interaction
- `settings.py`: Configuration management using Pydantic

## Available Tools

### kafka-publish

Publishes information to the configured Kafka topic.

### kafka-consume

consume information from the configured Kafka topic.
- Note: once a message is read from the topic it can not be read again using the same groupid
pyisyntax 0.1.5
Python bindings for libisyntax
Requires Python: >=3.10

# pyisyntax

A Python library for working with pathology images in the iSyntax file format,
powered by [libisyntax](https://github.com/amspath/libisyntax).

## Installation

```console
$ pip install pyisyntax
```

## Usage

Read and display a region of the WSI via
[Pillow](https://pillow.readthedocs.io/).

```python
from isyntax import ISyntax
import PIL.Image

with ISyntax.open("my_file.isyntax") as isyntax:
    # Read pixels from the specified region into a numpy array
    pixels = isyntax.read_region(500, 500, 400, 200, level=4)
    # Convert numpy array into a PIL image
    pil_image = PIL.Image.fromarray(pixels)
    # Show the image
    pil_image.show()
```

Extract and save the associated macro image.

```python
from isyntax import ISyntax

with ISyntax.open("my_file.isyntax") as isyntax:
    # The macro image will be returned as compressed JPEG data.
    jpeg_data = isyntax.read_macro_image_jpeg()
    # This JPEG data can be written directly to a file.
    with open("macro_image.jpg", "wb") as f:
        f.write(jpeg_data)
    # Alternatively, you could decompress the data using Pillow:
    # pil_image = PIL.Image.open(io.BytesIO(jpeg_data), formats=["JPEG"])
```

## Development

### Dependency management

To set up a development environment from the lock file:

1. Ensure that you have [uv](https://docs.astral.sh/uv/) installed.
2. Create the virtual environment:
   ```console
   $ uv sync --frozen
   ```

To modify pyisyntax project dependencies:

1. Edit dependencies in `pyproject.toml`.
2. Update the lock file using uv:
   ```console
   $ uv lock
   ```
resume-screening-mcp 0.1.6
Resume screening service using LLM
Requires Python: >=3.10

# Resume Screening MCP Service

A service for screening resumes using Large Language Models. This service evaluates resumes against specific requirements using semantic understanding rather than simple keyword matching.

## Installation

### Using UV (recommended)

```bash
uv pip install .
```

### Using pip

```bash
pip install .
```

## Configuration

The application uses environment variables for configuration. Create a `.env` file in the root directory with the following variables:

```
OPENAI_API_KEY=your_api_key_here
OPENAI_MODEL=gpt-4o-mini
```

## Usage

### Command Line Interface

```bash
# Process resumes in a specific directory
resume-screening --resume-dir=./my_resumes --report-dir=./reports

# Or using environment variables
RESUME_DIR=./my_resumes REPORT_DIR=./reports resume-screening
```

### As MCP Service

```python
from fastmcp import FastMCPClient

client = FastMCPClient()
response = await client.call("resume_screening", {
    "prompt": "筛选精通Python且有金融机构从业经验的简历",
    "resume_dir": "./resumes",
    "report_dir": "./reports"
})
print(response)
```

## Directory Structure

- `resume_screening_mcp/` - Main package directory
  - `__init__.py` - Package initialization
  - `core.py` - Core resume processing functionality
  - `cli.py` - Command line interface
  - `server.py` - MCP server implementation

## Development

```bash
# Install development dependencies
uv pip install -e ".[dev]"

# Run tests
pytest
```

## License

MIT
jiwer-gml 4.0.1
Evaluate your speech-to-text system with similarity measures such as word error rate (WER)
Requires Python: >=3.8

# JiWER

JiWER is a simple and fast python package to evaluate an automatic speech recognition system.
It supports the following measures:

1. word error rate (WER)
2. match error rate (MER)
3. word information lost (WIL) 
4. word information preserved (WIP) 
5. character error rate (CER)

These measures are computed with the use of the minimum-edit distance between one or more reference and hypothesis sentences.
The minimum-edit distance is calculated using [RapidFuzz](https://github.com/maxbachmann/RapidFuzz), which uses C++ under the hood, and is therefore faster than a pure python implementation.

## Documentation

For further info, see the documentation at [jitsi.github.io/jiwer](https://jitsi.github.io/jiwer).

## Installation

You should be able to install this package using [uv](https://docs.astral.sh/uv/): 

```
$ uv add jiwer
```

Or, if you prefer old-fashioned pip and you're using Python >= `3.8`:

```bash
$ pip install jiwer
```

## Usage

The most simple use-case is computing the word error rate between two strings:

```python
from jiwer import wer

reference = "hello world"
hypothesis = "hello duck"

error = wer(reference, hypothesis)
```


## A note on empty references

There is undefined behaviour when you apply an empty reference and hypothesis pair
to the WER formula, as you get a division by zero.

As of version 4.0, `jiwer` defines the behaviour as follows, and thereby also
lifts the requirement for reference strings to be non-empty.
This allows for testing whether models hallucinate on silent audio.
Note that usually, there are multiple reference and hypothesis pairs.
It now supported that one or more of these references are empty, but to test well,
most references should still be non-empty.

```python3
import jiwer

# when ref and hyp are both empty, there is no error as
# an ASR system correctly predicted silence/non-speech.
assert jiwer.wer('', '') == 0 
assert jiwer.mer('', '') == 0
assert jiwer.wip('', '') == 1
assert jiwer.wil('', '') == 0

assert jiwer.cer('', '') == 0
```

When the hypothesis is non-empty, every word or character counts as an insertion:
```python3
import jiwer

assert jiwer.wer('', 'silence') == 1
assert jiwer.wer('', 'peaceful silence') == 2
assert jiwer.process_words('', 'now defined behaviour').insertions == 3

assert jiwer.cer('', 'a') == 1
assert jiwer.cer('', 'abcde') == 5
```

## Licence

The jiwer package is released under the `Apache License, Version 2.0` licence by [8x8](https://www.8x8.com/).

For further information, see [`LICENCE`](./LICENSE).

## Reference

_For a comparison between WER, MER and WIL, see: \
Morris, Andrew & Maier, Viktoria & Green, Phil. (2004). [From WER and RIL to MER and WIL: improved evaluation measures for connected speech recognition.](https://www.researchgate.net/publication/221478089_From_WER_and_RIL_to_MER_and_WIL_improved_evaluation_measures_for_connected_speech_recognition)_