semvec/pypi-packages huggingface dataset:
optimade-mcp-server 0.1.2
A MCP-compatible OPTIMADE server with configurable filters and endpoints.
Requires Python: >=3.10

# OPTIMADE MCP SERVER
A Model Context Protocol (MCP) tool for querying Optimade-compatible material databases, fully configurable custom filter presets and provider endpoints.
# 🎯 Overview
This tool enables structured data queries across multiple OPTIMADE databases (e.g., Materials Project, Materials Cloud, COD), via MCP protocol. Key capabilities include:

1.Custom or preset OPTIMADE filter queries

2.Configurable list of OPTIMADE providers via config/optimade_config.json

3.Proxy support via .env file

4.Easily deployable via uvx, cline
# ⚙️ Installation & Usage
## ✅ Recommended via uv
1.Install the tool:
~~~~~~
uv pip install optimade-mcp-server
~~~~~~
2.In cline or any MCP-compatible launcher, configure the tool as follows:
~~~~~~
{
  "mcpServers": {
    "optimade": {
      "command": "uv",
      "args": ["--directory", "optimade-mcp-server", "run", "optimade"]
    }
  }
}
~~~~~~
# 🌐 Proxy Support (Optional)
If you need to use a VPN or proxy, create a .env file in the project root:
~~~~~~
HTTP_PROXY=http://127.0.0.1:<your-port>
HTTPS_PROXY=http://127.0.0.1:<your-port>
~~~~~~
If you don't need a proxy, you can comment out or remove the proxy setup in the source code.
# 🪪 License
This project is licensed under the MIT License. See LICENSE for details.
dj-dispatch 0.1.0
A Django app implementing the transactional outbox pattern with CloudEvents support
Requires Python: >=3.11
Keywords: dispatch, django, outbox

# Django Outbox

[![PyPI version](https://badge.fury.io/py/django-outbox.svg)](https://badge.fury.io/py/django-outbox)
[![Python versions](https://img.shields.io/pypi/pyversions/django-outbox.svg)](https://pypi.org/project/django-outbox/)
[![Django versions](https://img.shields.io/pypi/djversions/django-outbox.svg)](https://pypi.org/project/django-outbox/)
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
[![CI](https://github.com/yourusername/django-outbox/workflows/CI/badge.svg)](https://github.com/yourusername/django-outbox/actions)
[![Coverage](https://codecov.io/gh/yourusername/django-outbox/branch/main/graph/badge.svg)](https://codecov.io/gh/yourusername/django-outbox)

A Django app that implements the transactional outbox pattern with CloudEvents support, enabling reliable event publishing in distributed systems.

## Features

- 🔄 **Transactional Outbox Pattern**: Ensures events are published reliably
- ☁️ **CloudEvents Compatible**: Follows CloudEvents specification
- 🔌 **Multiple Backends**: Redis Streams, Kafka, NATS support
- 🔁 **Retry Logic**: Exponential backoff with configurable retries
- 🔑 **Idempotency**: Prevents duplicate event processing
- 📊 **Monitoring**: Built-in metrics and health checks
- 🎯 **Event Handlers**: Local event processing framework
- 🔧 **Admin Interface**: Django admin integration

## Quick Start

### Installation

```bash
# Using pip
pip install django-dispatch

# Using uv
uv add django-dispatch
```

## Configuration
Add to your Django settings:

```python
INSTALLED_APPS = [
    # ... your other apps
    'django_dispatch',
]

OUTBOX_PUBLISHERS = {
    'default': {
        'BACKEND': 'django_dispatch.backends.RedisStreamBackend',
        'OPTIONS': {
            'host': 'localhost',
            'port': 6379,
            'stream_name': 'events',
        }
    }
}
```

## Usage
```python
from django_dispatch.publishers import publisher

# Publish an event
event = publisher.publish_event(
    event_type='user.created',
    source='user-service',
    data={'user_id': 123, 'email': 'user@example.com'}
)

# Register event handler
from django_dispatch.registry import event_registry

@event_registry.register('user.created')
def handle_user_created(event):
    print(f"User created: {event.data}")
```
## Running the Worker

```bash
python manage.py outbox_worker
```
## Documentation
Full documentation is available at https://django-dispatch.readthedocs.io/en/latest/.

### Building and Serving Documentation Locally

To build the documentation locally:

```bash
# Build the documentation
make docs-build

# Serve the documentation locally at http://localhost:8080
make docs-serve
```

After running `make docs-serve`, you can access the documentation by opening http://localhost:8080 in your web browser.

## Contributing
Contributions are welcome! Please read our Contributing Guide for details.

## License
This project is licensed under the MIT License - see the LICENSE file for details.
beanycro 0.0.1
A package of utilities used for personal projects.
Requires Python: >=3.13

# Benny Bean Utils Package

## Description
This package targets to offer basic utilities for my personal projects.

## Installation

### To build the package : 
```bash
py -m pip install --upgrade build
py -m build
```

### To upload the package to PyPI:
```bash
py -m pip install --upgrade twine
py -m twine upload dist/*
```

## Utilities
### Test
This is a simple utility to test if the package works

```python
from benny_bean_utils.test import ping

ping()  # Output: Pong!
```
flexitricity-stream-dtk 0.2.0
Utility functions for working with Azure Event Hub
Requires Python: >=3.10

![Flexitricity](https://ui.flex.paz/assets/resources/logos/flexitricity-logo-svg.svg)

# Stream Developer Tool Kit 🛶

Development tools for streaming, install via `pip install flexitricity-stream-dtk` and import with `from flex import stream`.

Tools in here are designed to support streaming onto Azure event hubs, grids etc, as well as to create standards for consistent message formats for easier sending/recieving.
flexitricity-data-dtk 1.0.0
Handy tools for datalake access
Requires Python: >=3.10

<img src="https://ui.flex.paz/assets/resources/logos/flexitricity-logo-svg.svg" alt="Flexitricity" width="100">

# Data Developer Tool Kit 💾

Development tools for data access, install via `pip install flexitricity-data-dtk` and import with `from flex import data`.

Tools in here are designed to support best practice authentication and access of data resources, and to implement standards for easier cross-team collaboration.