semvec/pypi-packages huggingface dataset:
damascus 0.1.5
Fast, modern, and open-source OpenAPI SDK Generator
License: MIT
Requires Python: >=3.8

<p align="center">
  <img src="https://github.com/beshu-tech/damascus/raw/main/logo.png" alt="Damascus Logo" width="250" />
</p>

# Damascus - OpenAPI SDK Generator

![License](https://img.shields.io/badge/license-GPLv3-blue.svg)
![Python](https://img.shields.io/badge/python-3.8%2B-green.svg)

Damascus is a powerful Python-based SDK generator that transforms OpenAPI specifications into elegant, type-safe client libraries. Generate professional client SDKs for your API with minimal effort.

## Key Features

- **Full Response Models**: Converts API schemas into proper Python dataclasses
- **Type Safety**: Comprehensive type annotations for modern Python development
- **Authentication Support**: Handles API key, Bearer token and other auth methods
- **Multiple Input Sources**: Generate from local JSON files or remote URLs
- **Template-Based**: Easily customizable code generation via Jinja2 templates
- **Python Version Targeting**: Generate code optimized for specific Python versions

## Installation

Using pip:
```bash
pip install damascus
```

Using uv (recommended):
```bash
uv pip install damascus
```

## Requirements

- **Runtime**: Python 3.8+
- **Development**: Python 3.10+ recommended for modern type hints
- **Dependencies**: Jinja2 for templating

## Quick Start

### CLI Usage

Generate an SDK from an OpenAPI specification:

```bash
# From a local file
damascus generate ./path/to/openapi.json --output my_sdk

# From a URL
damascus generate https://api.example.com/openapi.json --output my_sdk

# With custom headers (for protected specs)
damascus generate https://api.example.com/openapi.json --header "Authorization: Bearer token123" --output my_sdk
```

### SDK Usage

Once generated, using the SDK is straightforward:

```python
from my_sdk import Client

# Initialize client
client = Client(
    base_url="https://api.example.com",
    api_key="your-api-key"
)

# Call API methods - responses are typed objects
response = client.get_user(user_id=123)
print(f"User name: {response.name}")
```

## Documentation

Comprehensive documentation is available in the [docs/](docs/) directory:

- [CLI Usage Guide](docs/cli.md)
- [SDK Generation Options](docs/sdkgen.md)
- [Template Customization](docs/templates.md)

## Contributing

We welcome contributions! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.

## License

Damascus is licensed under the GNU General Public License v3.0 (GPLv3) - see the [LICENSE](LICENSE) file for details.

## About

Damascus is created and maintained by [Beshu Limited](https://beshu.tech), a UK company based in London, established in 2017.

Beshu Limited is best known for:
- [ReadonlyREST](https://readonlyrest.com/): Security for Elasticsearch and Kibana
- [Anaphora](https://anaphora.it/): Automated reporting and alerting for Kibana
ragazap 0.1.0
WhatsApp Multi-Capability Protocol (MCP) Server
License: MIT
Requires Python: >=3.8

# Ragazap

A WhatsApp Multi-Capability Protocol (MCP) server that integrates the WhatsApp Cloud API with AI capabilities.

## Features

- Receive and process WhatsApp messages via webhook
- Expose MCP WebSocket endpoint for AI agent connections
- Send messages to WhatsApp contacts
- Store and retrieve conversation history in Redis
- Support for text messages
- Tools for AI agents to interact with WhatsApp
- Two operation modes: Standalone and Client

## Operation Modes

### Standalone Mode
In standalone mode, the server operates independently with its own WhatsApp Business API credentials. This mode is useful for:
- Direct integration with WhatsApp
- Testing and development
- Single-tenant deployments

### Client Mode
In client mode, the server expects WhatsApp credentials to be provided by the client through the MCP protocol. This mode is useful for:
- Multi-tenant deployments
- Managed service providers
- Clients managing their own WhatsApp Business accounts

## Installation

### From PyPI (Recommended)

The package is available on PyPI and can be installed using pip:

```bash
# Install the latest stable version
pip install ragazap
```

### Direct Installation from GitHub

For development or the latest version:

```bash
# Clone the repository
git clone https://github.com/jquant/whatsapp-mcp-server.git
cd whatsapp-mcp-server

# Install the package in development mode
pip install -e .

# Install with development dependencies
pip install -e ".[dev]"
```

### System Requirements

- Python 3.8 or higher
- Redis (optional, for conversation history)
- WhatsApp Business API access (for standalone mode)

## Usage

### Environment Variables

Create a `.env` file with the following variables:

```env
# Mode Configuration
STANDALONE_MODE=false  # Set to true for standalone mode

# WhatsApp API Configuration (Required in standalone mode)
META_API_VERSION=v22.0
META_APP_SECRET=your_app_secret
WHATSAPP_API_TOKEN=your_api_token
WEBHOOK_VERIFY_TOKEN=your_verify_token
BUSINESS_PHONE_NUMBER_ID=your_phone_number_id

# Server Configuration (Required in both modes)
WEBHOOK_HOST=0.0.0.0
WEBHOOK_PORT=8000

# Redis Configuration (Optional in both modes)
UPSTASH_REDIS_URL=your_redis_url
UPSTASH_REDIS_TOKEN=your_redis_token

# Optional Configuration
MAX_CONVERSATION_HISTORY_LENGTH=100
CONVERSATION_EXPIRATION_DAYS=7
LOG_LEVEL=INFO
```

### Running the Server

```bash
# Using the CLI command (if installed via pip)
ragazap

# Or directly with Python
python -m app.main
```

### API Endpoints

- Webhook: `POST /api/v1/webhook`
- MCP WebSocket: `ws://host:port/api/v1/mcp`
- Health Check: `GET /`

## Development

```bash
# Install development dependencies
pip install -e ".[dev]"

# Run tests
pytest
```

## Building the Package

```bash
# Install build tools
pip install build twine

# Build the package
python -m build

# Publish to Test PyPI (for testing)
python scripts/publish_to_pypi.py --test

# Publish to PyPI
python scripts/publish_to_pypi.py
```

This will create both a source distribution (.tar.gz) and a wheel (.whl) in the `dist/` directory.