kerykeion 5.1.9__py3-none-any.whl → 5.1.12__py3-none-any.whl

kerykeion/aspects/aspects_factory.py

@@ -330,12 +330,25 @@ class AspectsFactory:
                     first_planet_id = planet_id_lookup.get(first_name, 0)
                     second_planet_id = planet_id_lookup.get(second_name, 0)
 
-                    # Calculate aspect movement (applying/separating/exact)
-                    aspect_movement = calculate_aspect_movement(
-                        active_points_list[first]["abs_pos"],
-                        active_points_list[second]["abs_pos"],
-                        aspect["aspect_degrees"]
-                    )
+                    # Determine aspect movement.
+                    # If both points are chart axes, there is no meaningful
+                    # dynamic movement between them, so we mark the aspect as
+                    # "Fixed" regardless of any synthetic speeds.
+                    if first_name in AXES_LIST and second_name in AXES_LIST:
+                        aspect_movement = "Fixed"
+                    else:
+                        # Get speeds, fall back to 0.0 only if missing/None
+                        first_speed = active_points_list[first].get("speed") or 0.0
+                        second_speed = active_points_list[second].get("speed") or 0.0
+
+                        # Calculate aspect movement (applying/separating/fixed)
+                        aspect_movement = calculate_aspect_movement(
+                            active_points_list[first]["abs_pos"],
+                            active_points_list[second]["abs_pos"],
+                            aspect["aspect_degrees"],
+                            first_speed,
+                            second_speed
+                        )
 
                     aspect_model = AspectModel(
                         p1_name=first_name,
@@ -412,12 +425,24 @@ class AspectsFactory:
                     first_planet_id = planet_id_lookup.get(first_name, 0)
                     second_planet_id = planet_id_lookup.get(second_name, 0)
 
-                    # Calculate aspect movement (applying/separating/exact)
-                    aspect_movement = calculate_aspect_movement(
-                        first_active_points_list[first]["abs_pos"],
-                        second_active_points_list[second]["abs_pos"],
-                        aspect["aspect_degrees"]
-                    )
+                    # For aspects between axes (ASC, MC, DSC, IC) in different charts
+                    # there is no meaningful dynamic movement between two house systems,
+                    # so we mark the movement as "Fixed".
+                    if first_name in AXES_LIST and second_name in AXES_LIST:
+                        aspect_movement = "Fixed"
+                    else:
+                        # Get speeds, fall back to 0.0 only if missing/None
+                        first_speed = first_active_points_list[first].get("speed") or 0.0
+                        second_speed = second_active_points_list[second].get("speed") or 0.0
+
+                        # Calculate aspect movement (applying/separating/fixed)
+                        aspect_movement = calculate_aspect_movement(
+                            first_active_points_list[first]["abs_pos"],
+                            second_active_points_list[second]["abs_pos"],
+                            aspect["aspect_degrees"],
+                            first_speed,
+                            second_speed
+                        )
 
                     aspect_model = AspectModel(
                         p1_name=first_name,
@@ -565,4 +590,3 @@ if __name__ == "__main__":
     yoko = AstrologicalSubjectFactory.from_birth_data("Yoko", 1933, 2, 18, 10, 30, "Tokyo", "JP")
     dual_chart_aspects = AspectsFactory.dual_chart_aspects(john, yoko)
     print(f"Dual chart aspects: {len(dual_chart_aspects.aspects)}")
-

kerykeion/aspects/aspects_utils.py

@@ -56,75 +56,182 @@ def get_aspect_from_two_points(
     }
 
 
+def _sign(x: float) -> int:
+    """
+    Return the sign of ``x``.
+
+    Returns +1 if ``x`` > 0, -1 if ``x`` < 0, and 0 if ``x`` == 0.
+    """
+    if x > 0:
+        return 1
+    elif x < 0:
+        return -1
+    else:
+        return 0
+
+
 def calculate_aspect_movement(
     point_one_abs_pos: float,
     point_two_abs_pos: float,
-    aspect_degrees: int,
-    exact_orb_threshold: float = 0.05
+    aspect_degrees: float,
+    point_one_speed: float,
+    point_two_speed: float,
 ) -> AspectMovementType:
     """
-    Calculate whether an aspect is applying, separating, or exact.
+        Determine whether an aspect is applying, separating, or fixed.
 
-    An aspect is:
-    - "Exact": When the orb is very tight (default < 0.17°)
-    - "Applying": When the faster planet is moving toward the exact aspect
-    - "Separating": When the faster planet is moving away from the exact aspect
+        This implementation uses a dynamic definition based on the time evolution
+        of the orb:
 
-    For simplicity, we assume the first planet (p1) is faster than the second (p2).
-    This is generally true for:
-    - Moon vs outer planets
-    - Inner planets vs outer planets
-    - Transits (transiting planet vs natal planet)
+        - "Applying": the orb is decreasing with time (the aspect is moving toward
+            exactness).
+        - "Separating": the orb is increasing with time (the aspect has already
+            perfected in the past, or will not perfect given the current motion).
+        - "Fixed": both points are effectively fixed so the orb does not change.
 
-    Args:
-        point_one_abs_pos: Absolute position of first point (0-360°)
-        point_two_abs_pos: Absolute position of second point (0-360°)
-        aspect_degrees: The exact degree of the aspect (0, 60, 90, 120, 180, etc.)
-        exact_orb_threshold: Maximum orb to consider aspect "exact" (default 0.17°)
+        Motion direction (direct or retrograde) is taken from the sign of the
+        speed values:
 
-    Returns:
-        "Applying", "Separating", or "Exact"
-
-    Example:
-        >>> # Moon at 45° applying to Sun at 50° (conjunction at 0°/360°)
-        >>> calculate_aspect_movement(45, 50, 0)
-        'Applying'
-        >>> # Moon at 55° separating from Sun at 50° (conjunction)
-        >>> calculate_aspect_movement(55, 50, 0)
-        'Separating'
+        - speed > 0: direct motion (increasing longitude)
+        - speed < 0: retrograde motion (decreasing longitude)
+
+        The algorithm does not assume which point is "faster" in absolute terms;
+        it uses the relative motion to determine whether the orb is growing or
+        shrinking.
+
+        Definitions:
+
+        - Longitudes are in degrees, 0 <= λ < 360 (normalized internally).
+        - ``aspect_degrees`` is the nominal angle of the aspect; values > 180
+            are made symmetric (e.g. 240° becomes 120°).
+        - The orb is defined as::
+
+                orb = abs(abs(separation) - aspect)
+
+            where ``separation`` is the minimal angular distance between the two
+            points in [-180, 180).
+
+        Logical steps:
+
+        1. Normalize longitudes to [0, 360) and the aspect to [0, 180].
+        2. Compute the signed separation ``sep`` between the two points using
+             ``difdeg2n``.
+        3. Compute the current orb::
+
+                     sep_abs = abs(sep)
+                     orb = abs(sep_abs - aspect)
+
+        4. Compute the relevant speed:
+             - if both points move: ``moving_speed = point_two_speed - point_one_speed``
+             - if one point is fixed (speed == 0): use the moving point speed
+                 against the fixed point.
+        5. The qualitative sign of the orb derivative is::
+
+                     sign_d_orb = sign(sep_abs - aspect) * sign(sep) * sign(moving_speed)
+
+             If ``sign_d_orb < 0`` the orb decreases (applying), if
+             ``sign_d_orb > 0`` the orb increases (separating).
+        6. If the relevant speed is exactly zero, the orb does not change over
+             time; if it is not exact, it is considered separating by convention.
+
+        Args:
+                point_one_abs_pos: Absolute longitude of the first point in degrees.
+                point_two_abs_pos: Absolute longitude of the second point in degrees.
+                aspect_degrees: Nominal aspect angle (e.g. 0, 60, 90, 120, 180).
+                point_one_speed: Speed of the first point in degrees/day (signed).
+                point_two_speed: Speed of the second point in degrees/day (signed).
+
+        Returns:
+                AspectMovementType: ``"Applying"``, ``"Separating"`` or ``"Fixed"``.
+
+        Raises:
+                ValueError: If any of the speeds is ``None``.
+
+        Examples:
+                >>> # Fast Moon at 45° approaching Sun at 50° (conjunction)
+                >>> calculate_aspect_movement(45, 50, 0, 12.5, 1.0)
+                'Applying'
+
+                >>> # Moon at 55° moving away from Sun at 50° (conjunction)
+                >>> calculate_aspect_movement(55, 50, 0, 12.5, 1.0)
+                'Separating'
+
+                >>> # Mercury (fast) square Mars
+                >>> calculate_aspect_movement(5, 100, 90, 1.5, 0.5)
+                'Applying'
+
+                >>> # Venus separating from a trine to Jupiter
+                >>> calculate_aspect_movement(5, 127, 120, 0.1, 1.2)
+                'Separating'
+
+                >>> # Retrograde Mars applying to a conjunction with direct Jupiter
+                >>> calculate_aspect_movement(110, 100, 0, -0.8, 0.1)
+                'Applying'
     """
 
-    # Calculate the angular distance
-    distance = abs(difdeg2n(point_one_abs_pos, point_two_abs_pos))
-    orbit = abs(distance - aspect_degrees)
+    if point_one_speed is None or point_two_speed is None:
+        raise ValueError(
+            "Speed values for both points are required to compute aspect "
+            "movement correctly. point_one_speed and point_two_speed "
+            "cannot be None."
+        )
 
-    # Check if aspect is exact (within tight orb)
-    if orbit <= exact_orb_threshold:
-        return "Exact"
+    # Normalize longitudes to [0, 360)
+    p1 = point_one_abs_pos % 360.0
+    p2 = point_two_abs_pos % 360.0
 
-    # Calculate if p1 is ahead or behind p2 relative to the aspect
-    # We need to determine the direction of movement
-    diff = difdeg2n(point_one_abs_pos, point_two_abs_pos)
+    # Normalize aspect to [0, 360) and then to [0, 180]
+    aspect = aspect_degrees % 360.0
+    if aspect > 180.0:
+        aspect = 360.0 - aspect  # es. 240 -> 120
 
-    # For conjunction (0°) or opposition (180°)
-    if aspect_degrees == 0 or aspect_degrees == 360:
-        # If p1 is behind p2 (negative diff), it's applying
-        # If p1 is ahead of p2 (positive diff), it's separating
-        return "Applying" if diff < 0 else "Separating"
+    # Special case: if one of the two points is effectively fixed (speed = 0),
+    # such as chart angles, we consider only the motion of the moving point
+    # relative to the fixed one. The order of the points must not affect
+    # the result.
+    if point_one_speed == 0 and point_two_speed == 0:
+        # Both points are fixed, the aspect never changes dynamically
+        return "Fixed"
 
-    elif aspect_degrees == 180:
-        # For opposition, the logic is reversed
-        return "Applying" if abs(diff) < 180 else "Separating"
+    # Identify which point is moving and which one is fixed/slower.
+    # To correctly handle axes we always compute with respect to the
+    # moving point.
+    if point_one_speed == 0:
+        # point_one is fixed (e.g. axis), point_two moves
+        moving_pos = p2
+        fixed_pos = p1
+        moving_speed = point_two_speed
+        sep = difdeg2n(moving_pos, fixed_pos)
+
+    elif point_two_speed == 0:
+        # point_two is fixed (e.g. axis), point_one moves
+        moving_pos = p1
+        fixed_pos = p2
+        moving_speed = point_one_speed
+        sep = difdeg2n(moving_pos, fixed_pos)
 
     else:
-        # For other aspects (60°, 90°, 120°, 150°)
-        # Check if the distance is increasing or decreasing
-        # If distance < aspect_degrees and diff < 0: applying
-        # If distance > aspect_degrees or diff > 0: separating
-        if abs(diff) < aspect_degrees:
-            return "Applying" if diff < 0 else "Separating"
-        else:
-            return "Separating" if diff > 0 else "Applying"
+        # Both points move: use relative speed and standard separation
+        sep = difdeg2n(p2, p1)
+        moving_speed = point_two_speed - point_one_speed
+
+    sep_abs = abs(sep)
+
+    # If the (relative or absolute) speed is zero, the orb does not change
+    if moving_speed == 0:
+        return "Separating"
+
+    # Signs used to determine whether the orb grows or shrinks
+    sign_sep = _sign(sep)                 # sign of the separation
+    sign_delta = _sign(sep_abs - aspect)  # whether we are "before" or "beyond" the exact aspect
+    sign_rel = _sign(moving_speed)        # direction in which the separation evolves
+
+    # Qualitative sign of the orb derivative (d(orb)/dt):
+    # < 0  -> orb decreases -> Applying
+    # > 0  -> orb increases -> Separating
+    orb_derivative_sign = sign_delta * sign_sep * sign_rel
+
+    return "Applying" if orb_derivative_sign < 0 else "Separating"
 
 
 def planet_id_decoder(planets_settings: list[KerykeionSettingsCelestialPointModel], name: str) -> int:

kerykeion/astrological_subject_factory.py

@@ -1088,16 +1088,24 @@ class AstrologicalSubjectFactory:
         # Calculate axis points
         point_type = "AstrologicalPoint"
 
+        # NOTE: Swiss Ephemeris does not provide direct speeds for angles (ASC/MC),
+        # but in realtà si muovono molto velocemente rispetto ai pianeti.
+        # Per rappresentare questo in modo coerente, assegniamo ai quattro assi
+        # una speed sintetica fissa, molto più alta di quella planetaria tipica.
+        # Questo permette a calculate_aspect_movement di considerarli sempre come
+        # "più veloci" rispetto ai pianeti quando serve.
+        axis_speed = 360.0  # gradi/giorno, valore simbolico ma coerente
+
         # Calculate Ascendant if needed
         if should_calculate("Ascendant"):
-            data["ascendant"] = get_kerykeion_point_from_degree(ascmc[0], "Ascendant", point_type=point_type)
+            data["ascendant"] = get_kerykeion_point_from_degree(ascmc[0], "Ascendant", point_type=point_type, speed=axis_speed)
             data["ascendant"].house = get_planet_house(data["ascendant"].abs_pos, data["_houses_degree_ut"])
             data["ascendant"].retrograde = False
             calculated_axial_cusps.append("Ascendant")
 
         # Calculate Medium Coeli if needed
         if should_calculate("Medium_Coeli"):
-            data["medium_coeli"] = get_kerykeion_point_from_degree(ascmc[1], "Medium_Coeli", point_type=point_type)
+            data["medium_coeli"] = get_kerykeion_point_from_degree(ascmc[1], "Medium_Coeli", point_type=point_type, speed=axis_speed)
             data["medium_coeli"].house = get_planet_house(data["medium_coeli"].abs_pos, data["_houses_degree_ut"])
             data["medium_coeli"].retrograde = False
             calculated_axial_cusps.append("Medium_Coeli")
@@ -1105,7 +1113,7 @@ class AstrologicalSubjectFactory:
         # Calculate Descendant if needed
         if should_calculate("Descendant"):
             dsc_deg = math.fmod(ascmc[0] + 180, 360)
-            data["descendant"] = get_kerykeion_point_from_degree(dsc_deg, "Descendant", point_type=point_type)
+            data["descendant"] = get_kerykeion_point_from_degree(dsc_deg, "Descendant", point_type=point_type, speed=axis_speed)
             data["descendant"].house = get_planet_house(data["descendant"].abs_pos, data["_houses_degree_ut"])
             data["descendant"].retrograde = False
             calculated_axial_cusps.append("Descendant")
@@ -1113,7 +1121,7 @@ class AstrologicalSubjectFactory:
         # Calculate Imum Coeli if needed
         if should_calculate("Imum_Coeli"):
             ic_deg = math.fmod(ascmc[1] + 180, 360)
-            data["imum_coeli"] = get_kerykeion_point_from_degree(ic_deg, "Imum_Coeli", point_type=point_type)
+            data["imum_coeli"] = get_kerykeion_point_from_degree(ic_deg, "Imum_Coeli", point_type=point_type, speed=axis_speed)
             data["imum_coeli"].house = get_planet_house(data["imum_coeli"].abs_pos, data["_houses_degree_ut"])
             data["imum_coeli"].retrograde = False
             calculated_axial_cusps.append("Imum_Coeli")
@@ -1463,89 +1471,92 @@ class AstrologicalSubjectFactory:
         # TRANS-NEPTUNIAN OBJECTS
         # ==================
 
+        # For TNOs we compute ecliptic longitude for zodiac placement and
+        # declination from equatorial coordinates, same as other bodies.
+
         # Calculate Eris
         if should_calculate("Eris"):
             try:
-                eris_calc = swe.calc_ut(julian_day, swe.AST_OFFSET + 136199, iflag)[0]
-                data["eris"] = get_kerykeion_point_from_degree(eris_calc[0], "Eris", point_type=point_type, speed=eris_calc[3], declination=eris_calc[1])
-                data["eris"].house = get_planet_house(eris_calc[0], houses_degree_ut)
-                data["eris"].retrograde = eris_calc[3] < 0
-                calculated_planets.append("Eris")
+                AstrologicalSubjectFactory._calculate_single_planet(
+                    data, "Eris", swe.AST_OFFSET + 136199, julian_day, iflag,
+                    houses_degree_ut, point_type, calculated_planets, active_points
+                )
             except Exception as e:
                 logging.warning(f"Could not calculate Eris position: {e}")
-                active_points.remove("Eris")  # Remove if not calculated
+                if "Eris" in active_points:
+                    active_points.remove("Eris")  # Remove if not calculated
 
         # Calculate Sedna
         if should_calculate("Sedna"):
             try:
-                sedna_calc = swe.calc_ut(julian_day, swe.AST_OFFSET + 90377, iflag)[0]
-                data["sedna"] = get_kerykeion_point_from_degree(sedna_calc[0], "Sedna", point_type=point_type, speed=sedna_calc[3], declination=sedna_calc[1])
-                data["sedna"].house = get_planet_house(sedna_calc[0], houses_degree_ut)
-                data["sedna"].retrograde = sedna_calc[3] < 0
-                calculated_planets.append("Sedna")
+                AstrologicalSubjectFactory._calculate_single_planet(
+                    data, "Sedna", swe.AST_OFFSET + 90377, julian_day, iflag,
+                    houses_degree_ut, point_type, calculated_planets, active_points
+                )
             except Exception as e:
                 logging.warning(f"Could not calculate Sedna position: {e}")
-                active_points.remove("Sedna")
+                if "Sedna" in active_points:
+                    active_points.remove("Sedna")
 
         # Calculate Haumea
         if should_calculate("Haumea"):
             try:
-                haumea_calc = swe.calc_ut(julian_day, swe.AST_OFFSET + 136108, iflag)[0]
-                data["haumea"] = get_kerykeion_point_from_degree(haumea_calc[0], "Haumea", point_type=point_type, speed=haumea_calc[3], declination=haumea_calc[1])
-                data["haumea"].house = get_planet_house(haumea_calc[0], houses_degree_ut)
-                data["haumea"].retrograde = haumea_calc[3] < 0
-                calculated_planets.append("Haumea")
+                AstrologicalSubjectFactory._calculate_single_planet(
+                    data, "Haumea", swe.AST_OFFSET + 136108, julian_day, iflag,
+                    houses_degree_ut, point_type, calculated_planets, active_points
+                )
             except Exception as e:
                 logging.warning(f"Could not calculate Haumea position: {e}")
-                active_points.remove("Haumea")  # Remove if not calculated
+                if "Haumea" in active_points:
+                    active_points.remove("Haumea")  # Remove if not calculated
 
         # Calculate Makemake
         if should_calculate("Makemake"):
             try:
-                makemake_calc = swe.calc_ut(julian_day, swe.AST_OFFSET + 136472, iflag)[0]
-                data["makemake"] = get_kerykeion_point_from_degree(makemake_calc[0], "Makemake", point_type=point_type, speed=makemake_calc[3], declination=makemake_calc[1])
-                data["makemake"].house = get_planet_house(makemake_calc[0], houses_degree_ut)
-                data["makemake"].retrograde = makemake_calc[3] < 0
-                calculated_planets.append("Makemake")
+                AstrologicalSubjectFactory._calculate_single_planet(
+                    data, "Makemake", swe.AST_OFFSET + 136472, julian_day, iflag,
+                    houses_degree_ut, point_type, calculated_planets, active_points
+                )
             except Exception as e:
                 logging.warning(f"Could not calculate Makemake position: {e}")
-                active_points.remove("Makemake")  # Remove if not calculated
+                if "Makemake" in active_points:
+                    active_points.remove("Makemake")  # Remove if not calculated
 
         # Calculate Ixion
         if should_calculate("Ixion"):
             try:
-                ixion_calc = swe.calc_ut(julian_day, swe.AST_OFFSET + 28978, iflag)[0]
-                data["ixion"] = get_kerykeion_point_from_degree(ixion_calc[0], "Ixion", point_type=point_type, speed=ixion_calc[3], declination=ixion_calc[1])
-                data["ixion"].house = get_planet_house(ixion_calc[0], houses_degree_ut)
-                data["ixion"].retrograde = ixion_calc[3] < 0
-                calculated_planets.append("Ixion")
+                AstrologicalSubjectFactory._calculate_single_planet(
+                    data, "Ixion", swe.AST_OFFSET + 28978, julian_day, iflag,
+                    houses_degree_ut, point_type, calculated_planets, active_points
+                )
             except Exception as e:
                 logging.warning(f"Could not calculate Ixion position: {e}")
-                active_points.remove("Ixion")  # Remove if not calculated
+                if "Ixion" in active_points:
+                    active_points.remove("Ixion")  # Remove if not calculated
 
         # Calculate Orcus
         if should_calculate("Orcus"):
             try:
-                orcus_calc = swe.calc_ut(julian_day, swe.AST_OFFSET + 90482, iflag)[0]
-                data["orcus"] = get_kerykeion_point_from_degree(orcus_calc[0], "Orcus", point_type=point_type, speed=orcus_calc[3], declination=orcus_calc[1])
-                data["orcus"].house = get_planet_house(orcus_calc[0], houses_degree_ut)
-                data["orcus"].retrograde = orcus_calc[3] < 0
-                calculated_planets.append("Orcus")
+                AstrologicalSubjectFactory._calculate_single_planet(
+                    data, "Orcus", swe.AST_OFFSET + 90482, julian_day, iflag,
+                    houses_degree_ut, point_type, calculated_planets, active_points
+                )
             except Exception as e:
                 logging.warning(f"Could not calculate Orcus position: {e}")
-                active_points.remove("Orcus")  # Remove if not calculated
+                if "Orcus" in active_points:
+                    active_points.remove("Orcus")  # Remove if not calculated
 
         # Calculate Quaoar
         if should_calculate("Quaoar"):
             try:
-                quaoar_calc = swe.calc_ut(julian_day, swe.AST_OFFSET + 50000, iflag)[0]
-                data["quaoar"] = get_kerykeion_point_from_degree(quaoar_calc[0], "Quaoar", point_type=point_type, speed=quaoar_calc[3], declination=quaoar_calc[1])
-                data["quaoar"].house = get_planet_house(quaoar_calc[0], houses_degree_ut)
-                data["quaoar"].retrograde = quaoar_calc[3] < 0
-                calculated_planets.append("Quaoar")
+                AstrologicalSubjectFactory._calculate_single_planet(
+                    data, "Quaoar", swe.AST_OFFSET + 50000, julian_day, iflag,
+                    houses_degree_ut, point_type, calculated_planets, active_points
+                )
             except Exception as e:
                 logging.warning(f"Could not calculate Quaoar position: {e}")
-                active_points.remove("Quaoar")  # Remove if not calculated
+                if "Quaoar" in active_points:
+                    active_points.remove("Quaoar")  # Remove if not calculated
 
         # ==================
         # FIXED STARS
@@ -1555,33 +1566,41 @@ class AstrologicalSubjectFactory:
         if should_calculate("Regulus"):
             try:
                 star_name = "Regulus"
-                pos = swe.fixstar_ut(star_name, julian_day, iflag)[0]
-                regulus_deg = pos[0]
-                regulus_speed = pos[3] if len(pos) > 3 else 0.0  # Fixed stars have very slow speed
-                regulus_dec = pos[1] if len(pos) > 1 else None  # Declination
+                # Ecliptic longitude for zodiac placement
+                pos_ecl = swe.fixstar_ut(star_name, julian_day, iflag)[0]
+                regulus_deg = pos_ecl[0]
+                regulus_speed = pos_ecl[3] if len(pos_ecl) > 3 else 0.0  # Fixed stars have very slow speed
+                # Equatorial coordinates for true declination
+                pos_eq = swe.fixstar_ut(star_name, julian_day, iflag | swe.FLG_EQUATORIAL)[0]
+                regulus_dec = pos_eq[1] if len(pos_eq) > 1 else None
                 data["regulus"] = get_kerykeion_point_from_degree(regulus_deg, "Regulus", point_type=point_type, speed=regulus_speed, declination=regulus_dec)
                 data["regulus"].house = get_planet_house(regulus_deg, houses_degree_ut)
                 data["regulus"].retrograde = False  # Fixed stars are never retrograde
                 calculated_planets.append("Regulus")
             except Exception as e:
                 logging.warning(f"Could not calculate Regulus position: {e}")
-                active_points.remove("Regulus")  # Remove if not calculated
+                if "Regulus" in active_points:
+                    active_points.remove("Regulus")  # Remove if not calculated
 
         # Calculate Spica (example fixed star)
         if should_calculate("Spica"):
             try:
                 star_name = "Spica"
-                pos = swe.fixstar_ut(star_name, julian_day, iflag)[0]
-                spica_deg = pos[0]
-                spica_speed = pos[3] if len(pos) > 3 else 0.0  # Fixed stars have very slow speed
-                spica_dec = pos[1] if len(pos) > 1 else None  # Declination
+                # Ecliptic longitude for zodiac placement
+                pos_ecl = swe.fixstar_ut(star_name, julian_day, iflag)[0]
+                spica_deg = pos_ecl[0]
+                spica_speed = pos_ecl[3] if len(pos_ecl) > 3 else 0.0  # Fixed stars have very slow speed
+                # Equatorial coordinates for true declination
+                pos_eq = swe.fixstar_ut(star_name, julian_day, iflag | swe.FLG_EQUATORIAL)[0]
+                spica_dec = pos_eq[1] if len(pos_eq) > 1 else None
                 data["spica"] = get_kerykeion_point_from_degree(spica_deg, "Spica", point_type=point_type, speed=spica_speed, declination=spica_dec)
                 data["spica"].house = get_planet_house(spica_deg, houses_degree_ut)
                 data["spica"].retrograde = False  # Fixed stars are never retrograde
                 calculated_planets.append("Spica")
             except Exception as e:
                 logging.warning(f"Could not calculate Spica position: {e}")
-                active_points.remove("Spica")  # Remove if not calculated
+                if "Spica" in active_points:
+                    active_points.remove("Spica")  # Remove if not calculated
 
         # ==================
         # ARABIC PARTS / LOTS