smart-api-integrations 0.2.0

Connect to any API and receive webhooks with minimal code. Turn API docs into Python functions and handle incoming events easily.

🚀 Smart API Integrations

Connect to any API and receive webhooks with minimal code.

What This Package Does

Smart API Integrations eliminates boilerplate code for:

1. API Integration - Connect to third-party APIs with simple function calls
2. Webhook Handling - Process incoming events from external services

Before vs After

API Integration

Before Smart API Integrations:

import requests
import os

# Set up authentication
token = os.environ.get("GITHUB_TOKEN")
headers = {"Authorization": f"Bearer {token}"}

# Make the request
response = requests.get("https://api.github.com/users/octocat", headers=headers)

# Handle the response
if response.status_code == 200:
    user = response.json()
    print(f"User: {user['name']}")
else:
    print(f"Error: {response.status_code}")
    print(response.text)

After Smart API Integrations:

from smart_api_integrations import GithubAPIClient

# Create client (automatically uses GITHUB_TOKEN from environment)
github = GithubAPIClient()

# Make the request
user = github.get_user(username='octocat')
print(f"User: {user.data['name']}")

Webhook Handling

Before Smart API Integrations:

from flask import Flask, request, jsonify
import hmac
import hashlib
import os

app = Flask(__name__)

@app.route('/webhooks/stripe', methods=['POST'])
def stripe_webhook():
    # Verify signature
    signature = request.headers.get('Stripe-Signature')
    secret = os.environ.get('STRIPE_WEBHOOK_SECRET')
    
    if not signature or not secret:
        return jsonify({"error": "Missing signature"}), 400
        
    # Compute expected signature
    payload = request.data
    expected_sig = hmac.new(
        secret.encode(),
        payload,
        hashlib.sha256
    ).hexdigest()
    
    # Verify signature
    if not hmac.compare_digest(expected_sig, signature):
        return jsonify({"error": "Invalid signature"}), 401
    
    # Process the event
    event_data = request.json
    event_type = event_data.get('type')
    
    if event_type == 'payment_intent.succeeded':
        # Handle payment success
        amount = event_data['data']['object']['amount'] / 100
        print(f"Payment received: ${amount}")
    elif event_type == 'payment_intent.payment_failed':
        # Handle payment failure
        print("Payment failed")
    
    return jsonify({"status": "success"})

if __name__ == '__main__':
    app.run(port=5000)

After Smart API Integrations:

from flask import Flask
from smart_api_integrations.webhooks import smart_webhook_handler
from smart_api_integrations.frameworks.flask import register_webhook_routes

app = Flask(__name__)

@smart_webhook_handler('stripe', 'payment_intent.succeeded')
def handle_payment(event):
    amount = event.payload['data']['object']['amount'] / 100
    print(f"Payment received: ${amount}")
    return {"status": "processed"}

@smart_webhook_handler('stripe', 'payment_intent.payment_failed')
def handle_payment_failure(event):
    print("Payment failed")
    return {"status": "handled"}

# Register all webhook routes
register_webhook_routes(app)

if __name__ == '__main__':
    app.run(port=5000)

🚀 Quick Start

Installation

pip install smart-api-integrations

API Integration

from smart_api_integrations import UniversalAPIClient

# Create a client for any configured API provider
github = UniversalAPIClient('github')  # Uses GITHUB_TOKEN from environment

# Call methods based on the provider's configuration
user = github.get_user(username='octocat')
print(f"User: {user.data['name']}")

Webhook Integration

from smart_api_integrations.webhooks import smart_webhook_handler

@smart_webhook_handler('stripe', 'payment_intent.succeeded')
def handle_payment(event):
    amount = event.payload['data']['object']['amount'] / 100
    print(f"Payment received: ${amount}")
    return {"status": "processed"}

📚 Documentation

Getting Started

• Quick Start Guide
• API Client Guide
• Webhook Integration

API Integration

• Adding New Providers
• OpenAPI Integration
• Type Safety Guide

Webhook Integration

• Webhook System Overview
• Webhook Handler Guide
• Framework Integration Guide

Reference

• CLI Reference
• Provider Configuration Guide
• Package Setup Guide

Examples

• API Examples
• Webhook Examples
• Framework Examples

🔧 Key Features

• ✅ Zero Boilerplate: Define endpoints once, use everywhere
• ✅ Type Safety: Full IDE support with generated type stubs
• ✅ Smart Parameters: Automatic handling of path/query/body parameters
• ✅ Framework Integration: Works with Flask, FastAPI, and Django
• ✅ Webhook Support: Easily handle incoming webhook events
• ✅ OpenAPI Support: Generate clients from API documentation

📄 License

MIT License - see LICENSE file for details.

---

Stop writing API boilerplate. Start building features. 🚀