Upload 14 files

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+generated-icon.png filter=lfs diff=lfs merge=lfs -text
+seas_18.se1 filter=lfs diff=lfs merge=lfs -text
+semo_18.se1 filter=lfs diff=lfs merge=lfs -text
+sepl_18.se1 filter=lfs diff=lfs merge=lfs -text

Pasted-C-Configurar-o-caminho-para-os-arquivos-de-efem-rides-ajuste-conforme-necess-rio-swe-set-ephe-pa-1740106355605.txt

@@ -0,0 +1,185 @@
+C
+# Configurar o caminho para os arquivos de efemérides (ajuste conforme necessário)
+swe.set_ephe_path('/path/to/ephe')  # Substitua pelo caminho correto no seu sistema
+
+def download_ephe_files():
+    """Baixa e configura os arquivos de efemérides necessários."""
+    # Criar diretório para as efemérides se não existir
+    ephe_dir = Path("ephe")
+    ephe_dir.mkdir(exist_ok=True)
+    
+    # URL base do repositório
+    base_url = "https://raw.githubusercontent.com/aloistr/swisseph/master/ephe/"
+    
+    # Lista de arquivos essenciais
+    essential_files = [
+        "seas_18.se1",  # Arquivo principal do Sol
+        "semo_18.se1",  # Arquivo principal da Lua
+        "sepl_18.se1"   # Arquivo principal dos planetas
+    ]
+    
+    # Baixar arquivos
+    for filename in essential_files:
+        file_path = ephe_dir / filename
+        if not file_path.exists():
+            print(f"Baixando {filename}...")
+            try:
+                response = requests.get(f"{base_url}{filename}")
+                response.raise_for_status()
+                with open(file_path, "wb") as f:
+                    f.write(response.content)
+            except Exception as e:
+                print(f"Erro ao baixar {filename}: {e}")
+                return False
+    
+    # Configurar o caminho das efemérides
+    swe.set_ephe_path(str(ephe_dir))
+    return True
+
+# Funções auxiliares
+def get_timezone(cidade):
+    """Obtém latitude, longitude e fuso horário a partir do nome da cidade."""
+    geolocator = Nominatim(user_agent="astro_calculator")
+    location = geolocator.geocode(cidade)
+    if not location:
+        raise ValueError("Cidade não encontrada.")
+    lat, lon = location.latitude, location.longitude
+    tf = TimezoneFinder()
+    timezone_str = tf.timezone_at(lat=lat, lng=lon)
+    if not timezone_str:
+        raise ValueError("Fuso horário não encontrado para esta localização.")
+    return timezone_str, lat, lon
+
+def get_julian_day(data_str, hora_str, timezone_str):
+    """Converte data e hora local para Julian Day (UTC)."""
+    try:
+        # Parsear data e hora
+        dia, mes, ano = map(int, data_str.split('/'))
+        hora, minuto = map(int, hora_str.split(':'))
+        # Criar objeto datetime com fuso horário local
+        tz = pytz.timezone(timezone_str)
+        dt_local = tz.localize(datetime(ano, mes, dia, hora, minuto))
+        # Converter para UTC
+        dt_utc = dt_local.astimezone(pytz.UTC)
+        # Calcular Julian Day
+        return swe.utc_to_jd(dt_utc.year, dt_utc.month, dt_utc.day, 
+                            dt_utc.hour, dt_utc.minute, dt_utc.second, 
+                            swe.GREG_CAL)[1]
+    except Exception as e:
+        print(f"Erro ao converter data/hora: {e}")
+        return None
+
+def calcular_signo(graus):
+    """Converte uma posição em graus para o signo correspondente."""
+    signos = ["Áries", "Touro", "Gêmeos", "Câncer", "Leão", "Virgem", 
+              "Libra", "Escorpião", "Sagitário", "Capricórnio", "Aquário", "Peixes"]
+    grau_normalizado = graus % 360
+    indice = int(grau_normalizado // 30)
+    return signos[indice]
+
+def calcular_aspectos(posicoes):
+    """Calcula aspectos principais entre os planetas."""
+    aspectos = []
+    orbes = {"Conjunção": 8, "Oposição": 8, "Trígono": 6, "Quadrratura": 6, "Sextil": 4}
+    tipos_aspectos = {
+        0: "Conjunção", 60: "Sextil", 90: "Quadrratura", 120: "Trígono", 180: "Oposição"
+    }
+    
+    planetas_lista = list(posicoes.keys())
+    for i in range(len(planetas_lista)):
+        for j in range(i + 1, len(planetas_lista)):
+            p1, p2 = planetas_lista[i], planetas_lista[j]
+            grau1, grau2 = posicoes[p1]["graus"], posicoes[p2]["graus"]
+            diff = min((grau1 - grau2) % 360, (grau2 - grau1) % 360)
+            
+            for angulo, tipo in tipos_aspectos.items():
+                if abs(diff - angulo) <= orbes[tipo]:
+                    aspectos.append(f"{p1} em {tipo} com {p2} ({diff:.2f}°)")
+    
+    return aspectos
+
+# Programa principal
+def main():
+    print("Bem-vindo ao cálculo do Mapa Astral!")
+    
+    # Adicionar verificação e download dos arquivos de efemérides
+    print("Verificando arquivos de efemérides...")
+    if not download_ephe_files():
+        print("Erro ao configurar os arquivos de efemérides. O programa não pode continuar.")
+        return
+        
+    data_nascimento = input("Digite sua data de nascimento (dd/mm/aaaa): ")
+    hora_nascimento = input("Digite sua hora de nascimento (hh:mm): ")
+    cidade_nascimento = input("Digite a cidade e país de nascimento (ex.: São Paulo, Brasil): ")
+
+    try:
+        # Obter fuso horário e coordenadas
+        timezone, latitude, longitude = get_timezone(cidade_nascimento)
+        print(f"\nLocal: {cidade_nascimento} (Lat: {latitude:.4f}, Lon: {longitude:.4f})")
+        print(f"Fuso horário: {timezone}")
+
+        # Converter para Julian Day
+        julian_day = get_julian_day(data_nascimento, hora_nascimento, timezone)
+        if julian_day is None:
+            raise ValueError("Erro ao calcular o Julian Day.")
+
+        # Calcular posições planetárias e nodos
+        planetas = {
+            "Sol": swe.SUN, "Lua": swe.MOON, "Mercúrio": swe.MERCURY,
+            "Vênus": swe.VENUS, "Marte": swe.MARS, "Júpiter": swe.JUPITER,
+            "Saturno": swe.SATURN, "Urano": swe.URANUS, "Netuno": swe.NEPTUNE,
+            "Plutão": swe.PLUTO, "Nodo Norte": swe.MEAN_NODE
+        }
+        posicoes = {}
+        for nome, planeta in planetas.items():
+            resultado = swe.calc_ut(julian_day, planeta)
+            pos = resultado[0][0]  # Pegando apenas a longitude eclíptica
+            posicoes[nome] = {"graus": pos, "signo": calcular_signo(pos)}
+
+        # Nodo Sul é oposto ao Nodo Norte
+        nodo_sul_graus = (posicoes["Nodo Norte"]["graus"] + 180) % 360
+        posicoes["Nodo Sul"] = {"graus": nodo_sul_graus, "signo": calcular_signo(nodo_sul_graus)}
+
+        # Calcular Ascendente e casas
+        casas, aspectos_casas = swe.houses(julian_day, latitude, longitude, b'P')  # Placidus
+        ascendente = casas[0]
+        signo_ascendente = calcular_signo(ascendente)
+        meio_do_ceu = casas[9]
+        signo_mc = calcular_signo(meio_do_ceu)
+
+        # Calcular aspectos
+        aspectos = calcular_aspectos(posicoes)
+
+        # Exibir resultados
+        print("\n=== Mapa Astral ===")
+        print(f"Signo Solar: {posicoes['Sol']['signo']} ({posicoes['Sol']['graus']:.2f}°)")
+        print(f"Signo Lunar: {posicoes['Lua']['signo']} ({posicoes['Lua']['graus']:.2f}°)")
+        print(f"Ascendente: {signo_ascendente} ({ascendente:.2f}°)")
+        print(f"Meio do Céu: {signo_mc} ({meio_do_ceu:.2f}°)")
+
+        print("\n=== Outros Planetas ===")
+        for planeta, info in posicoes.items():
+            if planeta not in ["Sol", "Lua", "Nodo Norte", "Nodo Sul"]:
+                print(f"{planeta}: {info['signo']} ({info['graus']:.2f}°)")
+
+        print("\n=== Nodos Lunares ===")
+        print(f"Nodo Norte: {posicoes['Nodo Norte']['signo']} ({posicoes['Nodo Norte']['graus']:.2f}°)")
+        print(f"Nodo Sul: {posicoes['Nodo Sul']['signo']} ({posicoes['Nodo Sul']['graus']:.2f}°)")
+
+        print("\n=== Casas Astrológicas ===")
+        for i, casa in enumerate(casas[:12], 1):
+            signo_casa = calcular_signo(casa)
+            print(f"Casa {i}: {signo_casa} ({casa:.2f}°)")
+
+        print("\n=== Aspectos Principais ===")
+        if aspectos:
+            for aspecto in aspectos:
+                print(aspecto)
+        else:
+            print("Nenhum aspecto significativo encontrado.")
+
+    except Exception as e:
+        print(f"Erro: {e}")
+
+if __name__ == "__main__":
+    main()

Pasted-import-swisseph-as-swe-from-datetime-import-datetime-import-pytz-from-geopy-geocoders-import-Nominat-1740106507168.txt

@@ -0,0 +1,194 @@
+import swisseph as swe
+from datetime import datetime
+import pytz
+from geopy.geocoders import Nominatim
+from timezonefinder import TimezoneFinder
+import os
+import requests
+import zipfile
+from pathlib import Path
+
+# Configurar o caminho para os arquivos de efemérides (ajuste conforme necessário)
+swe.set_ephe_path('/path/to/ephe')  # Substitua pelo caminho correto no seu sistema
+
+def download_ephe_files():
+    """Baixa e configura os arquivos de efemérides necessários."""
+    # Criar diretório para as efemérides se não existir
+    ephe_dir = Path("ephe")
+    ephe_dir.mkdir(exist_ok=True)
+    
+    # URL base do repositório
+    base_url = "https://raw.githubusercontent.com/aloistr/swisseph/master/ephe/"
+    
+    # Lista de arquivos essenciais
+    essential_files = [
+        "seas_18.se1",  # Arquivo principal do Sol
+        "semo_18.se1",  # Arquivo principal da Lua
+        "sepl_18.se1"   # Arquivo principal dos planetas
+    ]
+    
+    # Baixar arquivos
+    for filename in essential_files:
+        file_path = ephe_dir / filename
+        if not file_path.exists():
+            print(f"Baixando {filename}...")
+            try:
+                response = requests.get(f"{base_url}{filename}")
+                response.raise_for_status()
+                with open(file_path, "wb") as f:
+                    f.write(response.content)
+            except Exception as e:
+                print(f"Erro ao baixar {filename}: {e}")
+                return False
+    
+    # Configurar o caminho das efemérides
+    swe.set_ephe_path(str(ephe_dir))
+    return True
+
+# Funções auxiliares
+def get_timezone(cidade):
+    """Obtém latitude, longitude e fuso horário a partir do nome da cidade."""
+    geolocator = Nominatim(user_agent="astro_calculator")
+    location = geolocator.geocode(cidade)
+    if not location:
+        raise ValueError("Cidade não encontrada.")
+    lat, lon = location.latitude, location.longitude
+    tf = TimezoneFinder()
+    timezone_str = tf.timezone_at(lat=lat, lng=lon)
+    if not timezone_str:
+        raise ValueError("Fuso horário não encontrado para esta localização.")
+    return timezone_str, lat, lon
+
+def get_julian_day(data_str, hora_str, timezone_str):
+    """Converte data e hora local para Julian Day (UTC)."""
+    try:
+        # Parsear data e hora
+        dia, mes, ano = map(int, data_str.split('/'))
+        hora, minuto = map(int, hora_str.split(':'))
+        # Criar objeto datetime com fuso horário local
+        tz = pytz.timezone(timezone_str)
+        dt_local = tz.localize(datetime(ano, mes, dia, hora, minuto))
+        # Converter para UTC
+        dt_utc = dt_local.astimezone(pytz.UTC)
+        # Calcular Julian Day
+        return swe.utc_to_jd(dt_utc.year, dt_utc.month, dt_utc.day, 
+                            dt_utc.hour, dt_utc.minute, dt_utc.second, 
+                            swe.GREG_CAL)[1]
+    except Exception as e:
+        print(f"Erro ao converter data/hora: {e}")
+        return None
+
+def calcular_signo(graus):
+    """Converte uma posição em graus para o signo correspondente."""
+    signos = ["Áries", "Touro", "Gêmeos", "Câncer", "Leão", "Virgem", 
+              "Libra", "Escorpião", "Sagitário", "Capricórnio", "Aquário", "Peixes"]
+    grau_normalizado = graus % 360
+    indice = int(grau_normalizado // 30)
+    return signos[indice]
+
+def calcular_aspectos(posicoes):
+    """Calcula aspectos principais entre os planetas."""
+    aspectos = []
+    orbes = {"Conjunção": 8, "Oposição": 8, "Trígono": 6, "Quadrratura": 6, "Sextil": 4}
+    tipos_aspectos = {
+        0: "Conjunção", 60: "Sextil", 90: "Quadrratura", 120: "Trígono", 180: "Oposição"
+    }
+    
+    planetas_lista = list(posicoes.keys())
+    for i in range(len(planetas_lista)):
+        for j in range(i + 1, len(planetas_lista)):
+            p1, p2 = planetas_lista[i], planetas_lista[j]
+            grau1, grau2 = posicoes[p1]["graus"], posicoes[p2]["graus"]
+            diff = min((grau1 - grau2) % 360, (grau2 - grau1) % 360)
+            
+            for angulo, tipo in tipos_aspectos.items():
+                if abs(diff - angulo) <= orbes[tipo]:
+                    aspectos.append(f"{p1} em {tipo} com {p2} ({diff:.2f}°)")
+    
+    return aspectos
+
+# Programa principal
+def main():
+    print("Bem-vindo ao cálculo do Mapa Astral!")
+    
+    # Adicionar verificação e download dos arquivos de efemérides
+    print("Verificando arquivos de efemérides...")
+    if not download_ephe_files():
+        print("Erro ao configurar os arquivos de efemérides. O programa não pode continuar.")
+        return
+        
+    data_nascimento = input("Digite sua data de nascimento (dd/mm/aaaa): ")
+    hora_nascimento = input("Digite sua hora de nascimento (hh:mm): ")
+    cidade_nascimento = input("Digite a cidade e país de nascimento (ex.: São Paulo, Brasil): ")
+
+    try:
+        # Obter fuso horário e coordenadas
+        timezone, latitude, longitude = get_timezone(cidade_nascimento)
+        print(f"\nLocal: {cidade_nascimento} (Lat: {latitude:.4f}, Lon: {longitude:.4f})")
+        print(f"Fuso horário: {timezone}")
+
+        # Converter para Julian Day
+        julian_day = get_julian_day(data_nascimento, hora_nascimento, timezone)
+        if julian_day is None:
+            raise ValueError("Erro ao calcular o Julian Day.")
+
+        # Calcular posições planetárias e nodos
+        planetas = {
+            "Sol": swe.SUN, "Lua": swe.MOON, "Mercúrio": swe.MERCURY,
+            "Vênus": swe.VENUS, "Marte": swe.MARS, "Júpiter": swe.JUPITER,
+            "Saturno": swe.SATURN, "Urano": swe.URANUS, "Netuno": swe.NEPTUNE,
+            "Plutão": swe.PLUTO, "Nodo Norte": swe.MEAN_NODE
+        }
+        posicoes = {}
+        for nome, planeta in planetas.items():
+            resultado = swe.calc_ut(julian_day, planeta)
+            pos = resultado[0][0]  # Pegando apenas a longitude eclíptica
+            posicoes[nome] = {"graus": pos, "signo": calcular_signo(pos)}
+
+        # Nodo Sul é oposto ao Nodo Norte
+        nodo_sul_graus = (posicoes["Nodo Norte"]["graus"] + 180) % 360
+        posicoes["Nodo Sul"] = {"graus": nodo_sul_graus, "signo": calcular_signo(nodo_sul_graus)}
+
+        # Calcular Ascendente e casas
+        casas, aspectos_casas = swe.houses(julian_day, latitude, longitude, b'P')  # Placidus
+        ascendente = casas[0]
+        signo_ascendente = calcular_signo(ascendente)
+        meio_do_ceu = casas[9]
+        signo_mc = calcular_signo(meio_do_ceu)
+
+        # Calcular aspectos
+        aspectos = calcular_aspectos(posicoes)
+
+        # Exibir resultados
+        print("\n=== Mapa Astral ===")
+        print(f"Signo Solar: {posicoes['Sol']['signo']} ({posicoes['Sol']['graus']:.2f}°)")
+        print(f"Signo Lunar: {posicoes['Lua']['signo']} ({posicoes['Lua']['graus']:.2f}°)")
+        print(f"Ascendente: {signo_ascendente} ({ascendente:.2f}°)")
+        print(f"Meio do Céu: {signo_mc} ({meio_do_ceu:.2f}°)")
+
+        print("\n=== Outros Planetas ===")
+        for planeta, info in posicoes.items():
+            if planeta not in ["Sol", "Lua", "Nodo Norte", "Nodo Sul"]:
+                print(f"{planeta}: {info['signo']} ({info['graus']:.2f}°)")
+
+        print("\n=== Nodos Lunares ===")
+        print(f"Nodo Norte: {posicoes['Nodo Norte']['signo']} ({posicoes['Nodo Norte']['graus']:.2f}°)")
+        print(f"Nodo Sul: {posicoes['Nodo Sul']['signo']} ({posicoes['Nodo Sul']['graus']:.2f}°)")
+
+        print("\n=== Casas Astrológicas ===")
+        for i, casa in enumerate(casas[:12], 1):
+            signo_casa = calcular_signo(casa)
+            print(f"Casa {i}: {signo_casa} ({casa:.2f}°)")
+
+        print("\n=== Aspectos Principais ===")
+        if aspectos:
+            for aspecto in aspectos:
+                print(aspecto)
+        else:
+            print("Nenhum aspecto significativo encontrado.")
+
+    except Exception as e:
+        print(f"Erro: {e}")
+
+if __name__ == "__main__":
+    main()

app.py

@@ -0,0 +1,216 @@
+import streamlit as st
+import datetime
+from utils import (
+    download_ephe_files, get_location_data, calculate_julian_day,
+    get_planet_positions, calculate_houses
+)
+from chart_generator import create_wheel_chart, PLANET_NAMES
+
+# Zodiac sign symbols and names
+ZODIAC_SYMBOLS = {
+    "Aries": "♈",
+    "Taurus": "♉",
+    "Gemini": "♊",
+    "Cancer": "♋",
+    "Leo": "♌",
+    "Virgo": "♍",
+    "Libra": "♎",
+    "Scorpio": "♏",
+    "Sagittarius": "♐",
+    "Capricorn": "♑",
+    "Aquarius": "♒",
+    "Pisces": "♓"
+}
+
+def calcular_signo(longitude):
+    signo = ""
+    if 0 <= longitude < 30:
+        signo = "Aries"
+    elif 30 <= longitude < 60:
+        signo = "Taurus"
+    elif 60 <= longitude < 90:
+        signo = "Gemini"
+    elif 90 <= longitude < 120:
+        signo = "Cancer"
+    elif 120 <= longitude < 150:
+        signo = "Leo"
+    elif 150 <= longitude < 180:
+        signo = "Virgo"
+    elif 180 <= longitude < 210:
+        signo = "Libra"
+    elif 210 <= longitude < 240:
+        signo = "Scorpio"
+    elif 240 <= longitude < 270:
+        signo = "Sagittarius"
+    elif 270 <= longitude < 300:
+        signo = "Capricorn"
+    elif 300 <= longitude < 330:
+        signo = "Aquarius"
+    elif 330 <= longitude < 360:
+        signo = "Pisces"
+    return signo
+
+# Configuração da página
+st.set_page_config(
+    page_title="Visualizador de Mapa Astral",
+    page_icon="🌟",
+    layout="centered"
+)
+
+# Carregar CSS personalizado
+with open("styles/custom.css") as f:
+    st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
+
+# Inicializar arquivos de efemérides
+if not download_ephe_files():
+    st.error("Falha ao inicializar dados astronômicos. Por favor, tente novamente.")
+    st.stop()
+
+# Título e descrição
+st.markdown("""
+<div style='text-align: center; padding: 2rem 0;'>
+    <h1 class='glow-text'>✨ Visualizador de Mapa Astral ✨</h1>
+</div>
+""", unsafe_allow_html=True)
+
+st.markdown("""
+<div class='cosmic-card'>
+    <p style='text-align: center; font-size: 1.2rem;'>
+        Descubra seu mapa astral através deste visualizador interativo.<br>
+        Insira seus dados de nascimento abaixo para revelar as posições celestiais no momento do seu nascimento.
+    </p>
+</div>
+""", unsafe_allow_html=True)
+
+# Formulário de entrada
+st.markdown("<div class='cosmic-card'>", unsafe_allow_html=True)
+if st.viewport_width < 768:
+    # Layout em uma coluna para dispositivos móveis
+    birth_date = st.date_input(
+        "Data de Nascimento",
+        min_value=datetime.date(1900, 1, 1),
+        max_value=datetime.date.today(),
+        help="Selecione sua data de nascimento"
+    )
+    
+    birth_time = st.time_input(
+        "Hora de Nascimento",
+        help="Insira o horário mais preciso possível"
+    )
+    
+    birth_place = st.text_input(
+        "Local de Nascimento",
+        placeholder="Ex: São Paulo, Brasil",
+        help="Digite a cidade e país de nascimento"
+    )
+else:
+    # Layout em três colunas para desktop
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        birth_date = st.date_input(
+            "Data de Nascimento",
+            min_value=datetime.date(1900, 1, 1),
+            max_value=datetime.date.today(),
+            help="Selecione sua data de nascimento"
+        )
+    
+    with col2:
+        birth_time = st.time_input(
+            "Hora de Nascimento",
+            help="Insira o horário mais preciso possível"
+        )
+    
+    with col3:
+        birth_place = st.text_input(
+            "Local de Nascimento",
+            placeholder="Ex: São Paulo, Brasil",
+            help="Digite a cidade e país de nascimento"
+        )
+
+if st.button("✨ Gerar Mapa Astral ✨", key="generate"):
+    try:
+        with st.spinner("🌟 Calculando posições celestiais..."):
+            location_data = get_location_data(birth_place)
+            jd = calculate_julian_day(birth_date, birth_time, location_data['timezone'])
+            planet_positions = get_planet_positions(jd)
+            houses = calculate_houses(
+                jd,
+                location_data['latitude'],
+                location_data['longitude']
+            )
+
+            # Calcular signo solar
+            signo_solar = calcular_signo(planet_positions['Sun']['longitude'])
+            simbolo_solar = ZODIAC_SYMBOLS[signo_solar]
+
+            st.markdown("<div style='text-align: center;'><h2 class='glow-text'>Seu Mapa Astral</h2></div>", unsafe_allow_html=True)
+
+            # Ajuste do layout responsivo para o resultado
+            if st.viewport_width < 768:
+                # Layout em uma coluna para mobile
+                st.markdown(f"""
+                <div class='cosmic-card signo-solar-card'>
+                    <div class='signo-symbol'>{simbolo_solar}</div>
+                    <h2 class='signo-nome'>{signo_solar}</h2>
+                    <p class='signo-grau'>{planet_positions['Sun']['longitude']:.2f}°</p>
+                </div>
+                """, unsafe_allow_html=True)
+                
+                st.markdown("<div class='chart-container'>", unsafe_allow_html=True)
+                fig = create_wheel_chart(planet_positions, houses)
+                st.plotly_chart(fig, use_container_width=True)
+                st.markdown("</div>", unsafe_allow_html=True)
+                
+                st.markdown("<div class='cosmic-card'>", unsafe_allow_html=True)
+                st.markdown("<h3>🌍 Posições Planetárias</h3>", unsafe_allow_html=True)
+                for planet, data in planet_positions.items():
+                    planet_name = PLANET_NAMES.get(planet, planet)  # Usar nome traduzido
+                    st.write(f"✨ {planet_name}: {data['longitude']:.2f}°")
+
+                st.markdown("<h3>🏠 Cúspides das Casas</h3>", unsafe_allow_html=True)
+                for i, cusp in enumerate(houses['cusps'], 1):
+                    st.write(f"Casa {i}: {cusp:.2f}°")
+                st.markdown("</div>", unsafe_allow_html=True)
+
+                st.markdown("<div class='cosmic-card'>", unsafe_allow_html=True)
+                st.markdown("<h3>🌟 Pontos Importantes</h3>", unsafe_allow_html=True)
+                st.write(f"⭐ Ascendente: {houses['ascendant']:.2f}°")
+                st.write(f"🌠 Meio do Céu: {houses['mc']:.2f}°")
+                st.markdown("</div>", unsafe_allow_html=True)
+            else:
+                # Layout em duas colunas para desktop
+                chart_col, info_col = st.columns([2, 1])
+
+                with chart_col:
+                    st.markdown("<div class='chart-container'>", unsafe_allow_html=True)
+                    fig = create_wheel_chart(planet_positions, houses)
+                    st.plotly_chart(fig, use_container_width=True)
+                    st.markdown("</div>", unsafe_allow_html=True)
+
+                with info_col:
+                    st.markdown("<div class='cosmic-card'>", unsafe_allow_html=True)
+                    st.markdown("<h3>🌍 Posições Planetárias</h3>", unsafe_allow_html=True)
+                    for planet, data in planet_positions.items():
+                        planet_name = PLANET_NAMES.get(planet, planet)  # Usar nome traduzido
+                        st.write(f"✨ {planet_name}: {data['longitude']:.2f}°")
+
+                    st.markdown("<h3>🏠 Cúspides das Casas</h3>", unsafe_allow_html=True)
+                    for i, cusp in enumerate(houses['cusps'], 1):
+                        st.write(f"Casa {i}: {cusp:.2f}°")
+                    st.markdown("</div>", unsafe_allow_html=True)
+
+                    st.markdown("<div class='cosmic-card'>", unsafe_allow_html=True)
+                    st.markdown("<h3>🌟 Pontos Importantes</h3>", unsafe_allow_html=True)
+                    st.write(f"⭐ Ascendente: {houses['ascendant']:.2f}°")
+                    st.write(f"🌠 Meio do Céu: {houses['mc']:.2f}°")
+                    st.markdown("</div>", unsafe_allow_html=True)
+
+    except Exception as e:
+        st.error(f"Ocorreu um erro: {str(e)}")
+
+# Rodapé
+st.markdown("""
+<div class='cosmic-card' style='text-align: center; margin-top: 2rem;'>
+    <p>Feito com ✨ e energia cósmica</p>
+</div>
+""", unsafe_allow_html=True)

chart_generator.py

@@ -0,0 +1,193 @@
+import plotly.graph_objects as go
+import numpy as np
+
+THEME_COLORS = {
+    'dark': {
+        'background': 'rgba(28, 28, 28, 0.95)',
+        'primary': '#9C27B0',
+        'accent': '#FF4081',
+        'text': '#FFFFFF',
+        'grid': 'rgba(156, 39, 176, 0.2)',
+        'line': 'rgba(156, 39, 176, 0.5)'
+    },
+    'light': {
+        'background': 'rgba(255, 255, 255, 0.95)',
+        'primary': '#7B1FA2',
+        'accent': '#E91E63',
+        'text': '#333333',
+        'grid': 'rgba(123, 31, 162, 0.2)',
+        'line': 'rgba(123, 31, 162, 0.5)'
+    }
+}
+
+# Dicionário de tradução para os nomes dos planetas
+PLANET_NAMES = {
+    'Sun': 'Sol',
+    'Moon': 'Lua',
+    'Mercury': 'Mercúrio',
+    'Venus': 'Vênus',
+    'Mars': 'Marte',
+    'Jupiter': 'Júpiter',
+    'Saturn': 'Saturno',
+    'Uranus': 'Urano',
+    'Neptune': 'Netuno',
+    'Pluto': 'Plutão'
+}
+
+# Dicionário de símbolos dos signos
+ZODIAC_SYMBOLS = {
+    "Áries": "♈",
+    "Touro": "♉",
+    "Gêmeos": "♊",
+    "Câncer": "♋",
+    "Leão": "♌",
+    "Virgem": "♍",
+    "Libra": "♎",
+    "Escorpião": "♏",
+    "Sagitário": "♐",
+    "Capricórnio": "♑",
+    "Aquário": "♒",
+    "Peixes": "♓"
+}
+
+def calcular_signo(graus):
+    """Converte uma posição em graus para o signo correspondente."""
+    signos = ["Áries", "Touro", "Gêmeos", "Câncer", "Leão", "Virgem", 
+              "Libra", "Escorpião", "Sagitário", "Capricórnio", "Aquário", "Peixes"]
+    grau_normalizado = graus % 360
+    indice = int(grau_normalizado // 30)
+    return signos[indice]
+
+def create_wheel_chart(planet_positions, houses, theme='dark'):
+    """Gera um gráfico interativo do mapa astral usando Plotly."""
+    colors = THEME_COLORS[theme]
+
+    # Criar o círculo base
+    theta = np.linspace(0, 2*np.pi, 360)
+    r = np.ones_like(theta)
+
+    # Criar a figura
+    fig = go.Figure()
+
+    # Adicionar o círculo principal
+    fig.add_trace(go.Scatterpolar(
+        r=r,
+        theta=np.degrees(theta),
+        mode='lines',
+        line=dict(color=colors['primary'], width=2),
+        showlegend=False,
+        fill='toself',
+        fillcolor=colors['background']
+    ))
+
+    # Adicionar linhas das casas
+    for house in houses['cusps']:
+        angle = house
+        fig.add_trace(go.Scatterpolar(
+            r=[0, 1],
+            theta=[angle, angle],
+            mode='lines',
+            line=dict(color=colors['line'], width=1),
+            showlegend=False
+        ))
+
+    # Adicionar o signo solar com destaque
+    sun_longitude = planet_positions['Sun']['longitude']
+    sun_sign = calcular_signo(sun_longitude)
+    fig.add_trace(go.Scatterpolar(
+        r=[0.9],
+        theta=[sun_longitude],
+        mode='text',
+        text=[f"{sun_sign} {ZODIAC_SYMBOLS[sun_sign]}"],
+        textposition="middle center",
+        textfont=dict(
+            color=colors['text'],
+            size=24,
+            family="Arial"
+        ),
+        showlegend=False
+    ))
+
+
+    # Adicionar planetas
+    for planet, data in planet_positions.items():
+        if planet != 'Sun': #Avoid duplicating Sun
+            planet_name = PLANET_NAMES.get(planet, planet)  # Usar nome traduzido
+            fig.add_trace(go.Scatterpolar(
+                r=[0.8],
+                theta=[data['longitude']],
+                mode='markers+text',
+                name=planet_name,
+                text=[planet_name],
+                textposition="top center",
+                textfont=dict(
+                    color=colors['text'],
+                    size=16,  # Aumentado o tamanho da fonte
+                    family="Arial"  # Fonte mais legível
+                ),
+                marker=dict(
+                    size=18,  # Aumentado o tamanho do marcador
+                    color=colors['accent'],
+                    symbol='star',
+                    line=dict(
+                        color=colors['text'],
+                        width=1
+                    )
+                ),
+                showlegend=True
+            ))
+
+    # Atualizar layout
+    fig.update_layout(
+        polar=dict(
+            radialaxis=dict(
+                visible=False,
+                range=[0, 1]
+            ),
+            angularaxis=dict(
+                direction="clockwise",
+                period=360,
+                rotation=90,
+                tickmode='array',
+                ticktext=['♈', '♉', '♊', '♋', '♌', '♍', '♎', '♏', '♐', '♑', '♒', '♓'],
+                tickvals=np.arange(0, 360, 30),
+                tickfont=dict(
+                    size=24,  # Aumentado o tamanho dos símbolos zodiacais
+                    color=colors['text']
+                ),
+                gridcolor=colors['grid'],
+                linecolor=colors['line']
+            ),
+            bgcolor=colors['background']
+        ),
+        paper_bgcolor='rgba(0,0,0,0)',
+        plot_bgcolor='rgba(0,0,0,0)',
+        showlegend=True,
+        legend=dict(
+            bgcolor=colors['background'],
+            bordercolor=colors['primary'],
+            borderwidth=1,
+            font=dict(
+                color=colors['text'],
+                size=14,
+                family="Arial"
+            ),
+            itemsizing='constant',
+            yanchor="top",
+            y=0.99,
+            xanchor="left",
+            x=1.1,
+            title=dict(
+                text="Planetas",
+                font=dict(
+                    size=16,
+                    family="Arial",
+                    color=colors['text']
+                )
+            )
+        ),
+        margin=dict(l=20, r=120, t=20, b=20),  # Ajustado para acomodar a legenda
+        height=800
+    )
+
+    return fig

custom.css

@@ -0,0 +1,237 @@
+/* Custom styling for the mystical theme */
+.stApp {
+    background: linear-gradient(135deg, #1a1a1a 0%, #2d1a2f 100%);
+    font-family: 'Poppins', sans-serif;
+    letter-spacing: 0.02em;
+    line-height: 1.6;
+}
+
+/* Card styling */
+.cosmic-card {
+    background: rgba(28, 28, 28, 0.95);
+    border: 1px solid rgba(156, 39, 176, 0.3);
+    border-radius: 15px;
+    padding: 25px;
+    box-shadow: 0 0 20px rgba(156, 39, 176, 0.2);
+    transition: all 0.3s ease;
+    margin-bottom: 20px;
+}
+
+.cosmic-card:hover {
+    box-shadow: 0 0 30px rgba(156, 39, 176, 0.4);
+    transform: translateY(-2px);
+}
+
+/* Text styling */
+.glow-text {
+    color: #FF4081;
+    text-shadow: 0 0 10px rgba(255, 64, 129, 0.5);
+    font-size: 2.5rem;
+    font-weight: 600;
+    text-align: center;
+    margin-bottom: 30px;
+}
+
+h1, h2, h3 {
+    color: #FFFFFF;
+    margin-bottom: 20px;
+    font-weight: 600;
+}
+
+p, li {
+    color: #E0E0E0;
+    font-size: 1.1rem;
+    line-height: 1.8;
+}
+
+/* Chart container styling */
+.chart-container {
+    border-radius: 50%;
+    box-shadow: 0 0 30px rgba(156, 39, 176, 0.3);
+    padding: 20px;
+    background: rgba(28, 28, 28, 0.8);
+    transition: all 0.3s ease;
+}
+
+.chart-container:hover {
+    box-shadow: 0 0 40px rgba(156, 39, 176, 0.5);
+}
+
+/* Form inputs styling */
+.stTextInput > div > div, .stDateInput > div > div, .stTimeInput > div > div {
+    background: rgba(40, 40, 40, 0.9) !important;
+    border: 1px solid rgba(156, 39, 176, 0.5) !important;
+    border-radius: 8px !important;
+    color: #FFFFFF !important;
+    font-size: 1.1rem !important;
+    transition: all 0.3s ease;
+}
+
+.stTextInput > div > div:focus-within, 
+.stDateInput > div > div:focus-within, 
+.stTimeInput > div > div:focus-within {
+    border-color: #FF4081 !important;
+    box-shadow: 0 0 10px rgba(255, 64, 129, 0.3) !important;
+}
+
+/* Button styling */
+.stButton > button {
+    background: linear-gradient(135deg, #9C27B0 0%, #FF4081 100%) !important;
+    color: white !important;
+    border: none !important;
+    padding: 12px 30px !important;
+    border-radius: 8px !important;
+    font-size: 1.1rem !important;
+    font-weight: 600 !important;
+    letter-spacing: 0.05em !important;
+    transition: all 0.3s ease !important;
+    text-transform: uppercase;
+}
+
+.stButton > button:hover {
+    transform: translateY(-2px) !important;
+    box-shadow: 0 5px 15px rgba(156, 39, 176, 0.4) !important;
+}
+
+.stButton > button:active {
+    transform: translateY(1px) !important;
+}
+
+/* Labels and text inputs */
+.stTextInput label, .stDateInput label, .stTimeInput label {
+    color: #FFFFFF !important;
+    font-size: 1.1rem !important;
+    font-weight: 500 !important;
+    margin-bottom: 8px !important;
+}
+
+/* Loading spinner */
+.stSpinner > div {
+    border-color: #FF4081 !important;
+}
+
+/* Error messages */
+.stAlert {
+    background: rgba(244, 67, 54, 0.1) !important;
+    border-color: rgba(244, 67, 54, 0.5) !important;
+    color: #FFFFFF !important;
+}
+
+/* Success messages */
+.stSuccess {
+    background: rgba(76, 175, 80, 0.1) !important;
+    border-color: rgba(76, 175, 80, 0.5) !important;
+    color: #FFFFFF !important;
+}
+
+/* Estilo especial para o card do signo solar */
+.signo-solar-card {
+    background: linear-gradient(135deg, rgba(156, 39, 176, 0.2) 0%, rgba(255, 64, 129, 0.2) 100%);
+    text-align: center;
+    padding: 2rem;
+    margin-bottom: 2rem;
+    border: 2px solid rgba(156, 39, 176, 0.5);
+    transform: translateY(0);
+    transition: all 0.3s ease;
+}
+
+.signo-solar-card:hover {
+    transform: translateY(-5px);
+    box-shadow: 0 10px 30px rgba(156, 39, 176, 0.3);
+}
+
+.signo-symbol {
+    font-size: 4rem;
+    color: #FF4081;
+    text-shadow: 0 0 20px rgba(255, 64, 129, 0.5);
+    margin-bottom: 1rem;
+    animation: float 3s ease-in-out infinite;
+}
+
+.signo-nome {
+    font-size: 2.5rem;
+    color: #FFFFFF;
+    margin: 1rem 0;
+    font-weight: 600;
+    letter-spacing: 0.1em;
+}
+
+.signo-grau {
+    font-size: 1.2rem;
+    color: #E0E0E0;
+    font-family: 'Courier New', monospace;
+}
+
+@keyframes float {
+    0% {
+        transform: translateY(0px);
+    }
+    50% {
+        transform: translateY(-10px);
+    }
+    100% {
+        transform: translateY(0px);
+    }
+}
+
+/* Media Queries para Responsividade */
+@media screen and (max-width: 768px) {
+    .glow-text {
+        font-size: 1.8rem;
+    }
+
+    .cosmic-card {
+        padding: 15px;
+        margin-bottom: 15px;
+    }
+
+    .signo-symbol {
+        font-size: 3rem;
+    }
+
+    .signo-nome {
+        font-size: 2rem;
+    }
+
+    .chart-container {
+        padding: 10px;
+    }
+
+    .stButton > button {
+        padding: 10px 20px !important;
+        font-size: 1rem !important;
+    }
+}
+
+@media screen and (max-width: 480px) {
+    .glow-text {
+        font-size: 1.5rem;
+    }
+
+    .cosmic-card {
+        padding: 10px;
+        margin-bottom: 10px;
+    }
+
+    p, li {
+        font-size: 1rem;
+    }
+
+    .signo-symbol {
+        font-size: 2.5rem;
+    }
+
+    .signo-nome {
+        font-size: 1.8rem;
+    }
+
+    .signo-grau {
+        font-size: 1rem;
+    }
+
+    .stTextInput > div > div, 
+    .stDateInput > div > div, 
+    .stTimeInput > div > div {
+        font-size: 1rem !important;
+    }
+}

pyproject.toml

@@ -0,0 +1,17 @@
+[project]
+name = "repl-nix-workspace"
+version = "0.1.0"
+description = "Add your description here"
+requires-python = ">=3.11"
+dependencies = [
+    "geopy>=2.4.1",
+    "numpy>=2.2.3",
+    "plotly>=6.0.0",
+    "pyswisseph>=2.10.3.2",
+    "pytz>=2025.1",
+    "requests>=2.32.3",
+    "streamlit>=1.42.2",
+    "swisseph>=0.0.0.dev1",
+    "timezonefinder>=6.5.8",
+    "trafilatura>=2.0.0",
+]

requirements.txt

@@ -0,0 +1,9 @@
+streamlit==1.42.2
+geopy
+numpy
+plotly
+pyswisseph
+pytz
+requests
+swisseph
+timezonefinder 

seas_18.se1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5fd9c2aa1654e37c09a6aeb558076e795409b7dc4bd948ebc0faa7d4a7686b5b
+size 223002

semo_18.se1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ecfa54dbf5bc0b5a9bc3e04ed28629a821e98625eacae38f4070593bba0e2980
+size 1304771

sepl_18.se1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0b7e416e3c1be9e6a0dd1d711dae7f7685793a0e7df13f76363a493dc27b6ea1
+size 484055

streamlit.service

@@ -0,0 +1,12 @@
+[Unit]
+Description=Streamlit Mapa Astral
+After=network.target
+
+[Service]
+User=root
+WorkingDirectory=/var/www/mapa-astral
+Environment="PATH=/var/www/mapa-astral/venv/bin"
+ExecStart=/var/www/mapa-astral/venv/bin/streamlit run app.py --server.port=8501 --server.address=0.0.0.0
+
+[Install]
+WantedBy=multi-user.target

utils.py

@@ -0,0 +1,97 @@
+import swisseph as swe
+from datetime import datetime
+import pytz
+from geopy.geocoders import Nominatim
+from timezonefinder import TimezoneFinder
+import requests
+from pathlib import Path
+
+def download_ephe_files():
+    """Download and configure ephemeris files."""
+    ephe_dir = Path("ephe")
+    ephe_dir.mkdir(exist_ok=True)
+    
+    base_url = "https://raw.githubusercontent.com/aloistr/swisseph/master/ephe/"
+    essential_files = ["seas_18.se1", "semo_18.se1", "sepl_18.se1"]
+    
+    for filename in essential_files:
+        file_path = ephe_dir / filename
+        if not file_path.exists():
+            try:
+                response = requests.get(f"{base_url}{filename}")
+                response.raise_for_status()
+                with open(file_path, "wb") as f:
+                    f.write(response.content)
+            except Exception:
+                return False
+    
+    swe.set_ephe_path(str(ephe_dir))
+    return True
+
+def get_location_data(location_string):
+    """Get coordinates and timezone for a location."""
+    geolocator = Nominatim(user_agent="mystical_chart")
+    location = geolocator.geocode(location_string)
+    if not location:
+        raise ValueError("Location not found")
+    
+    tf = TimezoneFinder()
+    timezone_str = tf.timezone_at(lat=location.latitude, lng=location.longitude)
+    
+    return {
+        'latitude': location.latitude,
+        'longitude': location.longitude,
+        'timezone': timezone_str
+    }
+
+def calculate_julian_day(date, time, timezone_str):
+    """Calculate Julian Day from date and time."""
+    tz = pytz.timezone(timezone_str)
+    datetime_obj = datetime.combine(date, time)
+    local_dt = tz.localize(datetime_obj)
+    utc_dt = local_dt.astimezone(pytz.UTC)
+    
+    jd = swe.utc_to_jd(
+        utc_dt.year, utc_dt.month, utc_dt.day,
+        utc_dt.hour, utc_dt.minute, utc_dt.second,
+        swe.GREG_CAL
+    )[1]
+    
+    return jd
+
+def get_planet_positions(jd):
+    """Calculate positions for all planets."""
+    planets = {
+        "Sun": swe.SUN,
+        "Moon": swe.MOON,
+        "Mercury": swe.MERCURY,
+        "Venus": swe.VENUS,
+        "Mars": swe.MARS,
+        "Jupiter": swe.JUPITER,
+        "Saturn": swe.SATURN,
+        "Uranus": swe.URANUS,
+        "Neptune": swe.NEPTUNE,
+        "Pluto": swe.PLUTO
+    }
+    
+    positions = {}
+    for name, planet_id in planets.items():
+        result = swe.calc_ut(jd, planet_id)
+        positions[name] = {
+            'longitude': result[0][0],
+            'latitude': result[0][1],
+            'distance': result[0][2]
+        }
+    
+    return positions
+
+def calculate_houses(jd, lat, lon):
+    """Calculate house cusps using Placidus system."""
+    houses, angles = swe.houses(jd, lat, lon, b'P')
+    return {
+        'cusps': houses,
+        'ascendant': angles[0],
+        'mc': angles[1],
+        'armc': angles[2],
+        'vertex': angles[3]
+    }