from skyfield import almanac, api
from skyfield.api import utc


def calcular_fase_lunar(fecha):
    """Calcula la fase lunar para una fecha deseada.
    
    Parameters
    ----------
    fecha : ~datetime.datetime
        Fecha como objeto `datetime`.
        
    Returns
    -------
    fase_lunar : float
        Fase lunar en radianes.
        
    Notas
    -----
    La fase lunar es un ángulo, siendo su valor 0 [rad] 
    para la Luna nueva y pi [rad] para Luna llena.
        
    """
    # Cargamos la escala temporal y la tabla de efemérides
    tabla_tiempos = api.load.timescale()
    tabla_efemerides = api.load("de421.bsp")

    # Convertimos la fecha datetime a un datetime que entiende skyfield
    fecha_skyfield = tabla_tiempos.from_datetime(fecha.replace(tzinfo=utc))

    # Calculamos la fase lunar en radianes. Nos aseguramos de que sea un `float`
    fase_lunar = float(almanac.moon_phase(tabla_efemerides, fecha_skyfield).radians)
    return fase_lunar

import numpy as np


def calcular_iluminacion_disco(fecha):
    """Calcula el porcentaje de iluminación del disco lunar para una fecha.
    
    Parameters
    ----------
    fecha : ~datetime.datetime
        Fecha como objecto `datetime`.
        
    Returns
    -------
    iluminacion_disco : float
        Porcenatje de iluminación del disco lunar.
        
    Notas
    -----
    Para la Luna nueva, el valor de iluminación es de 0 unidades mientras
    que para Luna llena es de 100 unidades.
        
    """
    # Calculamos la fase lunar
    fase_lunar = calcular_fase_lunar(fecha)

    # Aplicamos la fórmula tomada del libro de Vallado
    iluminacion_disco = 100 * (1 - np.cos(fase_lunar)) / 2
    return iluminacion_disco

from datetime import datetime


# Declaramos la fecha y calculamos la fase e iluminación
fecha = datetime(2022, 4, 16)
fase_lunar, iluminacion_disco = calcular_fase_lunar(fecha), calcular_iluminacion_disco(fecha)

# Mostramos los resultados
print(f"Para el {fecha}, las propiedades lunares fueron:")
print(f"Fase Lunar = {np.rad2deg(fase_lunar):.2f} [deg]\nIlum. Disco = {iluminacion_disco:.2f} %")

from calendar import monthrange


def calcular_dias_en_mes(mes, año):
    """Calcula el número de un mes en un año determinado.

    Parameters
    ----------
    mes : int
        Número del mes.
    año : int
        Número del año.
        
    Returns
    -------
    dias : int
        Número de días en el mes.

    """
    _, dias = monthrange(año, mes)
    return dias

# Calculamos el número de días de Febrero, 2024
dias_en_febrero_2024 = calcular_dias_en_mes(2, 2024)
print(f"Febrero del año 2024 tiene {dias_en_febrero_2024} días.")

def calcular_propiedades_lunares(año):
    """Calcula la fase e iluminación para cada día de un año deseado.
    
    Parameters
    ----------
    año : int
        Año deseado.
        
    Yields
    ------
    propiedades : list
        Fecha completa, fase e iluminación.
    
    """
    # Todos los años tienen 12 meses
    for mes in range(1, 12+1):
        for dia in range(1, calcular_dias_en_mes(mes, año)+1):
            # Ensamblamos la fecha y calculamos las propiedades
            fecha = datetime(año, mes, dia)
            fase_lunar, iluminacion_disco = calcular_fase_lunar(fecha), calcular_iluminacion_disco(fecha)
            yield fecha, fase_lunar, iluminacion_disco

# Guardamos el generador y consumimos los primeros tres elementos para no alargar el post
propiedades_lunares_2022 = calcular_propiedades_lunares(2022)
for _ in range(3):
    fecha, fase_lunar, iluminacion_disco = next(propiedades_lunares_2022)
    print(
        f"Fecha = {fecha:%Y-%m-%d}  Fase Lunar = {np.rad2deg(fase_lunar):6.2f} [deg]  Ilum.Disco = {iluminacion_disco:.2f} %"
    )

from PIL import Image


def generar_imagenes_fases_lunares():
    """Genera todas las imágenes para cada fase lunar a partir del imagen matriz."""
    
    with Image.open("img/moon_phases.png") as imagen_matriz:
        
        # Calculamos las dimensiones de cada sub-imagen
        ancho, alto = imagen_matriz.size
        delta_ancho, delta_alto = ancho / 7, alto / 4

        # Iteramos para cada fase lunar de la matriz 
        dia = 0
        for n_fila in range(4):
            for n_columna in range(7):
                
                # Buscamos la esquina superior izquierda de cada sub-imagen
                x0, y0 = delta_ancho * n_columna, delta_alto * n_fila
                
                # La posición final del recorte es el inicio de la siguiente sub-imagen
                ancho_recorte = delta_ancho * (n_columna + 1)
                alto_recorte = delta_alto * (n_fila + 1)
                
                # Recortamos la región rectangular deseada y la guardamos como una imagen nueva.
                # Es importante guardar el dia de vida en el nombre del archivo.
                dimension_recorte = (x0, y0, ancho_recorte, alto_recorte)
                imagen_recorte = imagen_matriz.crop(dimension_recorte)
                imagen_recorte.save(f"img/luna_{dia}.png")
                
                # Incrementamos el contador de dias de vida de la Luna
                dia += 1
                
def calcular_imagen_fase_lunar(fase_lunar):
    """Devuelva la ruta de la imagen para la fase lunar deseada.
    
    Parameters
    ----------
    fase_lunar : float
        Fase lunar en radianes.
        
    Returns
    -------
    ruta_imagen_fase_lunar : str
        Ruta a la imagen de la fase lunar.
    
    """

    # Dado que la imagen matriz de fases lunares no comienza con una Luna nueva
    # aplicamos una corrección para acomodar la fase lunar con la sub-imagen que
    # le corresponde.
    dias_vida_luna = int(np.round(fase_lunar / (2 * np.pi) * 27 + 14, 0)) % 27
    ruta_imagen_fase_lunar = f"img/luna_{dias_vida_luna}.png"
    return ruta_imagen_fase_lunar

# Declaramos la fecha y calculamos la fase e iluminación
fecha = datetime(2022, 4, 16)
fase_lunar = calcular_fase_lunar(fecha)

# Generamos todas las sub-imágenes y resolvemos la ruta de la imagen
generar_imagenes_fases_lunares()
ruta_imagen_fase_lunar = calcular_imagen_fase_lunar(fase_lunar)
print(ruta_imagen_fase_lunar)

# Mostramos la imagen con Pillow
pil_im = Image.open(ruta_imagen_fase_lunar, 'r')
pil_im

<!DOCTYPE html>
<html>
  <head>
    <body>
      <h1 align="center">Calendario Lunar {{ anyo }}</h1>
      <div align="center">
        <table style="text-align: center;">

        <!-- Creamos la cabecera de la tabla -->
        <tr>
          <!-- Cabecera de los días -->
        <th>Day</th>
          <!-- Cabecera del mes -->
          {% for nombre_mes in lista_meses %}
            <th style="font-weight: bold; padding: 30px;">{{ nombre_mes[:3] }}</th>
          {% endfor %}
        </tr>

        <!-- Resolvemos la fase lunar y la imagen para cada fecha del año -->
        {% for dia in range(1, 32) %}
          <tr>
            <!-- Escribimos el numero del día en la columna de los días -->
            <td style="margin-right: 10px;">{{ dia }}</td>

            <!-- Calculamos la fase lunar para cada mes ese día -->
            {% for mes in range(1, 13) %}
                {% set dias_en_mes = calcular_dias_en_mes(mes, anyo) %}
                <!-- Rellenamos solo si el día existe para ese mes -->
                {% if dia < dias_en_mes + 1 %}
                  {% set fecha = datetime(anyo, mes, dia) %}
                  {% set fase_lunar = calcular_fase_lunar(fecha) %}
                  {% set imagen_fase_lunar = calcular_imagen_fase_lunar(fase_lunar) %}
                  <td style="padding: 5px;">
                        <img src="{{ imagen_fase_lunar }}">
                  </td>
                {% else %}
                  <!-- Si el mes tiene menos días no rellenamos nada -->
                  <td></td>
                {% endif %}

             {% endfor %}
           </tr>
         {% endfor %}

      </table>
    </div>
  </body>
</html>

import calendar
from datetime import datetime
import os
from pathlib import Path

from jinja2 import Template


MESES_DEL_ANYO = calendar.month_name[1:]
"""Lista con los nombres de todos los meses del año."""


def renderizar_calendario(anyo):
    """Renderiza la plantilla del calendario para el año deseado.
    
    Parameters
    ----------
    anyo : int
        Año deseado del calendario lunar.

    """

    # Make sure the year is integer and positive
    if anyo < 0:
        raise ValueError("Al año debe de ser positivo!")

    # Collect all variables
    variables = dict(
        anyo=anyo,
        lista_meses=MESES_DEL_ANYO,
        calcular_dias_en_mes=calcular_dias_en_mes,
        calcular_fase_lunar=calcular_fase_lunar,
        calcular_imagen_fase_lunar=calcular_imagen_fase_lunar,
        datetime=datetime,
    )

    # Open the template
    with open("res/plantilla_calendario.html", "r") as archivo_plantilla_calendario:

        # Render the template
        plantilla_calendario = archivo_plantilla_calendario.read()
        calendario_renderizado = Template(plantilla_calendario).render(variables)

        # Write the baked template to a new file
        with open(f"calendario_{anyo}.html", "w") as archivo_calendario:
            for linea in calendario_renderizado:
                archivo_calendario.write(linea)

# Calculamos el año actual y generamos el calendario
anyo = datetime.now().year
renderizar_calendario(anyo)