Flask Integration

Build astrology APIs with Flask

Setup

# Create project
mkdir flask-astrology && cd flask-astrology
python -m venv venv
source venv/bin/activate

# Install dependencies
pip install flask vedika-sdk python-dotenv

Basic Flask App

# app.py
from flask import Flask, request, jsonify
from dotenv import load_dotenv
from vedika import VedikaClient
from vedika.exceptions import VedikaAPIError

load_dotenv()

app = Flask(__name__)
vedika = VedikaClient()  # reads VEDIKA_API_KEY from the environment

@app.route('/api/chart', methods=['POST'])
def birth_chart():
    data = request.get_json()

    try:
        # request() returns the full response: {"success": ..., "data": {...}, "billing": {...}}
        body = vedika.request('POST', '/v2/astrology/birth-chart', json={
            'datetime': data['datetime'],
            'latitude': data['latitude'],
            'longitude': data['longitude'],
            'timezone': data['timezone']  # e.g. '+05:30'
        })
        chart = body['data']

        return jsonify({
            'sun_sign': chart['sunSign'],
            'moon_sign': chart['moonSign'],
            'ascendant': chart['ascendant']['sign'],
            'planets': [
                {
                    'name': p['name'],
                    'sign': p['sign'],
                    'degree': p['degree']
                }
                for p in chart['planets']
            ]
        })
    except VedikaAPIError as e:
        return jsonify({'error': e.message}), 500

@app.route('/api/panchang', methods=['GET'])
def panchang():
    date = request.args.get('date')  # YYYY-MM-DD
    lat = float(request.args.get('lat', 28.6139))
    lng = float(request.args.get('lng', 77.2090))

    try:
        body = vedika.get_panchang(
            date=date,
            latitude=lat,
            longitude=lng,
            timezone='+05:30'
        )
        panchang = body['data']

        return jsonify({
            'tithi': panchang['tithi']['name'],
            'nakshatra': panchang['nakshatra']['name'],
            'yoga': panchang['yoga']['name'],
            'karana': panchang['karana']['name']
        })
    except VedikaAPIError as e:
        return jsonify({'error': e.message}), 500

if __name__ == '__main__':
    app.run(debug=True)

Blueprints Structure

# routes/astrology.py
from flask import Blueprint, request, jsonify
from services.vedika_service import VedikaService

astrology_bp = Blueprint('astrology', __name__, url_prefix='/api')
vedika_service = VedikaService()

@astrology_bp.route('/chart', methods=['POST'])
def chart():
    data = request.get_json()
    result = vedika_service.get_chart(data)
    return jsonify(result)

@astrology_bp.route('/match', methods=['POST'])
def match():
    data = request.get_json()
    result = vedika_service.match_charts(data['bride'], data['groom'])
    return jsonify(result)

@astrology_bp.route('/dasha', methods=['POST'])
def dasha():
    data = request.get_json()
    result = vedika_service.get_dasha(data)
    return jsonify(result)
# services/vedika_service.py
from vedika import VedikaClient
from vedika.exceptions import VedikaAPIError

class VedikaService:
    def __init__(self):
        self.client = VedikaClient()

    def get_chart(self, birth_details):
        # birth_details: datetime, latitude, longitude, timezone
        body = self.client.request('POST', '/v2/astrology/birth-chart', json=birth_details)
        chart = body['data']
        return {
            'sun_sign': chart['sunSign'],
            'moon_sign': chart['moonSign'],
            'ascendant': chart['ascendant']['sign'],
            'nakshatra': chart['nakshatra']
        }

    def match_charts(self, bride, groom):
        # Guna Milan takes the male chart first, the female chart second
        body = self.client.get_guna_milan(groom, bride)
        match = body['data']
        return {
            'score': match['total_points'],
            'max_score': match['maximum_points'],
            'verdict': match['match_result']
        }

    def get_dasha(self, birth_details):
        body = self.client.get_vimshottari_dasha(birth_details)
        current = body['data']['current_dasha']
        return {
            'current_mahadasha': current['maha_dasha']['planet'],
            'current_antardasha': current['antar_dasha']['planet']
        }

Error Handling

# app.py
from flask import Flask, jsonify
from vedika.exceptions import VedikaAPIError, RateLimitError

app = Flask(__name__)

@app.errorhandler(VedikaAPIError)
def handle_vedika_error(error):
    return jsonify({
        'error': error.message,
        'code': error.code
    }), error.status_code or 500

@app.errorhandler(RateLimitError)
def handle_rate_limit(error):
    return jsonify({
        'error': 'Rate limit exceeded',
        'retry_after': error.retry_after
    }), 429

@app.errorhandler(400)
def handle_bad_request(error):
    return jsonify({'error': 'Bad request'}), 400

@app.errorhandler(500)
def handle_server_error(error):
    return jsonify({'error': 'Internal server error'}), 500

Caching with Flask-Caching

# app.py
from flask import Flask, request, jsonify
from flask_caching import Cache
from vedika import VedikaClient

app = Flask(__name__)
vedika = VedikaClient()
cache = Cache(app, config={
    'CACHE_TYPE': 'redis',
    'CACHE_REDIS_URL': 'redis://localhost:6379/0'
})

@app.route('/api/panchang')
@cache.cached(timeout=3600, query_string=True)  # Cache 1 hour
def panchang():
    # This will be cached
    date = request.args.get('date')
    body = vedika.get_panchang(date=date, latitude=28.6139, longitude=77.2090, timezone='+05:30')
    return jsonify(body['data'])

Async with Quart

# quart_app.py
import asyncio
from quart import Quart, request, jsonify
from vedika import VedikaClient

app = Quart(__name__)
vedika = VedikaClient()

@app.route('/api/chart', methods=['POST'])
async def chart():
    data = await request.get_json()  # datetime, latitude, longitude, timezone
    # The SDK is synchronous, so run the call in a worker thread
    body = await asyncio.to_thread(
        vedika.request, 'POST', '/v2/astrology/birth-chart', json=data
    )
    return jsonify(body['data'])

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

Production Setup

# Install Gunicorn
pip install gunicorn

# Run with Gunicorn
gunicorn -w 4 -b 0.0.0.0:8000 app:app

# With environment variables
VEDIKA_API_KEY=vk_live_xxx gunicorn -w 4 app:app
# config.py
import os

class Config:
    VEDIKA_API_KEY = os.environ.get('VEDIKA_API_KEY')
    CACHE_TYPE = 'redis'
    CACHE_REDIS_URL = os.environ.get('REDIS_URL')

class ProductionConfig(Config):
    DEBUG = False

class DevelopmentConfig(Config):
    DEBUG = True

Next Steps