voshod-solnca APIvoshod-solnca.ru ↗

"""
Ekadashi Fasting Calendar API Client

Retrieve Ekadashi fasting schedules and upcoming fasting dates for cities across Russia.
Get your API key from: https://parse.bot/settings
"""

import os
import requests
from typing import Optional, Dict, Any, List
from dataclasses import dataclass
from datetime import datetime


@dataclass
class EkadashiInfo:
    """Structured representation of Ekadashi fasting information."""
    city: str
    ekadashi_date: str
    day_of_week: str
    fast_start_time: str
    fast_end_date: str
    fast_end_window_start: str
    fast_end_window_end: str
    raw_info: str
    upcoming_ekadashi: List[Dict[str, str]]

    def __str__(self) -> str:
        return (
            f"🕉️ Ekadashi Fasting Schedule for {self.city.title()}\n"
            f"{'─' * 50}\n"
            f"Next Ekadashi: {self.ekadashi_date} ({self.day_of_week})\n"
            f"Fast Begins: {self.fast_start_time}\n"
            f"Fast Ends: {self.fast_end_date}\n"
            f"Break Fast Window: {self.fast_end_window_start} - {self.fast_end_window_end}\n"
            f"Upcoming Events: {len(self.upcoming_ekadashi)} scheduled"
        )


class ParseClient:
    """Client for the Ekadashi Fasting Calendar API."""

    def __init__(self, api_key: Optional[str] = None):
        """
        Initialize the Parse API client.

        Args:
            api_key: API key for authentication. If not provided, reads from PARSE_API_KEY env var.
        """
        self.base_url = "https://api.parse.bot"
        self.scraper_id = "9af620de-ce55-4245-82c0-1973a1148805"
        self.api_key = api_key or os.getenv("PARSE_API_KEY")

        if not self.api_key:
            raise ValueError(
                "API key not provided. Set PARSE_API_KEY environment variable or pass api_key parameter."
            )

    def _call(
        self, endpoint: str, method: str = "POST", **params
    ) -> Dict[str, Any]:
        """
        Make an API call to the Parse service.

        Args:
            endpoint: The endpoint name (e.g., 'get_next_ekadashi')
            method: HTTP method ('GET' or 'POST')
            **params: Query/body parameters

        Returns:
            Parsed JSON response as dictionary

        Raises:
            requests.RequestException: If the API call fails
        """
        url = f"{self.base_url}/scraper/{self.scraper_id}/{endpoint}"
        headers = {
            "X-API-Key": self.api_key,
            "Content-Type": "application/json",
        }

        try:
            if method.upper() == "GET":
                response = requests.get(url, headers=headers, params=params)
            else:
                response = requests.post(url, headers=headers, json=params)

            response.raise_for_status()
            return response.json()
        except requests.RequestException as e:
            print(f"API Error: {e}")
            raise

    def get_next_ekadashi(self, city: str) -> EkadashiInfo:
        """
        Get the next Ekadashi fasting day and upcoming calendar for a city.

        Args:
            city: City name in Russian (e.g., 'москва', 'санкт-петербург', 'алматы')

        Returns:
            EkadashiInfo object with structured fasting schedule data

        Example:
            >>> client = ParseClient()
            >>> info = client.get_next_ekadashi('москва')
            >>> print(info)
        """
        result = self._call("get_next_ekadashi", method="GET", city=city)

        return EkadashiInfo(
            city=result.get("city", city),
            ekadashi_date=result.get("ekadashi_date", ""),
            day_of_week=result.get("day_of_week", ""),
            fast_start_time=result.get("fast_start_time", ""),
            fast_end_date=result.get("fast_end_date", ""),
            fast_end_window_start=result.get("fast_end_window_start", ""),
            fast_end_window_end=result.get("fast_end_window_end", ""),
            raw_info=result.get("raw_info", ""),
            upcoming_ekadashi=result.get("upcoming_ekadashi", []),
        )


def main():
    """Demonstrate practical usage of the Ekadashi Fasting Calendar API."""

    # Initialize the client (API key from environment)
    client = ParseClient()

    # List of major Russian cities to check Ekadashi schedules
    cities = ["москва", "санкт-петербург", "алматы"]

    print("=" * 60)
    print("🕉️  EKADASHI FASTING CALENDAR - MULTI-CITY LOOKUP")
    print("=" * 60)
    print()

    # Collect all Ekadashi data for comparison
    ekadashi_data: Dict[str, EkadashiInfo] = {}

    for city in cities:
        try:
            print(f"📍 Fetching Ekadashi schedule for {city.title()}...")
            ekadashi_info = client.get_next_ekadashi(city)
            ekadashi_data[city] = ekadashi_info

            # Display the formatted information
            print(ekadashi_info)
            print()

        except Exception as e:
            print(f"❌ Failed to fetch data for {city}: {e}")
            print()

    # Analyze and compare across cities
    if ekadashi_data:
        print("=" * 60)
        print("📊 COMPARATIVE ANALYSIS")
        print("=" * 60)
        print()

        # Show earliest Ekadashi across all cities
        earliest_city = None
        earliest_date = None

        for city, info in ekadashi_data.items():
            try:
                # Parse date in Russian format (e.g., "11 июня 2026")
                date_str = info.ekadashi_date.split()[0]
                if earliest_date is None or int(date_str) < int(earliest_date):
                    earliest_date = date_str
                    earliest_city = city
            except (ValueError, IndexError):
                continue

        if earliest_city:
            print(f"⏰ Earliest upcoming Ekadashi: {earliest_city.title()}")
            print(
                f"   Date: {ekadashi_data[earliest_city].ekadashi_date}"
            )
            print(
                f"   Fast begins at: {ekadashi_data[earliest_city].fast_start_time}"
            )
            print()

        # Show upcoming schedule for first city (detailed)
        first_city = list(ekadashi_data.keys())[0]
        upcoming = ekadashi_data[first_city].upcoming_ekadashi

        if upcoming:
            print(f"📅 Upcoming Ekadashi events for {first_city.title()}:")
            print(f"   Total scheduled: {len(upcoming)} fasting days")
            print()

            for i, event in enumerate(upcoming[:5], 1):
                date = event.get("date", "N/A")
                day = event.get("day_of_week", "N/A")
                start = event.get("fast_start_time", "N/A")
                sunrise = event.get("sunrise", "N/A")
                print(
                    f"   {i}. {date} ({day}) - Start: {start}, Sunrise: {sunrise}"
                )

            if len(upcoming) > 5:
                print(f"   ... and {len(upcoming) - 5} more events")

        print()
        print("=" * 60)


if __name__ == "__main__":
    main()