kerykeion 5.0.0a9__tar.gz → 5.0.0a10__tar.gz

{kerykeion-5.0.0a9 → kerykeion-5.0.0a10}/.gitignore

@@ -51,4 +51,4 @@ dist/
 kr_venv
 request_cache
 Pipfile
-.mypy_cache
+.mypy_cache

{kerykeion-5.0.0a9 → kerykeion-5.0.0a10}/PKG-INFO

@@ -1,23 +1,28 @@
 Metadata-Version: 2.4
 Name: kerykeion
-Version: 5.0.0a9
-Summary: A python library for astrology.
+Version: 5.0.0a10
+Summary: A Python library for astrological calculations, including natal charts, houses, planetary aspects, and SVG chart generation.
 Project-URL: Homepage, https://www.kerykeion.net/
 Project-URL: Repository, https://github.com/g-battaglia/kerykeion
 Author-email: Giacomo Battaglia <kerykeion.astrology@gmail.com>
 License: AGPL-3.0
 License-File: LICENSE
-Keywords: astrology,astrology library,astrology-calculator,astronomical-algorithms,birtchart,ephemeris,svg,synastry,zodiac,zodiac-sing
+Keywords: astrology,astrology calculations,astrology calculator,astrology library,astrology transits,astronomical algorithms,birth chart,ephemeris,houses of astrology,natal chart,planetary aspects,svg charts,synastry,zodiac,zodiac signs
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Information Technology
-Classifier: License :: OSI Approved :: GNU General Public License (GPL)
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Religion
 Classifier: Topic :: Scientific/Engineering :: Astronomy
+Classifier: Topic :: Scientific/Engineering :: Visualization
 Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules

{kerykeion-5.0.0a9 → kerykeion-5.0.0a10}/kerykeion/__init__.py

@@ -6,7 +6,7 @@ This is part of Kerykeion (C) 2025 Giacomo Battaglia
 """
 
 # Local
-from .aspects import SynastryAspects, NatalAspects
+from .aspects import SynastryAspectsFactory, NatalAspectsFactory
 from .astrological_subject_factory import AstrologicalSubjectFactory
 from .charts.kerykeion_chart_svg import KerykeionChartSVG
 from .composite_subject_factory import CompositeSubjectFactory
@@ -20,3 +20,24 @@ from .relationship_score_factory import RelationshipScoreFactory
 from .report import Report
 from .settings import KerykeionSettingsModel, get_settings
 from .transits_time_range import TransitsTimeRangeFactory
+
+__all__ = [
+    "SynastryAspectsFactory",
+    "NatalAspectsFactory",
+    "AstrologicalSubjectFactory",
+    "KerykeionChartSVG",
+    "CompositeSubjectFactory",
+    "Planets",
+    "Aspects",
+    "Signs",
+    "EphemerisDataFactory",
+    "HouseComparisonFactory",
+    "HouseComparisonModel",
+    "PlanetaryReturnFactory",
+    "PlanetReturnModel",
+    "RelationshipScoreFactory",
+    "Report",
+    "KerykeionSettingsModel",
+    "get_settings",
+    "TransitsTimeRangeFactory",
+]

{kerykeion-5.0.0a9 → kerykeion-5.0.0a10}/kerykeion/aspects/__init__.py

@@ -7,5 +7,10 @@ The aspects module contains the classes and functions for calculating
 """
 
 
-from .synastry_aspects import SynastryAspects
-from .natal_aspects import NatalAspects
+from .synastry_aspects_factory import SynastryAspectsFactory
+from .natal_aspects_factory import NatalAspectsFactory
+
+__all__ = [
+    "SynastryAspectsFactory",
+    "NatalAspectsFactory",
+]

{kerykeion-5.0.0a9 → kerykeion-5.0.0a10}/kerykeion/aspects/aspects_utils.py

@@ -4,17 +4,15 @@
 """
 # TODO: Better documentation and unit tests
 
-from kerykeion.settings import KerykeionSettingsModel
 from swisseph import difdeg2n
 from typing import Union, TYPE_CHECKING
 from kerykeion.kr_types.kr_models import AstrologicalSubjectModel, CompositeSubjectModel, PlanetReturnModel
-from kerykeion.kr_types.kr_literals import AstrologicalPoint
 from kerykeion.kr_types.settings_models import KerykeionSettingsCelestialPointModel
 from kerykeion.settings.legacy.legacy_celestial_points_settings import DEFAULT_CELESTIAL_POINTS_SETTINGS
 
 
 if TYPE_CHECKING:
-    from kerykeion import AstrologicalSubjectFactory
+    pass
 
 def get_aspect_from_two_points(
     aspects_settings: Union[list[dict], list[dict]],

kerykeion-5.0.0a10/kerykeion/aspects/natal_aspects_factory.py

@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+"""
+    This is part of Kerykeion (C) 2025 Giacomo Battaglia
+"""
+
+import logging
+from pathlib import Path
+from typing import Union, List, Optional
+
+from kerykeion.astrological_subject_factory import AstrologicalSubjectFactory
+from kerykeion.aspects.aspects_utils import get_aspect_from_two_points, get_active_points_list
+from kerykeion.kr_types.kr_models import AstrologicalSubjectModel, AspectModel, ActiveAspect, CompositeSubjectModel, PlanetReturnModel, NatalAspectsModel
+from kerykeion.kr_types.kr_literals import AstrologicalPoint
+from kerykeion.kr_types.settings_models import KerykeionSettingsModel
+from kerykeion.settings.config_constants import DEFAULT_ACTIVE_ASPECTS, DEFAULT_AXIS_ORBIT
+from kerykeion.settings.legacy.legacy_celestial_points_settings import DEFAULT_CELESTIAL_POINTS_SETTINGS
+from kerykeion.settings.legacy.legacy_chart_aspects_settings import DEFAULT_CHART_ASPECTS_SETTINGS
+from kerykeion.utilities import find_common_active_points
+
+# Axes constants for orb filtering
+AXES_LIST = [
+    "Ascendant",
+    "Medium_Coeli",
+    "Descendant",
+    "Imum_Coeli",
+]
+
+
+class NatalAspectsFactory:
+    """
+    Factory class for creating natal aspects analysis.
+
+    This factory calculates all aspects in a birth chart and provides both
+    comprehensive and filtered aspect lists based on orb settings and relevance.
+    """
+
+    @staticmethod
+    def from_subject(
+        user: Union[AstrologicalSubjectModel, CompositeSubjectModel, PlanetReturnModel],
+        new_settings_file: Union[Path, KerykeionSettingsModel, dict, None] = None,
+        active_points: Optional[List[AstrologicalPoint]] = None,
+        active_aspects: Optional[List[ActiveAspect]] = None,
+    ) -> NatalAspectsModel:
+        """
+        Create natal aspects analysis from an existing astrological subject.
+
+        Args:
+            user: The astrological subject for aspect calculation
+            new_settings_file: Custom settings file or settings model
+            active_points: List of points to include in calculations
+            active_aspects: List of aspects with their orb settings
+
+        Returns:
+            NatalAspectsModel containing all calculated aspects data
+        """
+        # Initialize settings and configurations
+        celestial_points = DEFAULT_CELESTIAL_POINTS_SETTINGS
+        aspects_settings = DEFAULT_CHART_ASPECTS_SETTINGS
+        axes_orbit_settings = DEFAULT_AXIS_ORBIT
+
+        # Set active aspects with default fallback
+        active_aspects_resolved = active_aspects if active_aspects is not None else DEFAULT_ACTIVE_ASPECTS
+
+        # Determine active points to use
+        if active_points is None:
+            active_points_resolved = user.active_points
+        else:
+            active_points_resolved = find_common_active_points(
+                user.active_points,
+                active_points,
+            )
+
+        return NatalAspectsFactory._create_natal_aspects_model(
+            user, active_points_resolved, active_aspects_resolved,
+            aspects_settings, axes_orbit_settings, celestial_points
+        )
+
+    @staticmethod
+    def _create_natal_aspects_model(
+        user: Union[AstrologicalSubjectModel, CompositeSubjectModel, PlanetReturnModel],
+        active_points_resolved: List[AstrologicalPoint],
+        active_aspects_resolved: List[ActiveAspect],
+        aspects_settings: List[dict],
+        axes_orbit_settings: float,
+        celestial_points: List[dict]
+    ) -> NatalAspectsModel:
+        """
+        Create the complete natal aspects model with all calculations.
+
+        Returns:
+            NatalAspectsModel containing all aspects data
+        """
+        all_aspects = NatalAspectsFactory._calculate_all_aspects(
+            user, active_points_resolved, active_aspects_resolved, aspects_settings, celestial_points
+        )
+        relevant_aspects = NatalAspectsFactory._filter_relevant_aspects(all_aspects, axes_orbit_settings)
+
+        return NatalAspectsModel(
+            subject=user,
+            all_aspects=all_aspects,
+            relevant_aspects=relevant_aspects,
+            active_points=active_points_resolved,
+            active_aspects=active_aspects_resolved,
+        )
+
+    @staticmethod
+    def _calculate_all_aspects(
+        user: Union[AstrologicalSubjectModel, CompositeSubjectModel, PlanetReturnModel],
+        active_points: List[AstrologicalPoint],
+        active_aspects: List[ActiveAspect],
+        aspects_settings: List[dict],
+        celestial_points: List[dict]
+    ) -> List[AspectModel]:
+        """
+        Calculate all aspects between active points in the natal chart.
+
+        This method handles all aspect calculations including settings updates,
+        opposite pair filtering, and planet ID resolution in a single comprehensive method.
+
+        Returns:
+            List of all calculated AspectModel instances
+        """
+        active_points_list = get_active_points_list(user, active_points)
+
+        # Update aspects settings with active aspects orbs
+        filtered_settings = []
+        for aspect_setting in aspects_settings:
+            for active_aspect in active_aspects:
+                if aspect_setting["name"] == active_aspect["name"]:
+                    aspect_setting = aspect_setting.copy()  # Don't modify original
+                    aspect_setting["orb"] = active_aspect["orb"]
+                    filtered_settings.append(aspect_setting)
+                    break
+
+        # Define opposite pairs that should be skipped
+        opposite_pairs = {
+            ("Ascendant", "Descendant"),
+            ("Descendant", "Ascendant"),
+            ("Medium_Coeli", "Imum_Coeli"),
+            ("Imum_Coeli", "Medium_Coeli"),
+            ("True_Node", "True_South_Node"),
+            ("Mean_Node", "Mean_South_Node"),
+            ("True_South_Node", "True_Node"),
+            ("Mean_South_Node", "Mean_Node"),
+        }
+
+        all_aspects_list = []
+
+        for first in range(len(active_points_list)):
+            # Generate aspects list without repetitions
+            for second in range(first + 1, len(active_points_list)):
+                # Skip predefined opposite pairs (AC/DC, MC/IC, North/South nodes)
+                first_name = active_points_list[first]["name"]
+                second_name = active_points_list[second]["name"]
+
+                if (first_name, second_name) in opposite_pairs:
+                    continue
+
+                aspect = get_aspect_from_two_points(
+                    filtered_settings,
+                    active_points_list[first]["abs_pos"],
+                    active_points_list[second]["abs_pos"]
+                )
+
+                if aspect["verdict"]:
+                    # Get planet IDs directly from celestial points settings
+                    first_planet_id = 0
+                    second_planet_id = 0
+
+                    for planet in celestial_points:
+                        if planet["name"] == first_name:
+                            first_planet_id = planet["id"]
+                        if planet["name"] == second_name:
+                            second_planet_id = planet["id"]
+
+                    aspect_model = AspectModel(
+                        p1_name=first_name,
+                        p1_owner=user.name,
+                        p1_abs_pos=active_points_list[first]["abs_pos"],
+                        p2_name=second_name,
+                        p2_owner=user.name,
+                        p2_abs_pos=active_points_list[second]["abs_pos"],
+                        aspect=aspect["name"],
+                        orbit=aspect["orbit"],
+                        aspect_degrees=aspect["aspect_degrees"],
+                        diff=aspect["diff"],
+                        p1=first_planet_id,
+                        p2=second_planet_id,
+                    )
+                    all_aspects_list.append(aspect_model)
+
+        return all_aspects_list
+
+    @staticmethod
+    def _filter_relevant_aspects(all_aspects: List[AspectModel], axes_orbit_settings: float) -> List[AspectModel]:
+        """
+        Filter aspects based on orb thresholds for axes and other comprehensive criteria.
+
+        This method consolidates all filtering logic including axes checks and orb thresholds
+        into a single comprehensive filtering method.
+
+        Args:
+            all_aspects: Complete list of calculated aspects
+            axes_orbit_settings: Orb threshold for axes aspects
+
+        Returns:
+            Filtered list of relevant aspects
+        """
+        logging.debug("Calculating relevant aspects by filtering orbs...")
+
+        relevant_aspects = []
+
+        for aspect in all_aspects:
+            # Check if aspect involves any of the chart axes and apply stricter orb limits
+            aspect_involves_axes = (aspect.p1_name in AXES_LIST or aspect.p2_name in AXES_LIST)
+
+            if aspect_involves_axes and abs(aspect.orbit) >= axes_orbit_settings:
+                continue
+
+            relevant_aspects.append(aspect)
+
+        return relevant_aspects
+
+
+if __name__ == "__main__":
+    from kerykeion.utilities import setup_logging
+
+    setup_logging(level="debug")
+
+    # Create subject using AstrologicalSubjectFactory
+    johnny = AstrologicalSubjectFactory.from_birth_data("Johnny Depp", 1963, 6, 9, 0, 0, city="Owensboro", nation="US")
+
+    # Create aspects analysis from subject
+    natal_aspects = NatalAspectsFactory.from_subject(johnny)
+    print(f"All aspects count: {len(natal_aspects.all_aspects)}")
+    print(f"Relevant aspects count: {len(natal_aspects.relevant_aspects)}")

kerykeion-5.0.0a10/kerykeion/aspects/synastry_aspects_factory.py

@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+"""
+    This is part of Kerykeion (C) 2025 Giacomo Battaglia
+"""
+
+import logging
+from pathlib import Path
+from typing import Union, List, Optional
+
+from kerykeion.astrological_subject_factory import AstrologicalSubjectFactory
+from kerykeion.aspects.aspects_utils import get_aspect_from_two_points, get_active_points_list
+from kerykeion.kr_types.kr_models import AstrologicalSubjectModel, AspectModel, ActiveAspect, CompositeSubjectModel, PlanetReturnModel, SynastryAspectsModel
+from kerykeion.kr_types.settings_models import KerykeionSettingsModel
+from kerykeion.settings.config_constants import DEFAULT_ACTIVE_ASPECTS, DEFAULT_AXIS_ORBIT
+from kerykeion.settings.legacy.legacy_celestial_points_settings import DEFAULT_CELESTIAL_POINTS_SETTINGS
+from kerykeion.settings.legacy.legacy_chart_aspects_settings import DEFAULT_CHART_ASPECTS_SETTINGS
+from kerykeion.kr_types.kr_literals import AstrologicalPoint
+from kerykeion.utilities import find_common_active_points
+
+
+# Axes constants for orb filtering
+AXES_LIST = [
+    "Ascendant",
+    "Medium_Coeli",
+    "Descendant",
+    "Imum_Coeli",
+]
+
+
+class SynastryAspectsFactory:
+    """
+    Factory class for creating synastry aspects analysis between two subjects.
+
+    This factory calculates all aspects between two charts and provides both
+    comprehensive and filtered aspect lists based on orb settings and relevance.
+    """
+
+    @staticmethod
+    def from_subjects(
+        first_subject: Union[AstrologicalSubjectModel, CompositeSubjectModel, PlanetReturnModel],
+        second_subject: Union[AstrologicalSubjectModel, CompositeSubjectModel, PlanetReturnModel],
+        new_settings_file: Union[Path, KerykeionSettingsModel, dict, None] = None,
+        active_points: Optional[List[AstrologicalPoint]] = None,
+        active_aspects: Optional[List[ActiveAspect]] = None,
+    ) -> SynastryAspectsModel:
+        """
+        Create synastry aspects analysis from two existing astrological subjects.
+
+        Args:
+            first_subject: The first astrological subject
+            second_subject: The second astrological subject
+            new_settings_file: Custom settings file or settings model
+            active_points: List of points to include in calculations
+            active_aspects: List of aspects with their orb settings
+
+        Returns:
+            SynastryAspectsModel containing all calculated aspects data
+        """
+        # Initialize settings and configurations
+        celestial_points = DEFAULT_CELESTIAL_POINTS_SETTINGS
+        aspects_settings = DEFAULT_CHART_ASPECTS_SETTINGS
+        axes_orbit_settings = DEFAULT_AXIS_ORBIT
+
+        # Set active aspects with default fallback
+        active_aspects_resolved = active_aspects if active_aspects is not None else DEFAULT_ACTIVE_ASPECTS
+
+        # Determine active points to use - find common points between both subjects
+        if active_points is None:
+            active_points_resolved = first_subject.active_points
+        else:
+            active_points_resolved = find_common_active_points(
+                first_subject.active_points,
+                active_points,
+            )
+
+        # Further filter with second subject's active points
+        active_points_resolved = find_common_active_points(
+            second_subject.active_points,
+            active_points_resolved,
+        )
+
+        return SynastryAspectsFactory._create_synastry_aspects_model(
+            first_subject, second_subject, active_points_resolved, active_aspects_resolved,
+            aspects_settings, axes_orbit_settings, celestial_points
+        )
+
+    @staticmethod
+    def _create_synastry_aspects_model(
+        first_subject: Union[AstrologicalSubjectModel, CompositeSubjectModel, PlanetReturnModel],
+        second_subject: Union[AstrologicalSubjectModel, CompositeSubjectModel, PlanetReturnModel],
+        active_points_resolved: List[AstrologicalPoint],
+        active_aspects_resolved: List[ActiveAspect],
+        aspects_settings: List[dict],
+        axes_orbit_settings: float,
+        celestial_points: List[dict]
+    ) -> SynastryAspectsModel:
+        """
+        Create the complete synastry aspects model with all calculations.
+
+        Returns:
+            SynastryAspectsModel containing all aspects data
+        """
+        all_aspects = SynastryAspectsFactory._calculate_all_aspects(
+            first_subject, second_subject, active_points_resolved, active_aspects_resolved,
+            aspects_settings, celestial_points
+        )
+        relevant_aspects = SynastryAspectsFactory._filter_relevant_aspects(all_aspects, axes_orbit_settings)
+
+        return SynastryAspectsModel(
+            first_subject=first_subject,
+            second_subject=second_subject,
+            all_aspects=all_aspects,
+            relevant_aspects=relevant_aspects,
+            active_points=active_points_resolved,
+            active_aspects=active_aspects_resolved,
+        )
+
+    @staticmethod
+    def _calculate_all_aspects(
+        first_subject: Union[AstrologicalSubjectModel, CompositeSubjectModel, PlanetReturnModel],
+        second_subject: Union[AstrologicalSubjectModel, CompositeSubjectModel, PlanetReturnModel],
+        active_points: List[AstrologicalPoint],
+        active_aspects: List[ActiveAspect],
+        aspects_settings: List[dict],
+        celestial_points: List[dict]
+    ) -> List[AspectModel]:
+        """
+        Calculate all synastry aspects between two subjects.
+
+        This method handles all aspect calculations including settings updates
+        and planet ID resolution in a single comprehensive method.
+
+        Returns:
+            List of all calculated AspectModel instances
+        """
+        # Get active points lists for both subjects
+        first_active_points_list = get_active_points_list(first_subject, active_points)
+        second_active_points_list = get_active_points_list(second_subject, active_points)
+
+        # Update aspects settings with active aspects orbs
+        filtered_settings = []
+        for aspect_setting in aspects_settings:
+            for active_aspect in active_aspects:
+                if aspect_setting["name"] == active_aspect["name"]:
+                    aspect_setting = aspect_setting.copy()  # Don't modify original
+                    aspect_setting["orb"] = active_aspect["orb"]
+                    filtered_settings.append(aspect_setting)
+                    break
+
+        all_aspects_list = []
+        for first in range(len(first_active_points_list)):
+            # Generate aspects list between all points of first and second subjects
+            for second in range(len(second_active_points_list)):
+                aspect = get_aspect_from_two_points(
+                    filtered_settings,
+                    first_active_points_list[first]["abs_pos"],
+                    second_active_points_list[second]["abs_pos"],
+                )
+
+                if aspect["verdict"]:
+                    # Get planet IDs directly from celestial points settings
+                    first_planet_id = 0
+                    second_planet_id = 0
+
+                    first_name = first_active_points_list[first]["name"]
+                    second_name = second_active_points_list[second]["name"]
+
+                    for planet in celestial_points:
+                        if planet["name"] == first_name:
+                            first_planet_id = planet["id"]
+                        if planet["name"] == second_name:
+                            second_planet_id = planet["id"]
+
+                    aspect_model = AspectModel(
+                        p1_name=first_name,
+                        p1_owner=first_subject.name,
+                        p1_abs_pos=first_active_points_list[first]["abs_pos"],
+                        p2_name=second_name,
+                        p2_owner=second_subject.name,
+                        p2_abs_pos=second_active_points_list[second]["abs_pos"],
+                        aspect=aspect["name"],
+                        orbit=aspect["orbit"],
+                        aspect_degrees=aspect["aspect_degrees"],
+                        diff=aspect["diff"],
+                        p1=first_planet_id,
+                        p2=second_planet_id,
+                    )
+                    all_aspects_list.append(aspect_model)
+
+        return all_aspects_list
+
+    @staticmethod
+    def _filter_relevant_aspects(all_aspects: List[AspectModel], axes_orbit_settings: float) -> List[AspectModel]:
+        """
+        Filter aspects based on orb thresholds for axes and comprehensive criteria.
+
+        This method consolidates all filtering logic including axes checks and orb thresholds
+        for synastry aspects in a single comprehensive filtering method.
+
+        Args:
+            all_aspects: Complete list of calculated aspects
+            axes_orbit_settings: Orb threshold for axes aspects
+
+        Returns:
+            Filtered list of relevant aspects
+        """
+        logging.debug("Calculating relevant synastry aspects by filtering orbs...")
+
+        relevant_aspects = []
+
+        for aspect in all_aspects:
+            # Check if aspect involves any of the chart axes and apply stricter orb limits
+            aspect_involves_axes = (aspect.p1_name in AXES_LIST or aspect.p2_name in AXES_LIST)
+
+            if aspect_involves_axes and abs(aspect.orbit) >= axes_orbit_settings:
+                continue
+
+            relevant_aspects.append(aspect)
+
+        return relevant_aspects
+
+
+if __name__ == "__main__":
+    from kerykeion.utilities import setup_logging
+
+    setup_logging(level="debug")
+
+    john = AstrologicalSubjectFactory.from_birth_data("John", 1940, 10, 9, 10, 30, "Liverpool", "GB")
+    yoko = AstrologicalSubjectFactory.from_birth_data("Yoko", 1933, 2, 18, 10, 30, "Tokyo", "JP")
+
+    # Create synastry aspects analysis using the factory
+    synastry_aspects_model = SynastryAspectsFactory.from_subjects(john, yoko)
+    print(f"All synastry aspects: {len(synastry_aspects_model.all_aspects)}")
+    print(f"Relevant synastry aspects: {len(synastry_aspects_model.relevant_aspects)}")

{kerykeion-5.0.0a9 → kerykeion-5.0.0a10}/kerykeion/astrological_subject_factory.py

@@ -6,14 +6,11 @@
 import pytz
 import swisseph as swe
 import logging
-import warnings
 import math
 from datetime import datetime
 from pathlib import Path
-from typing import Union, Optional, List, Dict, Any, Literal, get_args, cast, TypedDict, Set
-from functools import cached_property, lru_cache
+from typing import Optional, List, Dict, Any, get_args, cast
 from dataclasses import dataclass, field
-from typing import Callable
 
 
 from kerykeion.fetch_geonames import FetchGeonames
@@ -21,8 +18,6 @@ from kerykeion.kr_types import (
     KerykeionException,
     ZodiacType,
     AstrologicalSubjectModel,
-    LunarPhaseModel,
-    KerykeionPointModel,
     PointType,
     SiderealMode,
     HousesSystemIdentifier,
@@ -31,7 +26,6 @@ from kerykeion.kr_types import (
     Houses,
 )
 from kerykeion.utilities import (
-    get_number_from_name,
     get_kerykeion_point_from_degree,
     get_planet_house,
     check_and_adjust_polar_latitude,
@@ -527,7 +521,8 @@ class AstrologicalSubjectFactory:
     def _calculate_houses(cls, data: Dict[str, Any], active_points: Optional[List[AstrologicalPoint]]) -> None:
         """Calculate house cusps and axis points"""
         # Skip calculation if point is not in active_points
-        should_calculate: Callable[[AstrologicalPoint], bool] = lambda point: not active_points or point in active_points
+        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 = []
 
@@ -656,7 +651,8 @@ class AstrologicalSubjectFactory:
     def _calculate_planets(cls, data: Dict[str, Any], active_points: List[AstrologicalPoint]) -> None:
         """Calculate planetary positions and related information"""
         # Skip calculation if point is not in active_points
-        should_calculate: Callable[[AstrologicalPoint], bool] = lambda point: not active_points or point in active_points
+        def should_calculate(point: AstrologicalPoint) -> bool:
+            return not active_points or point in active_points
 
         point_type: PointType = "AstrologicalPoint"
         julian_day = data["julian_day"]