app.py

import gradio as gr
import swisseph as swe
from datetime import datetime, timedelta
from geopy.geocoders import Nominatim
import matplotlib.pyplot as plt
from matplotlib.patches import Rectangle
import numpy as np

# Initialize Swiss Ephemeris
swe.set_ephe_path('')

def get_coordinates(location_name):
    """Get latitude and longitude from location name."""
    try:
        geolocator = Nominatim(user_agent="rashi_chart_generator")
        location = geolocator.geocode(location_name)
        if location:
            return location.latitude, location.longitude, location.address
        else:
            return 28.6139, 77.2090, "New Delhi, India"
    except Exception as e:
        return 28.6139, 77.2090, "New Delhi, India"

def get_julian_day(date_str, lat, lon):
    """Calculate Julian Day for noon (12:00 PM)."""
    try:
        date_obj = datetime.strptime(date_str, "%Y-%m-%d")
        year = date_obj.year
        month = date_obj.month
        day = date_obj.day
        hour = 12.0
        jd = swe.julday(year, month, day, hour)
        return jd
    except Exception as e:
        print(f"Error calculating Julian Day: {e}")
        return None

def calculate_planet_positions(jd):
    """Calculate positions of all planets."""
    planets = {
        'Sun': swe.SUN,
        'Moon': swe.MOON,
        'Mars': swe.MARS,
        'Mercury': swe.MERCURY,
        'Jupiter': swe.JUPITER,
        'Venus': swe.VENUS,
        'Saturn': swe.SATURN,
        'Rahu': swe.MEAN_NODE,
    }
    positions = {}
    for planet_name, planet_id in planets.items():
        try:
            result = swe.calc_ut(jd, planet_id)
            longitude = result[0][0]
            positions[planet_name] = longitude
        except Exception as e:
            positions[planet_name] = 0.0
    positions['Ketu'] = (positions['Rahu'] + 180) % 360
    return positions

def calculate_moon_sign(birth_date, birth_location):
    """Calculate Moon sign (Rashi) from birth date."""
    lat, lon, address = get_coordinates(birth_location)
    jd = get_julian_day(birth_date, lat, lon)
    if jd is None:
        return None, None
    result = swe.calc_ut(jd, swe.MOON)
    moon_longitude = result[0][0]
    moon_rashi = int(moon_longitude / 30) + 1
    if moon_rashi > 12:
        moon_rashi = 12
    return moon_rashi, moon_longitude

def degree_to_rashi(degree):
    """Convert degree to Rashi number (1-12)."""
    rashi_num = int(degree / 30) + 1
    if rashi_num > 12:
        rashi_num = 12
    return rashi_num

def get_rashi_name(rashi_num):
    """Get Rashi name."""
    rashi_names = {
        1: 'Mesha', 2: 'Vrishabha', 3: 'Mithuna', 4: 'Karka',
        5: 'Simha', 6: 'Kanya', 7: 'Tula', 8: 'Vrishchika',
        9: 'Dhanu', 10: 'Makara', 11: 'Kumbha', 12: 'Meena'
    }
    return rashi_names.get(rashi_num, 'Unknown')

def organize_planets_by_house(positions, moon_rashi):
    """Organize current planets into houses relative to birth Moon sign."""
    house_planets = {i: [] for i in range(1, 13)}
    for planet, degree in positions.items():
        planet_rashi = degree_to_rashi(degree)
        house = ((planet_rashi - moon_rashi) % 12) + 1
        if house > 12:
            house = house - 12
        house_planets[house].append(planet)
    return house_planets

def get_short_planet_names(house_planets):
    """Convert to abbreviations."""
    short_names = {
        'Sun': 'Su', 'Moon': 'Mo', 'Mars': 'Ma', 'Mercury': 'Me',
        'Jupiter': 'Ju', 'Venus': 'Ve', 'Saturn': 'Sa',
        'Rahu': 'Ra', 'Ketu': 'Ke',
    }
    short_house_planets = {}
    for house, planets in house_planets.items():
        short_house_planets[house] = [short_names.get(p, p) for p in planets]
    return short_house_planets

def get_house_rashis(moon_rashi):
    """Get Rashi name for each house based on Moon sign."""
    house_rashis = {}
    for house in range(1, 13):
        rashi_num = ((moon_rashi + house - 2) % 12) + 1
        house_rashis[house] = get_rashi_name(rashi_num)
    return house_rashis

def draw_rashi_transit_chart(house_planets, house_rashis, birth_date, current_date, location, moon_rashi, save_path):
    """Draw square grid Rashi chart with current transits."""
    fig, ax = plt.subplots(1, 1, figsize=(12, 12))
    ax.set_xlim(0, 4)
    ax.set_ylim(0, 4)
    ax.set_aspect('equal')
    ax.axis('off')
    fig.patch.set_facecolor('#f5f5dc')
    
    moon_sign_name = get_rashi_name(moon_rashi)
    title_text = f"Rashi Chart (Moon Sign: {moon_sign_name})\n"
    title_text += f"Birth Date: {birth_date} | Current Date: {current_date}\n"
    title_text += f"Location: {location}"
    ax.text(2, 4.4, title_text, ha='center', va='top',
            fontsize=11, fontweight='bold', color='#8B4513')
    
    grid_layout = {
        12: (3,0), 1:(3,1), 2:(3,2), 3:(3,3),
        11:(2,0), 4:(2,3),
        10:(1,0), 5:(1,3),
        9:(0,0), 8:(0,1), 7:(0,2), 6:(0,3),
    }
    
    for house_num in range(1, 13):
        row, col = grid_layout[house_num]
        x = col
        y = 3 - row
        
        if house_num == 1:
            facecolor = '#FFE4B5'
            edgecolor = '#FF6347'
            linewidth = 3
        else:
            facecolor = '#FFFACD'
            edgecolor = '#8B4513'
            linewidth = 2
        
        rect = Rectangle((x, y), 1, 1, linewidth=linewidth,
                        edgecolor=edgecolor, facecolor=facecolor)
        ax.add_patch(rect)
        
        house_label = f"{house_num}"
        if house_num == 1:
            house_label += " (Lg)"
        ax.text(x + 0.08, y + 0.92, house_label,
                fontsize=9, ha='left', va='top',
                color='gray', fontweight='bold')
        
        rashi_name = house_rashis.get(house_num, '')
        ax.text(x + 0.5, y + 0.82, rashi_name,
                fontsize=9, ha='center', va='top',
                fontweight='bold', color='#006400')
        
        planets = house_planets.get(house_num, [])
        if planets:
            planet_text = '\n'.join(planets)
            ax.text(x + 0.5, y + 0.45, planet_text,
                    fontsize=11, ha='center', va='center',
                    color='red', fontweight='bold')
    
    center_text = f"RASI\n({moon_sign_name})"
    ax.text(2, 2, center_text, fontsize=16, ha='center', va='center',
            fontweight='bold', color='#8B4513')
    center_rect = Rectangle((1, 1), 2, 2, linewidth=2,
                            edgecolor='#8B4513', facecolor='#FFFACD',
                            linestyle='--')
    ax.add_patch(center_rect)
    
    legend_text = "Current Planetary Positions (Transit)\n"
    legend_text += "Su=Sun, Mo=Moon, Ma=Mars, Me=Mercury, Ju=Jupiter\n"
    legend_text += "Ve=Venus, Sa=Saturn, Ra=Rahu, Ke=Ketu\n"
    legend_text += "House 1 (Lg) = Lagna (Moon Sign at birth)"
    ax.text(2, -0.4, legend_text, ha='center', va='top',
            fontsize=8, style='italic', color='#8B4513',
            bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.3))
    
    plt.tight_layout()
    plt.savefig(save_path, dpi=300, bbox_inches='tight', facecolor='#f5f5dc')
    plt.close()
    return save_path

def generate_rashi_chart(birth_date, birth_location, transit_date=None):
    """Main function to generate Rashi chart."""
    if transit_date is None or transit_date == "":
        transit_date = datetime.now().strftime('%Y-%m-%d')
    
    moon_rashi, moon_longitude = calculate_moon_sign(birth_date, birth_location)
    if moon_rashi is None:
        return None, "Failed to calculate Moon sign. Please check your inputs."
    
    moon_sign_name = get_rashi_name(moon_rashi)
    lat, lon, full_address = get_coordinates(birth_location)
    jd = get_julian_day(transit_date, lat, lon)
    if jd is None:
        return None, "Failed to calculate Julian Day."
    
    current_positions = calculate_planet_positions(jd)
    house_planets = organize_planets_by_house(current_positions, moon_rashi)
    short_house_planets = get_short_planet_names(house_planets)
    house_rashis = get_house_rashis(moon_rashi)
    
    chart_filename = f"rashi_chart_{birth_date.replace('-', '_')}_{transit_date.replace('-', '_')}.png"
    chart_path = draw_rashi_transit_chart(short_house_planets, house_rashis, 
                                          birth_date, transit_date, full_address, 
                                          moon_rashi, chart_filename)
    
    report = f"""
## 🌙 RASHI CHART REPORT

### Birth Information
- **Moon Sign (Rashi):** {moon_sign_name} (Rashi {moon_rashi})
- **Moon Position:** {moon_longitude:.2f}°
- **Birth Date:** {birth_date}
- **Birth Location:** {full_address}

### Transit Information
- **Transit Date:** {transit_date}

### Current Planetary Positions

| Planet | Degree | Rashi | Sign |
|--------|--------|-------|------|
"""
    
    for planet, degree in current_positions.items():
        rashi = degree_to_rashi(degree)
        rashi_name = get_rashi_name(rashi)
        report += f"| {planet} | {degree:.2f}° | {rashi} | {rashi_name} |\n"
    
    report += "\n### House-wise Planet Distribution\n\n"
    
    for house in range(1, 13):
        planets = short_house_planets.get(house, [])
        rashi_name = house_rashis.get(house, '')
        planet_list = ', '.join(planets) if planets else 'Empty'
        house_label = f"House {house}"
        if house == 1:
            house_label += " (Lagna)"
        report += f"**{house_label}** ({rashi_name}): {planet_list}\n\n"
    
    return chart_path, report

def gradio_interface(birth_date, birth_location, transit_option, custom_transit_date, days_offset):
    """Gradio wrapper function."""
    try:
        if not birth_date:
            return None, "❌ Please enter your birth date."
        
        if not birth_location:
            return None, "❌ Please enter your birth location."
        
        if transit_option == "Today":
            transit_date = datetime.now().strftime('%Y-%m-%d')
        elif transit_option == "Tomorrow":
            transit_date = (datetime.now() + timedelta(days=1)).strftime('%Y-%m-%d')
        elif transit_option == "Custom Date":
            if not custom_transit_date:
                return None, "❌ Please enter a custom transit date."
            transit_date = custom_transit_date
        elif transit_option == "Days from Today":
            transit_date = (datetime.now() + timedelta(days=int(days_offset))).strftime('%Y-%m-%d')
        else:
            transit_date = datetime.now().strftime('%Y-%m-%d')
        
        chart_path, report = generate_rashi_chart(birth_date, birth_location, transit_date)
        return chart_path, report
    except Exception as e:
        return None, f"❌ Error: {str(e)}\n\nPlease check your inputs and try again."

def update_visibility(option):
    """Update visibility of date input fields."""
    return {
        custom_transit_date: gr.update(visible=(option == "Custom Date")),
        days_offset: gr.update(visible=(option == "Days from Today"))
    }

# Create Gradio Interface
with gr.Blocks(title="Vedic Rashi Chart Generator") as demo:
    gr.Markdown("""
    # 🌙 Vedic Rashi Chart Generator
    
    Generate your personalized Vedic astrology Rashi (Moon sign) chart with current planetary transits.
    
    
    """)
    
    with gr.Row():
        with gr.Column():
            birth_date = gr.Textbox(
                label="📅 Birth Date",
                placeholder="YYYY-MM-DD (e.g., 1995-08-15)",
                value=""
            )
            birth_location = gr.Textbox(
                label="📍 Birth Location",
                placeholder="e.g., Mumbai, India",
                value=""
            )
            
            gr.Markdown("### 🕐 Transit Date Options")
            transit_option = gr.Radio(
                choices=["Today", "Tomorrow", "Custom Date", "Days from Today"],
                value="Today",
                label="Select Transit Date Option"
            )
            
            custom_transit_date = gr.Textbox(
                label="Custom Transit Date",
                placeholder="YYYY-MM-DD",
                visible=False
            )
            
            days_offset = gr.Number(
                label="Days from Today",
                value=0,
                visible=False
            )
            
            generate_btn = gr.Button("✨ Generate Rashi Chart", variant="primary")
        
        with gr.Column():
            chart_output = gr.Image(label="📊 Rashi Chart", type="filepath")
            report_output = gr.Markdown(label="📋 Detailed Report")
    
    transit_option.change(
        update_visibility,
        inputs=[transit_option],
        outputs=[custom_transit_date, days_offset]
    )
    
    generate_btn.click(
        gradio_interface,
        inputs=[birth_date, birth_location, transit_option, custom_transit_date, days_offset],
        outputs=[chart_output, report_output]
    )

if __name__ == "__main__":
    demo.launch()