astroapi-python/src/astroapi/categories/vedic.py at main · astro-api/astroapi-python · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
"""Vedic astrology category client."""

from __future__ import annotations

from astroapi.categories.base import BaseCategoryClient
from astroapi.types.requests import (
    VedicCharaDashaRequest,
    VedicChartRequest,
    VedicDashaRequest,
    VedicDivisionalChartRequest,
    VedicFestivalRequest,
    VedicKPRequest,
    VedicKundliRequest,
    VedicPanchangRequest,
    VedicRegionalPanchangRequest,
    VedicRemediesRequest,
    VedicRequest,
    VedicSadeSatiRequest,
    VedicTransitRequest,
    VedicVarshaphalRequest,
    VedicYogaRequest,
)
from astroapi.types.responses import GenericResponse
from astroapi.utils.validators import validate_datetime_location, validate_subject


class VedicClient(BaseCategoryClient):
    """Client for Vedic astrology endpoints."""

    API_PREFIX = "/api/v3/vedic"

    def get_birth_details(self, request: VedicRequest) -> GenericResponse:
        """Get Vedic birth details."""
        validate_subject(request.subject)
        url = self._build_url("birth-details")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return GenericResponse(**data)

    def get_kundli_matching(self, request: VedicKundliRequest) -> GenericResponse:
        """Get Kundli matching."""
        validate_subject(request.groom)
        validate_subject(request.bride)
        url = self._build_url("kundli-matching")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return GenericResponse(**data)

    def get_manglik_dosha(self, request: VedicRequest) -> GenericResponse:
        """Get Manglik Dosha analysis."""
        validate_subject(request.subject)
        url = self._build_url("manglik-dosha")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return GenericResponse(**data)

    def get_divisional_chart(self, request: VedicDivisionalChartRequest) -> GenericResponse:
        """Get divisional charts."""
        validate_subject(request.subject)
        url = self._build_url("divisional-chart")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return GenericResponse(**data)

    def get_panchang(self, request: VedicPanchangRequest) -> GenericResponse:
        """Get Panchang."""
        validate_datetime_location(request.datetime_location)
        url = self._build_url("panchang")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return GenericResponse(**data)

    def get_remedies(self, request: VedicRemediesRequest) -> GenericResponse:
        """Get Vedic remedies."""
        validate_subject(request.subject)
        url = self._build_url("remedies")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return GenericResponse(**data)

    def get_vimshottari_dasha(self, request: VedicDashaRequest) -> GenericResponse:
        """Get Vimshottari Dasha."""
        validate_subject(request.subject)
        url = self._build_url("vimshottari-dasha")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return GenericResponse(**data)

    def get_sade_sati(self, request: VedicSadeSatiRequest) -> GenericResponse:
        """Get Sade Sati analysis."""
        validate_subject(request.subject)
        url = self._build_url("sade-sati")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return GenericResponse(**data)

    def get_kaal_sarpa_dosha(self, request: VedicRequest) -> GenericResponse:
        """Get Kaal Sarpa Dosha analysis."""
        validate_subject(request.subject)
        url = self._build_url("kaal-sarpa-dosha")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return GenericResponse(**data)

    def get_transit(self, request: VedicTransitRequest) -> GenericResponse:
        """Get Vedic transit analysis."""
        validate_subject(request.subject)
        url = self._build_url("transit")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return GenericResponse(**data)

    def get_nakshatra_predictions(self, request: VedicTransitRequest) -> GenericResponse:
        """Get Nakshatra predictions."""
        validate_subject(request.subject)
        url = self._build_url("nakshatra-predictions")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return GenericResponse(**data)

    def get_yogini_dasha(self, request: VedicDashaRequest) -> GenericResponse:
        """Get Yogini Dasha."""
        validate_subject(request.subject)
        url = self._build_url("yogini-dasha")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return GenericResponse(**data)

    def get_yoga_analysis(self, request: VedicYogaRequest) -> GenericResponse:
        """Analyze yogas (planetary combinations)."""
        validate_subject(request.subject)
        url = self._build_url("yoga-analysis")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return GenericResponse(**data)

    def get_ashtakvarga(self, request: VedicRequest) -> GenericResponse:
        """Calculate Ashtakvarga."""
        validate_subject(request.subject)
        url = self._build_url("ashtakvarga")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return GenericResponse(**data)

    def get_shadbala(self, request: VedicRequest) -> GenericResponse:
        """Calculate Shadbala (six-fold strength)."""
        validate_subject(request.subject)
        url = self._build_url("shadbala")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return GenericResponse(**data)

    def get_chara_dasha(self, request: VedicCharaDashaRequest) -> GenericResponse:
        """Calculate Chara Dasha."""
        validate_subject(request.subject)
        url = self._build_url("chara-dasha")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return GenericResponse(**data)

    def get_kp_system(self, request: VedicKPRequest) -> GenericResponse:
        """Calculate KP System."""
        validate_subject(request.subject)
        url = self._build_url("kp-system")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return GenericResponse(**data)

    def get_varshaphal(self, request: VedicVarshaphalRequest) -> GenericResponse:
        """Calculate Varshaphal (annual horoscope)."""
        validate_subject(request.subject)
        url = self._build_url("varshaphal")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return GenericResponse(**data)

    def get_festival_calendar(self, request: VedicFestivalRequest) -> GenericResponse:
        """Get festival calendar."""
        url = self._build_url("festival-calendar")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return GenericResponse(**data)

    def get_regional_panchang(self, request: VedicRegionalPanchangRequest) -> GenericResponse:
        """Get regional Panchang."""
        url = self._build_url("regional-panchang")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return GenericResponse(**data)

    def get_chart(self, request: VedicChartRequest) -> GenericResponse:
        """Generate Vedic chart SVG."""
        validate_subject(request.subject)
        url = self._build_url("chart")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return GenericResponse(**data)

    def render_chart(
        self, request: VedicChartRequest, output_format: str = "svg"
    ) -> GenericResponse:
        """Render Vedic chart in specified format."""
        validate_subject(request.subject)
        url = self._build_url("chart", "render", output_format)
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return GenericResponse(**data)