solarmoonpy 1.0.6__tar.gz → 1.0.8__tar.gz

{solarmoonpy-1.0.6 → solarmoonpy-1.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solarmoonpy
-Version: 1.0.6
+Version: 1.0.8
 Summary: Precise solar and lunar calculations for astronomical applications
 Author-email: figorr <jdcuartero@yahoo.es>
 License:                                  Apache License

{solarmoonpy-1.0.6 → solarmoonpy-1.0.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "solarmoonpy"
-version = "1.0.6"
+version = "1.0.8"
 description = "Precise solar and lunar calculations for astronomical applications"
 readme = "README.md"
 authors = [{ name = "figorr", email = "jdcuartero@yahoo.es" }]

{solarmoonpy-1.0.6 → solarmoonpy-1.0.8}/solarmoonpy/location.py

@@ -1,9 +1,9 @@
 from dataclasses import dataclass
 from datetime import date, datetime, timezone
 from zoneinfo import ZoneInfo
-from typing import Optional, Union, Literal
+from typing import Optional, Union, Literal, Dict
 
-from .sun import sunrise_sunset, noon, dawn, dusk, midnight  # Importar funciones de sun.py
+from .sun import sunrise_sunset, noon, dawn, dusk, midnight, sun_position  # Importar funciones de sun.py
 
 @dataclass
 class LocationInfo:
@@ -257,57 +257,6 @@ class Location:
             date=date,
             timezone=self.tzinfo if local else timezone.utc
         )
-
-    def sun_events(
-        self,
-        date: Optional[date] = None,
-        local: bool = True,
-        elevation: Optional[float] = None
-    ) -> dict:
-        """
-        Devuelve un diccionario con sunrise, noon y sunset para una fecha dada.
-
-        Args:
-            date: Fecha para la cual calcular los eventos solares. Si es None, usa la fecha actual.
-            local: True para devolver las horas en la zona horaria local, False para UTC.
-            elevation: Elevación del observador en metros. Si es None, usa self.elevation.
-
-        Returns:
-            dict: {
-                "sunrise": datetime,
-                "noon": datetime,
-                "sunset": datetime
-            }
-        """
-        if local and self.timezone is None:
-            raise ValueError("Se solicitó hora local pero no se definió una zona horaria.")
-
-        tz = self.tzinfo if local else timezone.utc
-        date = date or datetime.now(tz).date()
-        elevation = elevation if elevation is not None else self.elevation
-
-        # Calcular amanecer y atardecer
-        sunrise, sunset = sunrise_sunset(
-            latitude=self.latitude,
-            longitude=self.longitude,
-            date=date,
-            elevation=elevation,
-            timezone=tz,
-            with_refraction=True,
-        )
-
-        # Calcular mediodía solar
-        noon_time = noon(
-            longitude=self.longitude,
-            date=date,
-            timezone=tz,
-        )
-
-        return {
-            "sunrise": sunrise,
-            "noon": noon_time,
-            "sunset": sunset,
-        }
     
     def dawn(
         self,
@@ -372,4 +321,180 @@ class Location:
             longitude=self.longitude,
             date=date,
             timezone=self.tzinfo if local else timezone.utc
-        )
+        )
+    
+    def sun_position(
+        self,
+        dt: Optional[datetime] = None,
+        local: bool = True,
+        elevation: Optional[float] = None
+    ) -> dict:
+        """
+        Calcula la posición actual del Sol.
+
+        Args:
+            dt: Momento exacto. Si None, usa ahora.
+            local: True para usar zona horaria local.
+            elevation: Elevación del observador.
+
+        Returns:
+            dict: elevation, azimuth, above_horizon, rising
+        """
+        if local and self.timezone is None:
+            raise ValueError("Se solicitó hora local pero no se definió una zona horaria.")
+
+        tz = self.tzinfo if local else timezone.utc
+        dt = dt or datetime.now(tz)
+        elevation = elevation if elevation is not None else self.elevation
+
+        return sun_position(
+            latitude=self.latitude,
+            longitude=self.longitude,
+            dt=dt,
+            elevation=elevation,
+            timezone=tz,
+            with_refraction=True
+        )
+    
+    def sun_events(
+        self,
+        date: Optional[date] = None,
+        local: bool = True,
+        elevation: Optional[float] = None,
+    ) -> Dict:
+        """
+        Devuelve un diccionario con los eventos solares para una fecha dada, incluyendo todos los tipos de crepúsculo.
+
+        Args:
+            date: Fecha para la cual calcular los eventos solares. Si es None, usa la fecha actual.
+            local: True para devolver las horas en la zona horaria local, False para UTC.
+            elevation: Elevación del observador en metros. Si es None, usa self.elevation.
+
+        Returns:
+            dict: {
+                "dawn_civil": datetime | None,
+                "dawn_nautical": datetime | None,
+                "dawn_astronomical": datetime | None,
+                "sunrise": datetime,
+                "noon": datetime,
+                "sunset": datetime,
+                "dusk_civil": datetime | None,
+                "dusk_nautical": datetime | None,
+                "dusk_astronomical": datetime | None,
+                "midnight": datetime,
+                "daylight_duration": float | None
+            }
+        """
+        if local and self.timezone is None:
+            raise ValueError("Se solicitó hora local pero no se definió una zona horaria.")
+
+        tz = self.tzinfo if local else timezone.utc
+        now = datetime.now(tz)
+        date = date or now.date()
+        elevation = elevation if elevation is not None else self.elevation
+
+        # Calcular amanecer y atardecer
+        sunrise, sunset = sunrise_sunset(
+            latitude=self.latitude,
+            longitude=self.longitude,
+            date=date,
+            elevation=elevation,
+            timezone=tz,
+            with_refraction=True,
+        )
+
+        # Calcular mediodía solar
+        noon_time = noon(
+            longitude=self.longitude,
+            date=date,
+            timezone=tz,
+        )
+
+        # Calcular medianoche solar
+        midnight_time = midnight(
+            longitude=self.longitude,
+            date=date,
+            timezone=tz,
+        )
+
+        # Calcular duración del día (en horas)
+        daylight_duration = None
+        if sunrise and sunset:
+            daylight_duration = (sunset - sunrise).total_seconds() / 3600
+
+        # Calcular dawn y dusk para cada tipo de crepúsculo
+        dawn_civil = dawn(
+            latitude=self.latitude,
+            longitude=self.longitude,
+            date=date,
+            twilight_type="civil",
+            elevation=elevation,
+            timezone=tz,
+            with_refraction=True,
+        )
+        dusk_civil = dusk(
+            latitude=self.latitude,
+            longitude=self.longitude,
+            date=date,
+            twilight_type="civil",
+            elevation=elevation,
+            timezone=tz,
+            with_refraction=True,
+        )
+        dawn_nautical = dawn(
+            latitude=self.latitude,
+            longitude=self.longitude,
+            date=date,
+            twilight_type="nautical",
+            elevation=elevation,
+            timezone=tz,
+            with_refraction=True,
+        )
+        dusk_nautical = dusk(
+            latitude=self.latitude,
+            longitude=self.longitude,
+            date=date,
+            twilight_type="nautical",
+            elevation=elevation,
+            timezone=tz,
+            with_refraction=True,
+        )
+        dawn_astronomical = dawn(
+            latitude=self.latitude,
+            longitude=self.longitude,
+            date=date,
+            twilight_type="astronomical",
+            elevation=elevation,
+            timezone=tz,
+            with_refraction=True,
+        )
+        dusk_astronomical = dusk(
+            latitude=self.latitude,
+            longitude=self.longitude,
+            date=date,
+            twilight_type="astronomical",
+            elevation=elevation,
+            timezone=tz,
+            with_refraction=True,
+        )
+
+        # Posición actual del Sol
+        pos = self.sun_position(dt=now, local=local, elevation=elevation)
+
+        return {
+            "dawn_civil": dawn_civil,
+            "dawn_nautical": dawn_nautical,
+            "dawn_astronomical": dawn_astronomical,
+            "sunrise": sunrise,
+            "noon": noon_time,
+            "sunset": sunset,
+            "dusk_civil": dusk_civil,
+            "dusk_nautical": dusk_nautical,
+            "dusk_astronomical": dusk_astronomical,
+            "midnight": midnight_time,
+            "daylight_duration": daylight_duration,
+            "sun_elevation": pos["elevation"],
+            "sun_azimuth": pos["azimuth"],
+            "sun_horizon_position": pos["horizon_position"],
+            "sun_rising": pos["rising"],
+        }

{solarmoonpy-1.0.6 → solarmoonpy-1.0.8}/solarmoonpy/sun.py

@@ -333,6 +333,86 @@ def midnight(
     noon_time = noon(longitude, date, timezone)
     return noon_time + datetime.timedelta(hours=12)
 
+def sun_position(
+    latitude: float,
+    longitude: float,
+    dt: datetime.datetime,
+    elevation: float = 0.0,
+    timezone: datetime.timezone = datetime.timezone.utc,
+    with_refraction: bool = True
+) -> dict:
+    """
+    Calcula la posición del Sol con alta precisión.
+    """
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone)
+    dt_utc = dt.astimezone(datetime.timezone.utc)
+
+    jd = julianday(dt_utc)
+    jc = julianday_to_juliancentury(jd)
+    declination = sun_declination(jc)
+    eqtime = eq_of_time(jc)
+
+    # Tiempo solar verdadero en minutos desde medianoche
+    true_solar_time = (
+        dt_utc.hour * 60 + dt_utc.minute + dt_utc.second / 60.0
+        + eqtime + 4.0 * longitude
+    )
+
+    # Ángulo horario
+    hour_angle = (true_solar_time / 4.0) - 180.0
+    if hour_angle < -180:
+        hour_angle += 360
+    elif hour_angle > 180:
+        hour_angle -= 360
+
+    # Convertir a radianes
+    ha_rad = radians(hour_angle)
+    lat_rad = radians(latitude)
+    dec_rad = radians(declination)
+
+    # Elevación geométrica
+    sin_elev = sin(lat_rad) * sin(dec_rad) + cos(lat_rad) * cos(dec_rad) * cos(ha_rad)
+    elevation_geom = degrees(asin(max(min(sin_elev, 1.0), -1.0)))
+
+    # Corrección por altura del observador
+    elevation_adj = elevation_geom + adjust_to_horizon(elevation)
+
+    # Refracción atmosférica
+    if with_refraction and -10 <= elevation_adj <= 90:
+        refraction = refraction_at_zenith(90.0 - elevation_adj)
+        elevation_final = elevation_adj + refraction
+    else:
+        elevation_final = elevation_adj
+
+    # Azimut (0° = Norte)
+    sin_elev_final = sin(radians(elevation_final))
+    cos_elev_final = cos(radians(elevation_final))
+    cos_lat = cos(lat_rad)
+    sin_lat = sin(lat_rad)
+    sin_dec = sin(dec_rad)
+
+    if abs(cos_elev_final * cos_lat) < 1e-12:
+        azimuth = 180.0 if ha_rad < 0 else 0.0
+    else:
+        cos_az = (sin_dec - sin_elev_final * sin_lat) / (cos_elev_final * cos_lat)
+        cos_az = max(min(cos_az, 1.0), -1.0)
+        azimuth = degrees(acos(cos_az))
+        if hour_angle > 0:  # PM
+            azimuth = 360.0 - azimuth
+
+    horizon_position: Literal["above_horizon", "below_horizon"] = (
+        "above_horizon" if elevation_final > 0 else "below_horizon"
+    )
+    rising = elevation_final > 0 and hour_angle < 0
+
+    return {
+        "elevation": round(elevation_final, 2),
+        "azimuth": round(azimuth, 2),
+        "horizon_position": horizon_position,
+        "rising": rising
+    }
+
 # 🎁 FUNCIÓN BONUS: Todo junto (opcional)
 def all_sun_events(
     latitude: float, longitude: float, date: datetime.date,

solarmoonpy-1.0.8/solarmoonpy/version.py

@@ -0,0 +1,2 @@
+# version.py
+__version__ = "1.0.8"

{solarmoonpy-1.0.6 → solarmoonpy-1.0.8}/solarmoonpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solarmoonpy
-Version: 1.0.6
+Version: 1.0.8
 Summary: Precise solar and lunar calculations for astronomical applications
 Author-email: figorr <jdcuartero@yahoo.es>
 License:                                  Apache License

solarmoonpy-1.0.6/solarmoonpy/version.py

@@ -1,2 +0,0 @@
-# version.py
-__version__ = "1.0.6"