kerykeion 5.0.0a12__py3-none-any.whl → 5.0.0b1__py3-none-any.whl

kerykeion/astrological_subject_factory.py

@@ -38,10 +38,11 @@ from datetime import datetime
 from pathlib import Path
 from typing import Optional, List, Dict, Any, get_args, cast
 from dataclasses import dataclass, field
+from contextlib import contextmanager
 
 
 from kerykeion.fetch_geonames import FetchGeonames
-from kerykeion.kr_types import (
+from kerykeion.schemas import (
     KerykeionException,
     ZodiacType,
     AstrologicalSubjectModel,
@@ -81,8 +82,60 @@ GEONAMES_DEFAULT_USERNAME_WARNING = (
     "********"
 )
 
-NOW = datetime.now()
-
+@contextmanager
+def ephemeris_context(
+    ephe_path: str,
+    config: "ChartConfiguration",
+    lng: float,
+    lat: float,
+    alt: Optional[float] = None,
+):
+    """Context manager that isolates Swiss Ephemeris configuration.
+
+    Responsibilities:
+        - Set ephemeris path and calculation flags
+        - Configure perspective (true geo / helio / topo)
+        - Configure sidereal mode when needed
+        - Apply topocentric observer only inside the with-block
+        - Yield iflag for calculations
+        - Reset topocentric coordinates afterward (defensive)
+
+    Args:
+        ephe_path: Path containing Swiss Ephemeris data files.
+        config: Validated chart configuration.
+        lng: Observer longitude (used for topocentric charts).
+        lat: Observer latitude (used for topocentric charts).
+        alt: Observer altitude (meters) for topocentric charts.
+
+    Yields:
+        int: iflag to be passed to swe.calc_ut / swe.fixstar_ut.
+    """
+    swe.set_ephe_path(ephe_path)
+    iflag = swe.FLG_SWIEPH | swe.FLG_SPEED
+
+    topo_used = False
+
+    # Perspective configuration
+    if config.perspective_type == "True Geocentric":
+        iflag |= swe.FLG_TRUEPOS
+    elif config.perspective_type == "Heliocentric":
+        iflag |= swe.FLG_HELCTR
+    elif config.perspective_type == "Topocentric":
+        iflag |= swe.FLG_TOPOCTR
+        swe.set_topo(lng, lat, alt or 0.0)
+        topo_used = True
+
+    # Sidereal configuration
+    if config.zodiac_type == "Sidereal":
+        iflag |= swe.FLG_SIDEREAL
+        swe.set_sid_mode(getattr(swe, f"SIDM_{config.sidereal_mode}"))
+
+    try:
+        yield iflag
+    finally:
+        # Defensive cleanup: reset topo if it was set
+        if topo_used:
+            swe.set_topo(0.0, 0.0, 0.0)
 
 @dataclass
 class ChartConfiguration:
@@ -118,13 +171,15 @@ class ChartConfiguration:
         ...     houses_system_identifier="K",
         ...     perspective_type="Topocentric"
         ... )
-        >>> config.validate()
     """
     zodiac_type: ZodiacType = DEFAULT_ZODIAC_TYPE
     sidereal_mode: Optional[SiderealMode] = None
     houses_system_identifier: HousesSystemIdentifier = DEFAULT_HOUSES_SYSTEM_IDENTIFIER
     perspective_type: PerspectiveType = DEFAULT_PERSPECTIVE_TYPE
 
+    def __post_init__(self) -> None:
+        self.validate()
+
     def validate(self) -> None:
         """
         Validate configuration settings for internal consistency.
@@ -364,11 +419,11 @@ class AstrologicalSubjectFactory:
     def from_birth_data(
         cls,
         name: str = "Now",
-        year: int = NOW.year,
-        month: int = NOW.month,
-        day: int = NOW.day,
-        hour: int = NOW.hour,
-        minute: int = NOW.minute,
+        year: Optional[int] = None,
+        month: Optional[int] = None,
+        day: Optional[int] = None,
+        hour: Optional[int] = None,
+        minute: Optional[int] = None,
         city: Optional[str] = None,
         nation: Optional[str] = None,
         lng: Optional[float] = None,
@@ -383,10 +438,11 @@ class AstrologicalSubjectFactory:
         cache_expire_after_days: int = DEFAULT_GEONAMES_CACHE_EXPIRE_AFTER_DAYS,
         is_dst: Optional[bool] = None,
         altitude: Optional[float] = None,
-        active_points: List[AstrologicalPoint] = DEFAULT_ACTIVE_POINTS,
+        active_points: Optional[List[AstrologicalPoint]] = None,
         calculate_lunar_phase: bool = True,
         *,
         seconds: int = 0,
+        suppress_geonames_warning: bool = False,
 
     ) -> AstrologicalSubjectModel:
         """
@@ -440,11 +496,14 @@ class AstrologicalSubjectFactory:
             altitude (float, optional): Altitude above sea level in meters. Used for
                 topocentric calculations and atmospheric corrections. Defaults to None
                 (sea level assumed).
-            active_points (List[AstrologicalPoint], optional): List of astrological
+            active_points (Optional[List[AstrologicalPoint]], optional): List of astrological
                 points to calculate. Omitting points can improve performance for
-                specialized applications. Defaults to DEFAULT_ACTIVE_POINTS.
+                specialized applications. If None, uses DEFAULT_ACTIVE_POINTS.
             calculate_lunar_phase (bool, optional): Whether to calculate lunar phase.
                 Requires Sun and Moon in active_points. Defaults to True.
+            suppress_geonames_warning (bool, optional): If True, suppresses the warning
+                message when using the default GeoNames username. Useful for testing
+                or automated processes. Defaults to False.
 
         Returns:
             AstrologicalSubjectModel: Complete astrological subject with calculated
@@ -495,17 +554,30 @@ class AstrologicalSubjectFactory:
             - The method handles polar regions by adjusting extreme latitudes
             - Time zones are handled with full DST awareness via pytz
         """
+        # Resolve time defaults using current time
+        if year is None or month is None or day is None or hour is None or minute is None or seconds is None:
+            now = datetime.now()
+            year = year if year is not None else now.year
+            month = month if month is not None else now.month
+            day = day if day is not None else now.day
+            hour = hour if hour is not None else now.hour
+            minute = minute if minute is not None else now.minute
+            seconds = seconds if seconds is not None else now.second
+
         # Create a calculation data container
-        calc_data = {}
+        calc_data: Dict[str, Any] = {}
 
         # Basic identity
         calc_data["name"] = name
         calc_data["json_dir"] = str(Path.home())
 
         # Create a deep copy of active points to avoid modifying the original list
-        active_points = list(active_points)
+        if active_points is None:
+            active_points_list: List[AstrologicalPoint] = list(DEFAULT_ACTIVE_POINTS)
+        else:
+            active_points_list = list(active_points)
 
-        calc_data["active_points"] = active_points
+        calc_data["active_points"] = active_points_list
 
         # Initialize configuration
         config = ChartConfiguration(
@@ -514,7 +586,6 @@ class AstrologicalSubjectFactory:
             houses_system_identifier=houses_system_identifier,
             perspective_type=perspective_type,
         )
-        config.validate()
 
         # Add configuration data to calculation data
         calc_data["zodiac_type"] = config.zodiac_type
@@ -524,7 +595,8 @@ class AstrologicalSubjectFactory:
 
         # Set up geonames username if needed
         if geonames_username is None and online and (not lat or not lng or not tz_str):
-            logging.warning(GEONAMES_DEFAULT_USERNAME_WARNING)
+            if not suppress_geonames_warning:
+                logging.warning(GEONAMES_DEFAULT_USERNAME_WARNING)
             geonames_username = DEFAULT_GEONAMES_USERNAME
 
         # Initialize location data
@@ -571,20 +643,37 @@ class AstrologicalSubjectFactory:
         calc_data["is_dst"] = is_dst
 
         # Calculate time conversions
-        cls._calculate_time_conversions(calc_data, location)
-
-        # Initialize Swiss Ephemeris and calculate houses and planets
-        cls._setup_ephemeris(calc_data, config)
-        cls._calculate_houses(calc_data, calc_data["active_points"])
-        cls._calculate_planets(calc_data, calc_data["active_points"])
-        cls._calculate_day_of_week(calc_data)
+        AstrologicalSubjectFactory._calculate_time_conversions(calc_data, location)
+        # Initialize Swiss Ephemeris and calculate houses and planets with context manager
+        ephe_path = str(Path(__file__).parent.absolute() / "sweph")
+        with ephemeris_context(
+            ephe_path=ephe_path,
+            config=config,
+            lng=calc_data["lng"],
+            lat=calc_data["lat"],
+            alt=calc_data["altitude"],
+        ) as iflag:
+            calc_data["_iflag"] = iflag
+            # House system name (previously set in _setup_ephemeris)
+            calc_data["houses_system_name"] = swe.house_name(
+                config.houses_system_identifier.encode("ascii")
+            )
+            calculated_axial_cusps = AstrologicalSubjectFactory._calculate_houses(
+                calc_data, active_points_list
+            )
+            AstrologicalSubjectFactory._calculate_planets(
+                calc_data, active_points_list, calculated_axial_cusps
+            )
+        AstrologicalSubjectFactory._calculate_day_of_week(calc_data)
 
         # Calculate lunar phase (optional - only if requested and Sun and Moon are available)
         if calculate_lunar_phase and "moon" in calc_data and "sun" in calc_data:
             calc_data["lunar_phase"] = calculate_moon_phase(
-                calc_data["moon"].abs_pos,
-                calc_data["sun"].abs_pos
+                calc_data["moon"].abs_pos,  # type: ignore[attr-defined,union-attr]
+                calc_data["sun"].abs_pos  # type: ignore[attr-defined,union-attr]
             )
+        else:
+            calc_data["lunar_phase"] = None
 
         # Create and return the AstrologicalSubjectModel
         return AstrologicalSubjectModel(**calc_data)
@@ -606,8 +695,9 @@ class AstrologicalSubjectFactory:
         houses_system_identifier: HousesSystemIdentifier = DEFAULT_HOUSES_SYSTEM_IDENTIFIER,
         perspective_type: PerspectiveType = DEFAULT_PERSPECTIVE_TYPE,
         altitude: Optional[float] = None,
-        active_points: List[AstrologicalPoint] = DEFAULT_ACTIVE_POINTS,
-        calculate_lunar_phase: bool = True
+        active_points: Optional[List[AstrologicalPoint]] = None,
+        calculate_lunar_phase: bool = True,
+        suppress_geonames_warning: bool = False
     ) -> AstrologicalSubjectModel:
         """
         Create an astrological subject from an ISO formatted UTC timestamp.
@@ -645,8 +735,8 @@ class AstrologicalSubjectFactory:
                 Defaults to 'Apparent Geocentric'.
             altitude (float, optional): Altitude in meters for topocentric calculations.
                 Defaults to None (sea level).
-            active_points (List[AstrologicalPoint], optional): Points to calculate.
-                Defaults to DEFAULT_ACTIVE_POINTS.
+            active_points (Optional[List[AstrologicalPoint]], optional): Points to calculate.
+                If None, uses DEFAULT_ACTIVE_POINTS.
             calculate_lunar_phase (bool, optional): Whether to calculate lunar phase.
                 Defaults to True.
 
@@ -689,7 +779,8 @@ class AstrologicalSubjectFactory:
         # Get location data if online mode is enabled
         if online:
             if geonames_username == DEFAULT_GEONAMES_USERNAME:
-                logging.warning(GEONAMES_DEFAULT_USERNAME_WARNING)
+                if not suppress_geonames_warning:
+                    logging.warning(GEONAMES_DEFAULT_USERNAME_WARNING)
 
             geonames = FetchGeonames(
                 city,
@@ -727,7 +818,8 @@ class AstrologicalSubjectFactory:
             perspective_type=perspective_type,
             altitude=altitude,
             active_points=active_points,
-            calculate_lunar_phase=calculate_lunar_phase
+            calculate_lunar_phase=calculate_lunar_phase,
+            suppress_geonames_warning=suppress_geonames_warning
         )
 
     @classmethod
@@ -745,8 +837,9 @@ class AstrologicalSubjectFactory:
         sidereal_mode: Optional[SiderealMode] = None,
         houses_system_identifier: HousesSystemIdentifier = DEFAULT_HOUSES_SYSTEM_IDENTIFIER,
         perspective_type: PerspectiveType = DEFAULT_PERSPECTIVE_TYPE,
-        active_points: List[AstrologicalPoint] = DEFAULT_ACTIVE_POINTS,
-        calculate_lunar_phase: bool = True
+        active_points: Optional[List[AstrologicalPoint]] = None,
+        calculate_lunar_phase: bool = True,
+        suppress_geonames_warning: bool = False
     ) -> AstrologicalSubjectModel:
         """
         Create an astrological subject for the current moment in time.
@@ -780,8 +873,8 @@ class AstrologicalSubjectFactory:
                 system for calculations. Defaults to 'P' (Placidus).
             perspective_type (PerspectiveType, optional): Calculation perspective.
                 Defaults to 'Apparent Geocentric'.
-            active_points (List[AstrologicalPoint], optional): Astrological points
-                to calculate. Defaults to DEFAULT_ACTIVE_POINTS.
+            active_points (Optional[List[AstrologicalPoint]], optional): Astrological points
+                to calculate. If None, uses DEFAULT_ACTIVE_POINTS.
             calculate_lunar_phase (bool, optional): Whether to calculate lunar phase.
                 Defaults to True.
 
@@ -845,11 +938,12 @@ class AstrologicalSubjectFactory:
             houses_system_identifier=houses_system_identifier,
             perspective_type=perspective_type,
             active_points=active_points,
-            calculate_lunar_phase=calculate_lunar_phase
+            calculate_lunar_phase=calculate_lunar_phase,
+            suppress_geonames_warning=suppress_geonames_warning
         )
 
-    @classmethod
-    def _calculate_time_conversions(cls, data: Dict[str, Any], location: LocationData) -> None:
+    @staticmethod
+    def _calculate_time_conversions(data: Dict[str, Any], location: LocationData) -> None:
         """
         Calculate time conversions between local time, UTC, and Julian Day Number.
 
@@ -890,6 +984,11 @@ class AstrologicalSubjectFactory:
                 "Ambiguous time error! The time falls during a DST transition. "
                 "Please specify is_dst=True or is_dst=False to clarify."
             )
+        except pytz.exceptions.NonExistentTimeError:
+            raise KerykeionException(
+                "Non-existent time error! The time does not exist due to DST transition (spring forward). "
+                "Please specify a valid time."
+            )
 
         # Store formatted times
         utc_datetime = local_datetime.astimezone(pytz.utc)
@@ -899,71 +998,9 @@ class AstrologicalSubjectFactory:
         # Calculate Julian day
         data["julian_day"] = datetime_to_julian(utc_datetime)
 
-    @classmethod
-    def _setup_ephemeris(cls, data: Dict[str, Any], config: ChartConfiguration) -> None:
-        """
-        Configure Swiss Ephemeris with appropriate calculation flags and settings.
-
-        Sets up the Swiss Ephemeris library with the correct ephemeris data path,
-        calculation flags for the specified perspective type, and sidereal mode
-        configuration if applicable.
 
-        Args:
-            data (Dict[str, Any]): Calculation data dictionary to store configuration.
-            config (ChartConfiguration): Validated chart configuration settings.
-
-        Side Effects:
-            - Sets Swiss Ephemeris data path to bundled ephemeris files
-            - Configures calculation flags (SWIEPH, SPEED, perspective flags)
-            - Sets sidereal mode for sidereal zodiac calculations
-            - Sets topocentric observer coordinates for topocentric perspective
-            - Updates data dictionary with houses_system_name and _iflag
-
-        Calculation Flags Set:
-            - FLG_SWIEPH: Use Swiss Ephemeris data files
-            - FLG_SPEED: Calculate planetary velocities
-            - FLG_TRUEPOS: True geometric positions (True Geocentric)
-            - FLG_HELCTR: Heliocentric coordinates (Heliocentric perspective)
-            - FLG_TOPOCTR: Topocentric coordinates (Topocentric perspective)
-            - FLG_SIDEREAL: Sidereal calculations (Sidereal zodiac)
-
-        Note:
-            The method assumes the Swiss Ephemeris data files are located in the
-            'sweph' subdirectory relative to this module. For topocentric calculations,
-            observer coordinates must be set via longitude, latitude, and altitude.
-        """
-        # Set ephemeris path
-        swe.set_ephe_path(str(Path(__file__).parent.absolute() / "sweph"))
-
-        # Base flags
-        iflag = swe.FLG_SWIEPH + swe.FLG_SPEED
-
-        # Add perspective flags
-        if config.perspective_type == "True Geocentric":
-            iflag += swe.FLG_TRUEPOS
-        elif config.perspective_type == "Heliocentric":
-            iflag += swe.FLG_HELCTR
-        elif config.perspective_type == "Topocentric":
-            iflag += swe.FLG_TOPOCTR
-            # Set topocentric coordinates
-            swe.set_topo(data["lng"], data["lat"], data["altitude"] or 0)
-
-        # Add sidereal flag if needed
-        if config.zodiac_type == "Sidereal":
-            iflag += swe.FLG_SIDEREAL
-            # Set sidereal mode
-            mode = f"SIDM_{config.sidereal_mode}"
-            swe.set_sid_mode(getattr(swe, mode))
-            logging.debug(f"Using sidereal mode: {mode}")
-
-        # Save house system name and iflag for later use
-        data["houses_system_name"] = swe.house_name(
-            config.houses_system_identifier.encode('ascii')
-        )
-        data["_iflag"] = iflag
-
-    @classmethod
-    def _calculate_houses(cls, data: Dict[str, Any], active_points: Optional[List[AstrologicalPoint]]) -> None:
+    @staticmethod
+    def _calculate_houses(data: Dict[str, Any], active_points: Optional[List[AstrologicalPoint]]) -> List[AstrologicalPoint]:
         """
         Calculate house cusps and angular points (Ascendant, MC, etc.).
 
@@ -1004,7 +1041,7 @@ class AstrologicalSubjectFactory:
         def should_calculate(point: AstrologicalPoint) -> bool:
             return not active_points or point in active_points
         # Track which axial cusps are actually calculated
-        calculated_axial_cusps = []
+        calculated_axial_cusps: List[AstrologicalPoint] = []
 
         # Calculate houses based on zodiac type
         if data["zodiac_type"] == "Sidereal":
@@ -1077,9 +1114,10 @@ class AstrologicalSubjectFactory:
             data["imum_coeli"].retrograde = False
             calculated_axial_cusps.append("Imum_Coeli")
 
-    @classmethod
+        return calculated_axial_cusps
+
+    @staticmethod
     def _calculate_single_planet(
-        cls,
         data: Dict[str, Any],
         planet_name: AstrologicalPoint,
         planet_id: int,
@@ -1087,7 +1125,7 @@ class AstrologicalSubjectFactory:
         iflag: int,
         houses_degree_ut: List[float],
         point_type: PointType,
-        calculated_planets: List[str],
+        calculated_planets: List[AstrologicalPoint],
         active_points: List[AstrologicalPoint]
     ) -> None:
         """
@@ -1132,12 +1170,16 @@ class AstrologicalSubjectFactory:
             component being negative (element index 3).
         """
         try:
-            # Calculate planet position using Swiss Ephemeris
+            # Calculate planet position using Swiss Ephemeris (ecliptic coordinates)
             planet_calc = swe.calc_ut(julian_day, planet_id, iflag)[0]
 
+            # Get declination from equatorial coordinates
+            planet_eq = swe.calc_ut(julian_day, planet_id, iflag | swe.FLG_EQUATORIAL)[0]
+            declination = planet_eq[1]  # Declination from equatorial coordinates
+
             # Create Kerykeion point from degree
             data[planet_name.lower()] = get_kerykeion_point_from_degree(
-                planet_calc[0], planet_name, point_type=point_type
+                planet_calc[0], planet_name, point_type=point_type, speed=planet_calc[3], declination=declination
             )
 
             # Calculate house position
@@ -1154,8 +1196,8 @@ class AstrologicalSubjectFactory:
             if planet_name in active_points:
                 active_points.remove(planet_name)
 
-    @classmethod
-    def _calculate_planets(cls, data: Dict[str, Any], active_points: List[AstrologicalPoint]) -> None:
+    @staticmethod
+    def _calculate_planets(data: Dict[str, Any], active_points: List[AstrologicalPoint], calculated_axial_cusps: Optional[List[AstrologicalPoint]] = None) -> None:
         """
         Calculate positions for all requested celestial bodies and special points.
 
@@ -1248,7 +1290,7 @@ class AstrologicalSubjectFactory:
         houses_degree_ut = data["_houses_degree_ut"]
 
         # Track which planets are actually calculated
-        calculated_planets = []
+        calculated_planets: List[AstrologicalPoint] = []
 
         # ==================
         # MAIN PLANETS
@@ -1256,75 +1298,87 @@ class AstrologicalSubjectFactory:
 
         # Calculate Sun
         if should_calculate("Sun"):
-            cls._calculate_single_planet(data, "Sun", 0, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
+            AstrologicalSubjectFactory._calculate_single_planet(data, "Sun", 0, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
 
         # Calculate Moon
         if should_calculate("Moon"):
-            cls._calculate_single_planet(data, "Moon", 1, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
+            AstrologicalSubjectFactory._calculate_single_planet(data, "Moon", 1, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
 
         # Calculate Mercury
         if should_calculate("Mercury"):
-            cls._calculate_single_planet(data, "Mercury", 2, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
+            AstrologicalSubjectFactory._calculate_single_planet(data, "Mercury", 2, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
 
         # Calculate Venus
         if should_calculate("Venus"):
-            cls._calculate_single_planet(data, "Venus", 3, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
+            AstrologicalSubjectFactory._calculate_single_planet(data, "Venus", 3, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
 
         # Calculate Mars
         if should_calculate("Mars"):
-            cls._calculate_single_planet(data, "Mars", 4, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
+            AstrologicalSubjectFactory._calculate_single_planet(data, "Mars", 4, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
 
         # Calculate Jupiter
         if should_calculate("Jupiter"):
-            cls._calculate_single_planet(data, "Jupiter", 5, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
+            AstrologicalSubjectFactory._calculate_single_planet(data, "Jupiter", 5, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
 
         # Calculate Saturn
         if should_calculate("Saturn"):
-            cls._calculate_single_planet(data, "Saturn", 6, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
+            AstrologicalSubjectFactory._calculate_single_planet(data, "Saturn", 6, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
 
         # Calculate Uranus
         if should_calculate("Uranus"):
-            cls._calculate_single_planet(data, "Uranus", 7, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
+            AstrologicalSubjectFactory._calculate_single_planet(data, "Uranus", 7, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
 
         # Calculate Neptune
         if should_calculate("Neptune"):
-            cls._calculate_single_planet(data, "Neptune", 8, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
+            AstrologicalSubjectFactory._calculate_single_planet(data, "Neptune", 8, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
 
         # Calculate Pluto
         if should_calculate("Pluto"):
-            cls._calculate_single_planet(data, "Pluto", 9, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
+            AstrologicalSubjectFactory._calculate_single_planet(data, "Pluto", 9, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
 
         # ==================
         # LUNAR NODES
         # ==================
 
-        # Calculate Mean Lunar Node
-        if should_calculate("Mean_Node"):
-            cls._calculate_single_planet(data, "Mean_Node", 10, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
-
-        # Calculate True Lunar Node
-        if should_calculate("True_Node"):
-            cls._calculate_single_planet(data, "True_Node", 11, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
-
-        # Calculate Mean South Node (opposite to Mean North Node)
-        if should_calculate("Mean_South_Node") and "mean_node" in data:
-            mean_south_node_deg = math.fmod(data["mean_node"].abs_pos + 180, 360)
-            data["mean_south_node"] = get_kerykeion_point_from_degree(
-                mean_south_node_deg, "Mean_South_Node", point_type=point_type
+        # Calculate Mean North Lunar Node
+        if should_calculate("Mean_North_Lunar_Node"):
+            AstrologicalSubjectFactory._calculate_single_planet(data, "Mean_North_Lunar_Node", 10, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
+            # Get correct declination using equatorial coordinates
+            if "mean_north_lunar_node" in data:
+                mean_north_lunar_node_eq = swe.calc_ut(julian_day, 10, iflag | swe.FLG_EQUATORIAL)[0]
+                data["mean_north_lunar_node"].declination = mean_north_lunar_node_eq[1]  # Declination from equatorial coordinates
+
+        # Calculate True North Lunar Node
+        if should_calculate("True_North_Lunar_Node"):
+            AstrologicalSubjectFactory._calculate_single_planet(data, "True_North_Lunar_Node", 11, julian_day, iflag, houses_degree_ut, point_type, calculated_planets, active_points)
+            # Get correct declination using equatorial coordinates
+            if "true_north_lunar_node" in data:
+                true_north_lunar_node_eq = swe.calc_ut(julian_day, 11, iflag | swe.FLG_EQUATORIAL)[0]
+                data["true_north_lunar_node"].declination = true_north_lunar_node_eq[1]  # Declination from equatorial coordinates
+
+        # Calculate Mean South Lunar Node (opposite to Mean North Lunar Node)
+        if should_calculate("Mean_South_Lunar_Node") and "mean_north_lunar_node" in data:
+            mean_south_lunar_node_deg = math.fmod(data["mean_north_lunar_node"].abs_pos + 180, 360)
+            data["mean_south_lunar_node"] = get_kerykeion_point_from_degree(
+                mean_south_lunar_node_deg, "Mean_South_Lunar_Node", point_type=point_type,
+                speed=-data["mean_north_lunar_node"].speed if data["mean_north_lunar_node"].speed is not None else None,
+                declination=-data["mean_north_lunar_node"].declination if data["mean_north_lunar_node"].declination is not None else None
             )
-            data["mean_south_node"].house = get_planet_house(mean_south_node_deg, houses_degree_ut)
-            data["mean_south_node"].retrograde = data["mean_node"].retrograde
-            calculated_planets.append("Mean_South_Node")
-
-        # Calculate True South Node (opposite to True North Node)
-        if should_calculate("True_South_Node") and "true_node" in data:
-            true_south_node_deg = math.fmod(data["true_node"].abs_pos + 180, 360)
-            data["true_south_node"] = get_kerykeion_point_from_degree(
-                true_south_node_deg, "True_South_Node", point_type=point_type
+            data["mean_south_lunar_node"].house = get_planet_house(mean_south_lunar_node_deg, houses_degree_ut)
+            data["mean_south_lunar_node"].retrograde = data["mean_north_lunar_node"].retrograde
+            calculated_planets.append("Mean_South_Lunar_Node")
+
+        # Calculate True South Lunar Node (opposite to True North Lunar Node)
+        if should_calculate("True_South_Lunar_Node") and "true_north_lunar_node" in data:
+            true_south_lunar_node_deg = math.fmod(data["true_north_lunar_node"].abs_pos + 180, 360)
+            data["true_south_lunar_node"] = get_kerykeion_point_from_degree(
+                true_south_lunar_node_deg, "True_South_Lunar_Node", point_type=point_type,
+                speed=-data["true_north_lunar_node"].speed if data["true_north_lunar_node"].speed is not None else None,
+                declination=-data["true_north_lunar_node"].declination if data["true_north_lunar_node"].declination is not None else None
             )
-            data["true_south_node"].house = get_planet_house(true_south_node_deg, houses_degree_ut)
-            data["true_south_node"].retrograde = data["true_node"].retrograde
-            calculated_planets.append("True_South_Node")
+            data["true_south_lunar_node"].house = get_planet_house(true_south_lunar_node_deg, houses_degree_ut)
+            data["true_south_lunar_node"].retrograde = data["true_north_lunar_node"].retrograde
+            calculated_planets.append("True_South_Lunar_Node")
 
         # ==================
         # LILITH POINTS
@@ -1332,14 +1386,14 @@ class AstrologicalSubjectFactory:
 
         # Calculate Mean Lilith (Mean Black Moon)
         if should_calculate("Mean_Lilith"):
-            cls._calculate_single_planet(
+            AstrologicalSubjectFactory._calculate_single_planet(
                 data, "Mean_Lilith", 12, julian_day, iflag, houses_degree_ut,
                 point_type, calculated_planets, active_points
             )
 
         # Calculate True Lilith (Osculating Black Moon)
         if should_calculate("True_Lilith"):
-            cls._calculate_single_planet(
+            AstrologicalSubjectFactory._calculate_single_planet(
                 data, "True_Lilith", 13, julian_day, iflag, houses_degree_ut,
                 point_type, calculated_planets, active_points
             )
@@ -1350,21 +1404,21 @@ class AstrologicalSubjectFactory:
 
         # Calculate Earth - useful for heliocentric charts
         if should_calculate("Earth"):
-            cls._calculate_single_planet(
+            AstrologicalSubjectFactory._calculate_single_planet(
                 data, "Earth", 14, julian_day, iflag, houses_degree_ut,
                 point_type, calculated_planets, active_points
             )
 
         # Calculate Chiron
         if should_calculate("Chiron"):
-            cls._calculate_single_planet(
+            AstrologicalSubjectFactory._calculate_single_planet(
                 data, "Chiron", 15, julian_day, iflag, houses_degree_ut,
                 point_type, calculated_planets, active_points
             )
 
         # Calculate Pholus
         if should_calculate("Pholus"):
-            cls._calculate_single_planet(
+            AstrologicalSubjectFactory._calculate_single_planet(
                 data, "Pholus", 16, julian_day, iflag, houses_degree_ut,
                 point_type, calculated_planets, active_points
             )
@@ -1375,28 +1429,28 @@ class AstrologicalSubjectFactory:
 
         # Calculate Ceres
         if should_calculate("Ceres"):
-            cls._calculate_single_planet(
+            AstrologicalSubjectFactory._calculate_single_planet(
                 data, "Ceres", 17, julian_day, iflag, houses_degree_ut,
                 point_type, calculated_planets, active_points
             )
 
         # Calculate Pallas
         if should_calculate("Pallas"):
-            cls._calculate_single_planet(
+            AstrologicalSubjectFactory._calculate_single_planet(
                 data, "Pallas", 18, julian_day, iflag, houses_degree_ut,
                 point_type, calculated_planets, active_points
             )
 
         # Calculate Juno
         if should_calculate("Juno"):
-            cls._calculate_single_planet(
+            AstrologicalSubjectFactory._calculate_single_planet(
                 data, "Juno", 19, julian_day, iflag, houses_degree_ut,
                 point_type, calculated_planets, active_points
             )
 
         # Calculate Vesta
         if should_calculate("Vesta"):
-            cls._calculate_single_planet(
+            AstrologicalSubjectFactory._calculate_single_planet(
                 data, "Vesta", 20, julian_day, iflag, houses_degree_ut,
                 point_type, calculated_planets, active_points
             )
@@ -1409,7 +1463,7 @@ class AstrologicalSubjectFactory:
         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)
+                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")
@@ -1421,7 +1475,7 @@ class AstrologicalSubjectFactory:
         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)
+                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")
@@ -1433,7 +1487,7 @@ class AstrologicalSubjectFactory:
         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)
+                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")
@@ -1445,7 +1499,7 @@ class AstrologicalSubjectFactory:
         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)
+                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")
@@ -1457,7 +1511,7 @@ class AstrologicalSubjectFactory:
         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)
+                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")
@@ -1469,7 +1523,7 @@ class AstrologicalSubjectFactory:
         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)
+                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")
@@ -1481,7 +1535,7 @@ class AstrologicalSubjectFactory:
         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)
+                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")
@@ -1497,9 +1551,11 @@ class AstrologicalSubjectFactory:
         if should_calculate("Regulus"):
             try:
                 star_name = "Regulus"
-                swe.fixstar_ut(star_name, julian_day, iflag)
-                regulus_deg = swe.fixstar_ut(star_name, julian_day, iflag)[0][0]
-                data["regulus"] = get_kerykeion_point_from_degree(regulus_deg, "Regulus", point_type=point_type)
+                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
+                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")
@@ -1511,9 +1567,11 @@ class AstrologicalSubjectFactory:
         if should_calculate("Spica"):
             try:
                 star_name = "Spica"
-                swe.fixstar_ut(star_name, julian_day, iflag)
-                spica_deg = swe.fixstar_ut(star_name, julian_day, iflag)[0][0]
-                data["spica"] = get_kerykeion_point_from_degree(spica_deg, "Spica", point_type=point_type)
+                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
+                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")
@@ -1528,21 +1586,41 @@ class AstrologicalSubjectFactory:
         # Calculate Pars Fortunae (Part of Fortune)
         if should_calculate("Pars_Fortunae"):
             # Auto-activate required points with notification
-            required_points: List[AstrologicalPoint] = ["Ascendant", "Sun", "Moon"]
-            missing_points = [point for point in required_points if point not in active_points]
+            pars_fortunae_required_points: List[AstrologicalPoint] = ["Ascendant", "Sun", "Moon"]
+            missing_points = [point for point in pars_fortunae_required_points if point not in active_points]
             if missing_points:
                 logging.info(f"Automatically adding required points for Pars_Fortunae: {missing_points}")
                 active_points.extend(cast(List[AstrologicalPoint], missing_points))
                 # Recalculate the missing points
                 for point in missing_points:
-                    if point == "Sun" and point not in data:
+                    if point == "Ascendant" and "ascendant" not in data:
+                        # Calculate Ascendant from houses data if needed
+                        if data["zodiac_type"] == "Sidereal":
+                            cusps, ascmc = swe.houses_ex(
+                                tjdut=data["julian_day"],
+                                lat=data["lat"],
+                                lon=data["lng"],
+                                hsys=str.encode(data["houses_system_identifier"]),
+                                flags=swe.FLG_SIDEREAL
+                            )
+                        else:
+                            cusps, ascmc = swe.houses(
+                                tjdut=data["julian_day"],
+                                lat=data["lat"],
+                                lon=data["lng"],
+                                hsys=str.encode(data["houses_system_identifier"])
+                            )
+                        data["ascendant"] = get_kerykeion_point_from_degree(ascmc[0], "Ascendant", point_type=point_type)
+                        data["ascendant"].house = get_planet_house(ascmc[0], houses_degree_ut)
+                        data["ascendant"].retrograde = False
+                    elif point == "Sun" and "sun" not in data:
                         sun_calc = swe.calc_ut(julian_day, 0, iflag)[0]
-                        data["sun"] = get_kerykeion_point_from_degree(sun_calc[0], "Sun", point_type=point_type)
+                        data["sun"] = get_kerykeion_point_from_degree(sun_calc[0], "Sun", point_type=point_type, speed=sun_calc[3], declination=sun_calc[1])
                         data["sun"].house = get_planet_house(sun_calc[0], houses_degree_ut)
                         data["sun"].retrograde = sun_calc[3] < 0
-                    elif point == "Moon" and point not in data:
+                    elif point == "Moon" and "moon" not in data:
                         moon_calc = swe.calc_ut(julian_day, 1, iflag)[0]
-                        data["moon"] = get_kerykeion_point_from_degree(moon_calc[0], "Moon", point_type=point_type)
+                        data["moon"] = get_kerykeion_point_from_degree(moon_calc[0], "Moon", point_type=point_type, speed=moon_calc[3], declination=moon_calc[1])
                         data["moon"].house = get_planet_house(moon_calc[0], houses_degree_ut)
                         data["moon"].retrograde = moon_calc[3] < 0
 
@@ -1569,21 +1647,41 @@ class AstrologicalSubjectFactory:
         # Calculate Pars Spiritus (Part of Spirit)
         if should_calculate("Pars_Spiritus"):
             # Auto-activate required points with notification
-            required_points: List[AstrologicalPoint] = ["Ascendant", "Sun", "Moon"]
-            missing_points = [point for point in required_points if point not in active_points]
+            pars_spiritus_required_points: List[AstrologicalPoint] = ["Ascendant", "Sun", "Moon"]
+            missing_points = [point for point in pars_spiritus_required_points if point not in active_points]
             if missing_points:
                 logging.info(f"Automatically adding required points for Pars_Spiritus: {missing_points}")
                 active_points.extend(cast(List[AstrologicalPoint], missing_points))
                 # Recalculate the missing points
                 for point in missing_points:
-                    if point == "Sun" and point not in data:
+                    if point == "Ascendant" and "ascendant" not in data:
+                        # Calculate Ascendant from houses data if needed
+                        if data["zodiac_type"] == "Sidereal":
+                            cusps, ascmc = swe.houses_ex(
+                                tjdut=data["julian_day"],
+                                lat=data["lat"],
+                                lon=data["lng"],
+                                hsys=str.encode(data["houses_system_identifier"]),
+                                flags=swe.FLG_SIDEREAL
+                            )
+                        else:
+                            cusps, ascmc = swe.houses(
+                                tjdut=data["julian_day"],
+                                lat=data["lat"],
+                                lon=data["lng"],
+                                hsys=str.encode(data["houses_system_identifier"])
+                            )
+                        data["ascendant"] = get_kerykeion_point_from_degree(ascmc[0], "Ascendant", point_type=point_type)
+                        data["ascendant"].house = get_planet_house(ascmc[0], houses_degree_ut)
+                        data["ascendant"].retrograde = False
+                    elif point == "Sun" and "sun" not in data:
                         sun_calc = swe.calc_ut(julian_day, 0, iflag)[0]
-                        data["sun"] = get_kerykeion_point_from_degree(sun_calc[0], "Sun", point_type=point_type)
+                        data["sun"] = get_kerykeion_point_from_degree(sun_calc[0], "Sun", point_type=point_type, speed=sun_calc[3], declination=sun_calc[1])
                         data["sun"].house = get_planet_house(sun_calc[0], houses_degree_ut)
                         data["sun"].retrograde = sun_calc[3] < 0
-                    elif point == "Moon" and point not in data:
+                    elif point == "Moon" and "moon" not in data:
                         moon_calc = swe.calc_ut(julian_day, 1, iflag)[0]
-                        data["moon"] = get_kerykeion_point_from_degree(moon_calc[0], "Moon", point_type=point_type)
+                        data["moon"] = get_kerykeion_point_from_degree(moon_calc[0], "Moon", point_type=point_type, speed=moon_calc[3], declination=moon_calc[1])
                         data["moon"].house = get_planet_house(moon_calc[0], houses_degree_ut)
                         data["moon"].retrograde = moon_calc[3] < 0
 
@@ -1609,21 +1707,41 @@ class AstrologicalSubjectFactory:
         # Calculate Pars Amoris (Part of Eros/Love)
         if should_calculate("Pars_Amoris"):
             # Auto-activate required points with notification
-            required_points: List[AstrologicalPoint] = ["Ascendant", "Venus", "Sun"]
-            missing_points = [point for point in required_points if point not in active_points]
+            pars_amoris_required_points: List[AstrologicalPoint] = ["Ascendant", "Venus", "Sun"]
+            missing_points = [point for point in pars_amoris_required_points if point not in active_points]
             if missing_points:
                 logging.info(f"Automatically adding required points for Pars_Amoris: {missing_points}")
                 active_points.extend(cast(List[AstrologicalPoint], missing_points))
                 # Recalculate the missing points
                 for point in missing_points:
-                    if point == "Sun" and point not in data:
+                    if point == "Ascendant" and "ascendant" not in data:
+                        # Calculate Ascendant from houses data if needed
+                        if data["zodiac_type"] == "Sidereal":
+                            cusps, ascmc = swe.houses_ex(
+                                tjdut=data["julian_day"],
+                                lat=data["lat"],
+                                lon=data["lng"],
+                                hsys=str.encode(data["houses_system_identifier"]),
+                                flags=swe.FLG_SIDEREAL
+                            )
+                        else:
+                            cusps, ascmc = swe.houses(
+                                tjdut=data["julian_day"],
+                                lat=data["lat"],
+                                lon=data["lng"],
+                                hsys=str.encode(data["houses_system_identifier"])
+                            )
+                        data["ascendant"] = get_kerykeion_point_from_degree(ascmc[0], "Ascendant", point_type=point_type)
+                        data["ascendant"].house = get_planet_house(ascmc[0], houses_degree_ut)
+                        data["ascendant"].retrograde = False
+                    elif point == "Sun" and "sun" not in data:
                         sun_calc = swe.calc_ut(julian_day, 0, iflag)[0]
-                        data["sun"] = get_kerykeion_point_from_degree(sun_calc[0], "Sun", point_type=point_type)
+                        data["sun"] = get_kerykeion_point_from_degree(sun_calc[0], "Sun", point_type=point_type, speed=sun_calc[3], declination=sun_calc[1])
                         data["sun"].house = get_planet_house(sun_calc[0], houses_degree_ut)
                         data["sun"].retrograde = sun_calc[3] < 0
-                    elif point == "Venus" and point not in data:
+                    elif point == "Venus" and "venus" not in data:
                         venus_calc = swe.calc_ut(julian_day, 3, iflag)[0]
-                        data["venus"] = get_kerykeion_point_from_degree(venus_calc[0], "Venus", point_type=point_type)
+                        data["venus"] = get_kerykeion_point_from_degree(venus_calc[0], "Venus", point_type=point_type, speed=venus_calc[3], declination=venus_calc[1])
                         data["venus"].house = get_planet_house(venus_calc[0], houses_degree_ut)
                         data["venus"].retrograde = venus_calc[3] < 0
 
@@ -1640,21 +1758,41 @@ class AstrologicalSubjectFactory:
         # Calculate Pars Fidei (Part of Faith)
         if should_calculate("Pars_Fidei"):
             # Auto-activate required points with notification
-            required_points: List[AstrologicalPoint] = ["Ascendant", "Jupiter", "Saturn"]
-            missing_points = [point for point in required_points if point not in active_points]
+            pars_fidei_required_points: List[AstrologicalPoint] = ["Ascendant", "Jupiter", "Saturn"]
+            missing_points = [point for point in pars_fidei_required_points if point not in active_points]
             if missing_points:
                 logging.info(f"Automatically adding required points for Pars_Fidei: {missing_points}")
                 active_points.extend(cast(List[AstrologicalPoint], missing_points))
                 # Recalculate the missing points
                 for point in missing_points:
-                    if point == "Jupiter" and point not in data:
+                    if point == "Ascendant" and "ascendant" not in data:
+                        # Calculate Ascendant from houses data if needed
+                        if data["zodiac_type"] == "Sidereal":
+                            cusps, ascmc = swe.houses_ex(
+                                tjdut=data["julian_day"],
+                                lat=data["lat"],
+                                lon=data["lng"],
+                                hsys=str.encode(data["houses_system_identifier"]),
+                                flags=swe.FLG_SIDEREAL
+                            )
+                        else:
+                            cusps, ascmc = swe.houses(
+                                tjdut=data["julian_day"],
+                                lat=data["lat"],
+                                lon=data["lng"],
+                                hsys=str.encode(data["houses_system_identifier"])
+                            )
+                        data["ascendant"] = get_kerykeion_point_from_degree(ascmc[0], "Ascendant", point_type=point_type)
+                        data["ascendant"].house = get_planet_house(ascmc[0], houses_degree_ut)
+                        data["ascendant"].retrograde = False
+                    elif point == "Jupiter" and "jupiter" not in data:
                         jupiter_calc = swe.calc_ut(julian_day, 5, iflag)[0]
-                        data["jupiter"] = get_kerykeion_point_from_degree(jupiter_calc[0], "Jupiter", point_type=point_type)
+                        data["jupiter"] = get_kerykeion_point_from_degree(jupiter_calc[0], "Jupiter", point_type=point_type, speed=jupiter_calc[3], declination=jupiter_calc[1])
                         data["jupiter"].house = get_planet_house(jupiter_calc[0], houses_degree_ut)
                         data["jupiter"].retrograde = jupiter_calc[3] < 0
-                    elif point == "Saturn" and point not in data:
+                    elif point == "Saturn" and "saturn" not in data:
                         saturn_calc = swe.calc_ut(julian_day, 6, iflag)[0]
-                        data["saturn"] = get_kerykeion_point_from_degree(saturn_calc[0], "Saturn", point_type=point_type)
+                        data["saturn"] = get_kerykeion_point_from_degree(saturn_calc[0], "Saturn", point_type=point_type, speed=saturn_calc[3], declination=saturn_calc[1])
                         data["saturn"].house = get_planet_house(saturn_calc[0], houses_degree_ut)
                         data["saturn"].retrograde = saturn_calc[3] < 0
 
@@ -1668,8 +1806,8 @@ class AstrologicalSubjectFactory:
                 data["pars_fidei"].retrograde = False
                 calculated_planets.append("Pars_Fidei")
 
-        # Calculate Vertex (a sort of auxiliary Descendant)
-        if should_calculate("Vertex"):
+        # Calculate Vertex and/or Anti-Vertex
+        if should_calculate("Vertex") or should_calculate("Anti_Vertex"):
             try:
                 # Vertex is at ascmc[3] in Swiss Ephemeris
                 if data["zodiac_type"] == "Sidereal":
@@ -1689,58 +1827,71 @@ class AstrologicalSubjectFactory:
                     )
 
                 vertex_deg = ascmc[3]
-                data["vertex"] = get_kerykeion_point_from_degree(vertex_deg, "Vertex", point_type=point_type)
-                data["vertex"].house = get_planet_house(vertex_deg, houses_degree_ut)
-                data["vertex"].retrograde = False
-                calculated_planets.append("Vertex")
-
-                # Calculate Anti-Vertex (opposite to Vertex)
-                anti_vertex_deg = math.fmod(vertex_deg + 180, 360)
-                data["anti_vertex"] = get_kerykeion_point_from_degree(anti_vertex_deg, "Anti_Vertex", point_type=point_type)
-                data["anti_vertex"].house = get_planet_house(anti_vertex_deg, houses_degree_ut)
-                data["anti_vertex"].retrograde = False
-                calculated_planets.append("Anti_Vertex")
+
+                # Calculate Vertex if requested
+                if should_calculate("Vertex"):
+                    data["vertex"] = get_kerykeion_point_from_degree(vertex_deg, "Vertex", point_type=point_type)
+                    data["vertex"].house = get_planet_house(vertex_deg, houses_degree_ut)
+                    data["vertex"].retrograde = False
+                    calculated_planets.append("Vertex")
+
+                # Calculate Anti-Vertex if requested
+                if should_calculate("Anti_Vertex"):
+                    anti_vertex_deg = math.fmod(vertex_deg + 180, 360)
+                    data["anti_vertex"] = get_kerykeion_point_from_degree(anti_vertex_deg, "Anti_Vertex", point_type=point_type)
+                    data["anti_vertex"].house = get_planet_house(anti_vertex_deg, houses_degree_ut)
+                    data["anti_vertex"].retrograde = False
+                    calculated_planets.append("Anti_Vertex")
+
             except Exception as e:
-                logging.warning("Could not calculate Vertex position, error: %s", e)
-                active_points.remove("Vertex")
+                logging.warning("Could not calculate Vertex/Anti-Vertex position, error: %s", e)
+                if "Vertex" in active_points:
+                    active_points.remove("Vertex")
+                if "Anti_Vertex" in active_points:
+                    active_points.remove("Anti_Vertex")
 
         # Store only the planets that were actually calculated
-        data["active_points"] = calculated_planets
+        all_calculated_points = calculated_planets.copy()
+        if calculated_axial_cusps:
+            all_calculated_points.extend(calculated_axial_cusps)
+        data["active_points"] = all_calculated_points
 
-    @classmethod
-    def _calculate_day_of_week(cls, data: Dict[str, Any]) -> None:
+    @staticmethod
+    def _calculate_day_of_week(data: Dict[str, Any]) -> None:
         """
         Calculate the day of the week for the given astronomical event.
 
-        Determines the day of the week corresponding to the Julian Day Number
-        of the astrological event using Swiss Ephemeris calendar functions.
+        Determines the day of the week corresponding to the local datetime
+        using the standard library for consistency.
 
         Args:
-            data (Dict[str, Any]): Calculation data dictionary containing julian_day.
-                Updated with the calculated day_of_week string.
+            data (Dict[str, Any]): Calculation data dictionary containing
+                iso_formatted_local_datetime. Updated with the calculated day_of_week string.
 
         Side Effects:
             Updates data dictionary with:
             - day_of_week: Human-readable day name (e.g., "Monday", "Tuesday")
-
-        Note:
-            The Swiss Ephemeris day_of_week function returns an integer where
-            0=Monday, 1=Tuesday, ..., 6=Sunday. This is converted to readable
-            day names for user convenience.
         """
-        # Calculate the day of the week (0=Sunday, 1=Monday, ..., 6=Saturday)
-        day_of_week = swe.day_of_week(data["julian_day"])
-        # Map to human-readable names
-        days_of_week = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
-        data["day_of_week"] = days_of_week[day_of_week]
+        dt = datetime.fromisoformat(data["iso_formatted_local_datetime"])
+        data["day_of_week"] = dt.strftime("%A")
 
 if __name__ == "__main__":
+    from kerykeion.schemas.kr_literals import AstrologicalPoint
+
     # Example usage
-    subject = AstrologicalSubjectFactory.from_current_time(name="Test Subject")
+    new_active_points: List[AstrologicalPoint] = ['Sun', 'Moon', 'Mercury', 'Venus', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune', 'Pluto', 'Mean_North_Lunar_Node', 'True_North_Lunar_Node', 'Mean_South_Lunar_Node', 'True_South_Lunar_Node', 'Chiron', 'Mean_Lilith', 'True_Lilith', 'Earth', 'Pholus', 'Ceres', 'Pallas', 'Juno', 'Vesta', 'Eris', 'Sedna', 'Haumea', 'Makemake', 'Ixion', 'Orcus', 'Quaoar', 'Regulus', 'Spica', 'Pars_Fortunae', 'Pars_Spiritus', 'Pars_Amoris', 'Pars_Fidei', 'Vertex', 'Anti_Vertex', 'Ascendant', 'Medium_Coeli', 'Descendant', 'Imum_Coeli']
+    subject = AstrologicalSubjectFactory.from_current_time(name="Test Subject", active_points=new_active_points)
     print(subject.sun)
     print(subject.pars_amoris)
     print(subject.eris)
     print(subject.active_points)
+    print(subject.pars_fidei)
+    print("----")
+    print(subject.anti_vertex)
 
     # Create JSON output
     json_string = subject.model_dump_json(exclude_none=True, indent=2)
+
+    # Write JSON to home
+    with open(Path.home() / "kerykeion_subject_example.json", "w", encoding="utf-8") as f:
+        f.write(json_string)