kerykeion 5.0.0a9__py3-none-any.whl → 5.0.0a10__py3-none-any.whl

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/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/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/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/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/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"]

kerykeion/charts/charts_utils.py

@@ -2,7 +2,7 @@ import math
 import datetime
 from kerykeion.kr_types import KerykeionException, ChartType
 from kerykeion.kr_types.kr_literals import AstrologicalPoint
-from typing import Union, Literal, TYPE_CHECKING
+from typing import Union, Literal
 from kerykeion.kr_types.kr_models import AspectModel, KerykeionPointModel, CompositeSubjectModel, PlanetReturnModel, AstrologicalSubjectModel
 from kerykeion.kr_types.settings_models import KerykeionLanguageCelestialPointModel, KerykeionSettingsCelestialPointModel
 from kerykeion.house_comparison import HouseComparisonModel
@@ -645,15 +645,15 @@ def draw_houses_cusps_and_text_number(
 
             # Add the house number text for the second subject
             fill_opacity = "0" if chart_type == "Transit" else ".4"
-            path += f'<g kr:node="HouseNumber">'
+            path += '<g kr:node="HouseNumber">'
             path += f'<text style="fill: var(--kerykeion-chart-color-house-number); fill-opacity: {fill_opacity}; font-size: 14px"><tspan x="{xtext - 3}" y="{ytext + 3}">{i + 1}</tspan></text>'
-            path += f"</g>"
+            path += "</g>"
 
             # Add the house cusp line for the second subject
             stroke_opacity = "0" if chart_type == "Transit" else ".3"
-            path += f'<g kr:node="Cusp">'
+            path += '<g kr:node="Cusp">'
             path += f"<line x1='{t_x1}' y1='{t_y1}' x2='{t_x2}' y2='{t_y2}' style='stroke: {t_linecolor}; stroke-width: 1px; stroke-opacity:{stroke_opacity};'/>"
-            path += f"</g>"
+            path += "</g>"
 
         # Adjust dropin based on chart type
         dropin = {"Transit": 84, "Synastry": 84, "Return": 84, "ExternalNatal": 100}.get(chart_type, 48)
@@ -661,14 +661,14 @@ def draw_houses_cusps_and_text_number(
         ytext = sliceToY(0, (r - dropin), text_offset) + dropin
 
         # Add the house cusp line for the first subject
-        path += f'<g kr:node="Cusp">'
+        path += '<g kr:node="Cusp">'
         path += f'<line x1="{x1}" y1="{y1}" x2="{x2}" y2="{y2}" style="stroke: {linecolor}; stroke-width: 1px; stroke-dasharray:3,2; stroke-opacity:.4;"/>'
-        path += f"</g>"
+        path += "</g>"
 
         # Add the house number text for the first subject
-        path += f'<g kr:node="HouseNumber">'
+        path += '<g kr:node="HouseNumber">'
         path += f'<text style="fill: var(--kerykeion-chart-color-house-number); fill-opacity: .6; font-size: 14px"><tspan x="{xtext - 3}" y="{ytext + 3}">{i + 1}</tspan></text>'
-        path += f"</g>"
+        path += "</g>"
 
     return path
 
@@ -740,14 +740,14 @@ def draw_transit_aspect_list(
         inner_path += f'<use x="15" y="0" xlink:href="#orb{id_value}" />'
 
         # Second planet symbol
-        inner_path += f'<g transform="translate(30,0)">'
+        inner_path += '<g transform="translate(30,0)">'
         inner_path += f'<use transform="scale(0.4)" x="0" y="3" xlink:href="#{celestial_point_language[aspect["p2"]]["name"]}" />'
-        inner_path += f"</g>"
+        inner_path += "</g>"
 
         # Difference in degrees
         inner_path += f'<text y="8" x="45" style="fill: var(--kerykeion-chart-color-paper-0); font-size: 10px;">{convert_decimal_to_degree_string(aspect["orbit"])}</text>'
 
-        inner_path += f"</g>"
+        inner_path += "</g>"
 
     out = '<g transform="translate(565,273)">'
     out += f'<text y="-15" x="0" style="fill: var(--kerykeion-chart-color-paper-0); font-size: 14px;">{grid_title}:</text>'