kerykeion 5.0.0a6__py3-none-any.whl → 5.0.0a8__py3-none-any.whl

kerykeion/charts/draw_planets_v2.py

@@ -96,7 +96,12 @@ def draw_planets_v2(
         point_idx = position_index_map[abs_position]
 
         # Find previous and next point positions for distance calculations
-        if position_idx == 0:
+        # Handle special case when there's only one planet
+        if len(sorted_positions) == 1:
+            # With only one planet, there are no adjacent planets
+            prev_position = main_points_abs_positions[point_idx]
+            next_position = main_points_abs_positions[point_idx]
+        elif position_idx == 0:
             prev_position = main_points_abs_positions[position_index_map[sorted_positions[-1]]]
             next_position = main_points_abs_positions[position_index_map[sorted_positions[1]]]
         elif position_idx == len(sorted_positions) - 1:
@@ -107,8 +112,13 @@ def draw_planets_v2(
             next_position = main_points_abs_positions[position_index_map[sorted_positions[position_idx + 1]]]
 
         # Calculate distance to adjacent points
-        distance_to_prev = degreeDiff(prev_position, main_points_abs_positions[point_idx])
-        distance_to_next = degreeDiff(next_position, main_points_abs_positions[point_idx])
+        # When there's only one planet, set distances to a large value to prevent grouping
+        if len(sorted_positions) == 1:
+            distance_to_prev = 360.0  # Maximum possible distance
+            distance_to_next = 360.0  # Maximum possible distance
+        else:
+            distance_to_prev = degreeDiff(prev_position, main_points_abs_positions[point_idx])
+            distance_to_next = degreeDiff(next_position, main_points_abs_positions[point_idx])
 
         # Store position and distance information
         planets_by_position[position_idx] = [point_idx, distance_to_prev, distance_to_next]

kerykeion/charts/draw_planets_v3.py

@@ -0,0 +1,679 @@
+"""
+TODO: Not stable at all, check it very well before using it!
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Union, Optional, List, Dict, Tuple, get_args
+import logging
+
+from kerykeion.charts.charts_utils import degreeDiff, sliceToX, sliceToY, convert_decimal_to_degree_string
+from kerykeion.kr_types import KerykeionException, ChartType, KerykeionPointModel
+from kerykeion.kr_types.settings_models import KerykeionSettingsCelestialPointModel
+from kerykeion.kr_types.kr_literals import Houses
+
+
+class ChartRadius(Enum):
+    """Standard radius values for different chart elements."""
+    ANGLE_TRANSIT = 76
+    ANGLE_NATAL = 40
+    ANGLE_EXTERNAL_NATAL = 30
+    PLANET_PRIMARY = 94
+    PLANET_ALTERNATE = 74
+    PLANET_TRANSIT_PRIMARY = 130
+    PLANET_TRANSIT_ALTERNATE = 110
+    PLANET_EXTERNAL_PRIMARY = 84
+    PLANET_EXTERNAL_ALTERNATE = 64
+
+
+class ChartConstants:
+    """Configuration constants for chart drawing."""
+    PLANET_GROUPING_THRESHOLD = 3.4
+    SECONDARY_GROUPING_THRESHOLD = 2.5
+    ANGLE_INDEX_RANGE = (22, 27)  # ASC, MC, DSC, IC indices
+    SYMBOL_SCALE_FACTOR = 0.8
+    SYMBOL_SIZE = 12
+    MAX_DEGREE_DISTANCE = 360.0
+
+    # Line styling
+    LINE_OPACITY_PRIMARY = 0.3
+    LINE_OPACITY_SECONDARY = 0.5
+    LINE_WIDTH_THIN = 1
+    LINE_WIDTH_THICK = 2
+
+    # Text styling
+    TEXT_SIZE = 10
+
+
+@dataclass
+class PointPosition:
+    """Represents a celestial point's position and distance information."""
+    index: int
+    position_index: int
+    distance_to_prev: float
+    distance_to_next: float
+    label: str
+
+
+@dataclass
+class ChartConfiguration:
+    """Configuration for chart drawing parameters."""
+    radius: float
+    third_circle_radius: float
+    first_house_degree: float
+    seventh_house_degree: float
+    chart_type: ChartType
+    scale_factor: float = 1.0
+
+    def __post_init__(self):
+        """Set scale factor based on chart type."""
+        if self.chart_type in ["Transit", "Synastry", "Return", "ExternalNatal"]:
+            self.scale_factor = ChartConstants.SYMBOL_SCALE_FACTOR
+
+
+class CelestialPointGrouper:
+    """Handles grouping of celestial points that are close together."""
+
+    def __init__(self, threshold: float = ChartConstants.PLANET_GROUPING_THRESHOLD):
+        self.threshold = threshold
+
+    def create_position_mapping(
+        self,
+        celestial_points: List[KerykeionPointModel],
+        settings: List[KerykeionSettingsCelestialPointModel]
+    ) -> Tuple[Dict[float, int], List[float]]:
+        """Create mapping from absolute positions to point indices."""
+        position_index_map = {}
+        for i, point in enumerate(celestial_points):
+            position_index_map[point.abs_pos] = i
+            logging.debug(f"Point {settings[i]['label']}: index {i}, degree {point.abs_pos}")
+
+        return position_index_map, sorted(position_index_map.keys())
+
+    def calculate_distances(
+        self,
+        sorted_positions: List[float],
+        position_index_map: Dict[float, int],
+        abs_positions: List[float]
+    ) -> List[PointPosition]:
+        """Calculate distances between adjacent points."""
+        point_positions = []
+
+        for position_idx, abs_position in enumerate(sorted_positions):
+            point_idx = position_index_map[abs_position]
+
+            if len(sorted_positions) == 1:
+                # Single point case
+                distance_to_prev = distance_to_next = ChartConstants.MAX_DEGREE_DISTANCE
+            else:
+                prev_idx, next_idx = self._get_adjacent_indices(
+                    position_idx, sorted_positions, position_index_map
+                )
+                distance_to_prev = degreeDiff(abs_positions[prev_idx], abs_positions[point_idx])
+                distance_to_next = degreeDiff(abs_positions[next_idx], abs_positions[point_idx])
+
+            point_positions.append(PointPosition(
+                index=point_idx,
+                position_index=position_idx,
+                distance_to_prev=distance_to_prev,
+                distance_to_next=distance_to_next,
+                label=f"point_{point_idx}"  # Will be updated by caller
+            ))
+
+        return point_positions
+
+    def _get_adjacent_indices(
+        self,
+        position_idx: int,
+        sorted_positions: List[float],
+        position_index_map: Dict[float, int]
+    ) -> Tuple[int, int]:
+        """Get indices of previous and next points."""
+        total_positions = len(sorted_positions)
+
+        if position_idx == 0:
+            prev_position = sorted_positions[-1]
+            next_position = sorted_positions[1]
+        elif position_idx == total_positions - 1:
+            prev_position = sorted_positions[position_idx - 1]
+            next_position = sorted_positions[0]
+        else:
+            prev_position = sorted_positions[position_idx - 1]
+            next_position = sorted_positions[position_idx + 1]
+
+        return position_index_map[prev_position], position_index_map[next_position]
+
+    def identify_groups(self, point_positions: List[PointPosition]) -> List[List[PointPosition]]:
+        """Identify groups of points that are close together."""
+        groups = []
+        current_group = []
+
+        for point_pos in point_positions:
+            if point_pos.distance_to_next < self.threshold:
+                current_group.append(point_pos)
+            else:
+                if current_group:
+                    current_group.append(point_pos)
+                    groups.append(current_group)
+                    current_group = []
+
+        # Handle case where last group wraps around
+        if current_group and groups and point_positions[0] in groups[0]:
+            groups[0] = current_group + groups[0]
+        elif current_group:
+            groups.append(current_group)
+
+        return groups
+
+
+class PositionAdjuster:
+    """Calculates position adjustments to prevent overlapping points."""
+
+    def __init__(self, threshold: float = ChartConstants.PLANET_GROUPING_THRESHOLD):
+        self.threshold = threshold
+
+    def calculate_adjustments(
+        self,
+        groups: List[List[PointPosition]],
+        total_points: int
+    ) -> List[float]:
+        """Calculate position adjustments for all points."""
+        adjustments = [0.0] * total_points
+
+        for group in groups:
+            if len(group) == 2:
+                self._handle_two_point_group(group, adjustments)
+            elif len(group) >= 3:
+                self._handle_multi_point_group(group, adjustments)
+
+        return adjustments
+
+    def _handle_two_point_group(
+        self,
+        group: List[PointPosition],
+        adjustments: List[float]
+    ) -> None:
+        """Handle positioning for a group of two points."""
+        point_a, point_b = group[0], group[1]
+
+        # Check available space around the group
+        if (point_a.distance_to_prev > 2 * self.threshold and
+            point_b.distance_to_next > 2 * self.threshold):
+            # Both points have room
+            offset = (self.threshold - point_a.distance_to_next) / 2
+            adjustments[point_a.position_index] = -offset
+            adjustments[point_b.position_index] = +offset
+        elif point_a.distance_to_prev > 2 * self.threshold:
+            # Only first point has room
+            adjustments[point_a.position_index] = -self.threshold
+        elif point_b.distance_to_next > 2 * self.threshold:
+            # Only second point has room
+            adjustments[point_b.position_index] = +self.threshold
+
+    def _handle_multi_point_group(
+        self,
+        group: List[PointPosition],
+        adjustments: List[float]
+    ) -> None:
+        """Handle positioning for groups of three or more points."""
+        group_size = len(group)
+
+        # Calculate available and needed space
+        available_space = group[0].distance_to_prev
+        for point in group:
+            available_space += point.distance_to_next
+
+        needed_space = 3 * self.threshold + 1.2 * (group_size - 1) * self.threshold
+
+        if available_space > needed_space:
+            # Distribute points evenly
+            spacing = 1.2 * self.threshold
+            start_offset = (available_space - needed_space) / 2
+
+            for i, point in enumerate(group):
+                adjustments[point.position_index] = start_offset + i * spacing - group[0].distance_to_prev
+
+
+class RadiusCalculator:
+    """Calculates appropriate radius for different point types and chart types."""
+
+    @staticmethod
+    def get_point_radius(
+        point_idx: int,
+        chart_type: ChartType,
+        is_alternate: bool = False
+    ) -> int:
+        """Get radius for a celestial point based on its type and chart context."""
+        is_angle = ChartConstants.ANGLE_INDEX_RANGE[0] < point_idx < ChartConstants.ANGLE_INDEX_RANGE[1]
+
+        if chart_type in ["Transit", "Synastry", "Return"]:
+            if is_angle:
+                return ChartRadius.ANGLE_TRANSIT.value
+            return (ChartRadius.PLANET_TRANSIT_ALTERNATE.value if is_alternate
+                   else ChartRadius.PLANET_TRANSIT_PRIMARY.value)
+
+        elif chart_type == "ExternalNatal":
+            if is_angle:
+                return ChartRadius.ANGLE_EXTERNAL_NATAL.value
+            return (ChartRadius.PLANET_EXTERNAL_ALTERNATE.value if is_alternate
+                   else ChartRadius.PLANET_EXTERNAL_PRIMARY.value)
+
+        else:  # Natal chart
+            if is_angle:
+                return ChartRadius.ANGLE_NATAL.value
+            return (ChartRadius.PLANET_ALTERNATE.value if is_alternate
+                   else ChartRadius.PLANET_PRIMARY.value)
+
+
+class SVGRenderer:
+    """Handles SVG generation for celestial points."""
+
+    def __init__(self, config: ChartConfiguration):
+        self.config = config
+
+    def calculate_offset(self, point_degree: float, adjustment: float = 0) -> float:
+        """Calculate the angular offset for positioning a point."""
+        return (-self.config.seventh_house_degree) + point_degree + adjustment
+
+    def generate_point_svg(
+        self,
+        point: KerykeionPointModel,
+        x: float,
+        y: float,
+        point_name: str
+    ) -> str:
+        """Generate SVG element for a celestial point."""
+        scale = self.config.scale_factor
+        transform_offset = ChartConstants.SYMBOL_SIZE * scale
+
+        svg_parts = [
+            f'<g kr:node="ChartPoint" kr:house="{point.house}" kr:sign="{point.sign}" ',
+            f'kr:slug="{point.name}" transform="translate(-{transform_offset},-{transform_offset}) scale({scale})">',
+            f'<use x="{x / scale}" y="{y / scale}" xlink:href="#{point_name}" />',
+            '</g>'
+        ]
+
+        return ''.join(svg_parts)
+
+    def draw_external_natal_lines(
+        self,
+        point_radius: float,
+        true_offset: float,
+        adjusted_offset: float,
+        color: str
+    ) -> str:
+        """Draw connecting lines for ExternalNatal chart type."""
+        lines = []
+
+        # First line segment
+        x1 = sliceToX(0, self.config.radius - self.config.third_circle_radius, true_offset) + self.config.third_circle_radius
+        y1 = sliceToY(0, self.config.radius - self.config.third_circle_radius, true_offset) + self.config.third_circle_radius
+        x2 = sliceToX(0, self.config.radius - point_radius - 30, true_offset) + point_radius + 30
+        y2 = sliceToY(0, self.config.radius - point_radius - 30, true_offset) + point_radius + 30
+
+        lines.append(f'<line x1="{x1}" y1="{y1}" x2="{x2}" y2="{y2}" '
+                    f'style="stroke-width:{ChartConstants.LINE_WIDTH_THIN}px;stroke:{color};'
+                    f'stroke-opacity:{ChartConstants.LINE_OPACITY_PRIMARY};"/>')
+
+        # Second line segment
+        x3 = sliceToX(0, self.config.radius - point_radius - 10, adjusted_offset) + point_radius + 10
+        y3 = sliceToY(0, self.config.radius - point_radius - 10, adjusted_offset) + point_radius + 10
+
+        lines.append(f'<line x1="{x2}" y1="{y2}" x2="{x3}" y2="{y3}" '
+                    f'style="stroke-width:{ChartConstants.LINE_WIDTH_THIN}px;stroke:{color};'
+                    f'stroke-opacity:{ChartConstants.LINE_OPACITY_SECONDARY};"/>')
+
+        return '\n'.join(lines) + '\n'
+
+
+class SecondaryPointsRenderer:
+    """Handles rendering of secondary points (transit, synastry, return)."""
+
+    def __init__(self, config: ChartConfiguration):
+        self.config = config
+        self.grouper = CelestialPointGrouper(ChartConstants.SECONDARY_GROUPING_THRESHOLD)
+
+    def draw_secondary_points(
+        self,
+        points_abs_positions: List[float],
+        points_rel_positions: List[float],
+        points_settings: List[KerykeionSettingsCelestialPointModel],
+        exclude_points: List[str]
+    ) -> str:
+        """Draw all secondary celestial points."""
+        if not points_abs_positions:
+            return ""
+
+        # Filter out excluded points
+        filtered_indices = [
+            i for i, setting in enumerate(points_settings)
+            if self.config.chart_type != "Transit" or setting["name"] not in exclude_points
+        ]
+
+        if not filtered_indices:
+            return ""
+
+        # Calculate position adjustments for grouping
+        adjustments = self._calculate_secondary_adjustments(
+            filtered_indices, points_abs_positions, points_settings
+        )
+
+        # Render each secondary point
+        output_parts = []
+        alternate_position = False
+
+        for idx in filtered_indices:
+            point_svg = self._render_single_secondary_point(
+                idx, points_abs_positions, points_rel_positions,
+                points_settings, adjustments, alternate_position
+            )
+            output_parts.append(point_svg)
+            alternate_position = not alternate_position
+
+        return ''.join(output_parts)
+
+    def _calculate_secondary_adjustments(
+        self,
+        indices: List[int],
+        positions: List[float],
+        settings: List[KerykeionSettingsCelestialPointModel]
+    ) -> Dict[int, float]:
+        """Calculate position adjustments for secondary points."""
+        # Create position mapping for filtered indices
+        position_map = {positions[i]: i for i in indices}
+        sorted_positions = sorted(position_map.keys())
+
+        # Find groups
+        groups = []
+        current_group = []
+
+        for i, pos in enumerate(sorted_positions):
+            point_idx = position_map[pos]
+            next_pos = sorted_positions[(i + 1) % len(sorted_positions)]
+            next_idx = position_map[next_pos]
+
+            distance = degreeDiff(positions[point_idx], positions[next_idx])
+
+            if distance <= self.grouper.threshold:
+                if not current_group:
+                    current_group = [point_idx]
+                current_group.append(next_idx)
+            else:
+                if current_group:
+                    groups.append(current_group)
+                    current_group = []
+
+        if current_group:
+            groups.append(current_group)
+
+        # Calculate adjustments
+        adjustments = {i: 0.0 for i in indices}
+
+        for group in groups:
+            if len(group) == 2:
+                adjustments[group[0]] = -1.0
+                adjustments[group[1]] = 1.0
+            elif len(group) == 3:
+                adjustments[group[0]] = -1.5
+                adjustments[group[1]] = 0.0
+                adjustments[group[2]] = 1.5
+            elif len(group) >= 4:
+                for j, point_idx in enumerate(group):
+                    adjustments[point_idx] = -2.0 + j * (4.0 / (len(group) - 1))
+
+        return adjustments
+
+    def _render_single_secondary_point(
+        self,
+        point_idx: int,
+        abs_positions: List[float],
+        rel_positions: List[float],
+        settings: List[KerykeionSettingsCelestialPointModel],
+        adjustments: Dict[int, float],
+        is_alternate: bool
+    ) -> str:
+        """Render a single secondary point with symbol, line, and degree text."""
+        # Determine radius
+        is_angle = ChartConstants.ANGLE_INDEX_RANGE[0] < point_idx < ChartConstants.ANGLE_INDEX_RANGE[1]
+        point_radius = 9 if is_angle else (18 if is_alternate else 26)
+
+        # Calculate position
+        point_offset = self._calculate_secondary_offset(abs_positions[point_idx])
+
+        # Generate SVG components
+        symbol_svg = self._generate_secondary_symbol(point_idx, point_radius, point_offset, settings)
+        line_svg = self._generate_secondary_line(point_idx, point_offset, settings)
+        text_svg = self._generate_secondary_text(
+            point_idx, abs_positions, rel_positions, settings, adjustments, point_offset
+        )
+
+        return symbol_svg + line_svg + text_svg
+
+    def _calculate_secondary_offset(self, abs_position: float) -> float:
+        """Calculate offset for secondary point positioning."""
+        zero_point = 360 - self.config.seventh_house_degree
+        offset = zero_point + abs_position
+        return offset - 360 if offset > 360 else offset
+
+    def _generate_secondary_symbol(
+        self, point_idx: int, radius: int, offset: float,
+        settings: List[KerykeionSettingsCelestialPointModel]
+    ) -> str:
+        """Generate SVG for secondary point symbol."""
+        x = sliceToX(0, self.config.radius - radius, offset) + radius
+        y = sliceToY(0, self.config.radius - radius, offset) + radius
+
+        return (f'<g class="transit-planet-name" transform="translate(-6,-6)">'
+                f'<g transform="scale(0.5)">'
+                f'<use x="{x*2}" y="{y*2}" xlink:href="#{settings[point_idx]["name"]}" />'
+                f'</g></g>')
+
+    def _generate_secondary_line(
+        self, point_idx: int, offset: float,
+        settings: List[KerykeionSettingsCelestialPointModel]
+    ) -> str:
+        """Generate connecting line for secondary point."""
+        x1 = sliceToX(0, self.config.radius + 3, offset) - 3
+        y1 = sliceToY(0, self.config.radius + 3, offset) - 3
+        x2 = sliceToX(0, self.config.radius - 3, offset) + 3
+        y2 = sliceToY(0, self.config.radius - 3, offset) + 3
+
+        color = settings[point_idx]["color"]
+        return (f'<line class="transit-planet-line" x1="{x1}" y1="{y1}" x2="{x2}" y2="{y2}" '
+                f'style="stroke: {color}; stroke-width: {ChartConstants.LINE_WIDTH_THIN}px; '
+                f'stroke-opacity:.8;"/>')
+
+    def _generate_secondary_text(
+        self,
+        point_idx: int,
+        abs_positions: List[float],
+        rel_positions: List[float],
+        settings: List[KerykeionSettingsCelestialPointModel],
+        adjustments: Dict[int, float],
+        point_offset: float
+    ) -> str:
+        """Generate degree text for secondary point."""
+        # Calculate rotation and text anchor
+        rotation = self.config.first_house_degree - abs_positions[point_idx]
+        text_anchor = "end"
+
+        # Adjust for readability
+        if -270 < rotation < -90:
+            rotation += 180.0
+            text_anchor = "start"
+        elif 90 < rotation < 270:
+            rotation -= 180.0
+            text_anchor = "start"
+
+        # Position text
+        x_offset = 1 if text_anchor == "end" else -1
+        adjusted_offset = point_offset + adjustments[point_idx]
+        text_radius = -3.0
+
+        deg_x = sliceToX(0, self.config.radius - text_radius, adjusted_offset + x_offset) + text_radius
+        deg_y = sliceToY(0, self.config.radius - text_radius, adjusted_offset + x_offset) + text_radius
+
+        # Format degree text
+        degree_text = convert_decimal_to_degree_string(rel_positions[point_idx], format_type="1")
+        color = settings[point_idx]["color"]
+
+        return (f'<g transform="translate({deg_x},{deg_y})">'
+                f'<text transform="rotate({rotation})" text-anchor="{text_anchor}" '
+                f'style="fill: {color}; font-size: {ChartConstants.TEXT_SIZE}px;">{degree_text}</text>'
+                f'</g>')
+
+
+def _validate_chart_inputs(
+    chart_type: ChartType,
+    secondary_points: Optional[List[KerykeionPointModel]]
+) -> None:
+    """Validate that required secondary points are provided for chart types that need them."""
+    if _requires_secondary_points(chart_type) and secondary_points is None:
+        raise KerykeionException(f"Secondary celestial points are required for {chart_type} charts")
+
+
+def _requires_secondary_points(chart_type: ChartType) -> bool:
+    """Check if chart type requires secondary celestial points."""
+    return chart_type in ["Transit", "Synastry", "Return"]
+
+
+def _draw_main_points(
+    celestial_points: List[KerykeionPointModel],
+    settings: List[KerykeionSettingsCelestialPointModel],
+    config: ChartConfiguration,
+    grouper: CelestialPointGrouper,
+    adjuster: PositionAdjuster,
+    renderer: SVGRenderer
+) -> str:
+    """Draw the main celestial points with proper grouping and positioning."""
+    # Create position mapping and calculate distances
+    position_map, sorted_positions = grouper.create_position_mapping(celestial_points, settings)
+    abs_positions = [p.abs_pos for p in celestial_points]
+
+    point_positions = grouper.calculate_distances(sorted_positions, position_map, abs_positions)
+
+    # Update labels
+    for point_pos in point_positions:
+        point_pos.label = settings[point_pos.index]["label"]
+
+    # Identify groups and calculate adjustments
+    groups = grouper.identify_groups(point_positions)
+    adjustments = adjuster.calculate_adjustments(groups, len(settings))
+
+    # Draw each point
+    output_parts = []
+
+    for position_idx, abs_position in enumerate(sorted_positions):
+        point_idx = position_map[abs_position]
+
+        # Calculate positioning
+        point_radius = RadiusCalculator.get_point_radius(
+            point_idx, config.chart_type, bool(position_idx % 2)
+        )
+
+        adjusted_offset = renderer.calculate_offset(
+            abs_positions[point_idx], adjustments[position_idx]
+        )
+
+        # Calculate coordinates
+        point_x = sliceToX(0, config.radius - point_radius, adjusted_offset) + point_radius
+        point_y = sliceToY(0, config.radius - point_radius, adjusted_offset) + point_radius
+
+        # Draw external natal lines if needed
+        if config.chart_type == "ExternalNatal":
+            true_offset = renderer.calculate_offset(abs_positions[point_idx])
+            line_svg = renderer.draw_external_natal_lines(
+                point_radius, true_offset, adjusted_offset, settings[point_idx]["color"]
+            )
+            output_parts.append(line_svg)
+
+        # Generate point SVG
+        point_svg = renderer.generate_point_svg(
+            celestial_points[point_idx], point_x, point_y, settings[point_idx]["name"]
+        )
+        output_parts.append(point_svg)
+
+    return ''.join(output_parts)
+
+
+def draw_planets_v2(
+    radius: Union[int, float],
+    available_kerykeion_celestial_points: List[KerykeionPointModel],
+    available_planets_setting: List[KerykeionSettingsCelestialPointModel],
+    third_circle_radius: Union[int, float],
+    main_subject_first_house_degree_ut: Union[int, float],
+    main_subject_seventh_house_degree_ut: Union[int, float],
+    chart_type: ChartType,
+    second_subject_available_kerykeion_celestial_points: Optional[List[KerykeionPointModel]] = None,
+) -> str:
+    """
+    Draw celestial points on an astrological chart.
+
+    This is the main entry point for drawing planets and other celestial points
+    on astrological charts. It handles positioning, grouping, and overlap resolution.
+
+    Args:
+        radius: Chart radius in pixels
+        available_kerykeion_celestial_points: Main subject's celestial points
+        available_planets_setting: Settings for celestial points
+        third_circle_radius: Radius of the third circle
+        main_subject_first_house_degree_ut: First house degree
+        main_subject_seventh_house_degree_ut: Seventh house degree
+        chart_type: Type of chart being drawn
+        second_subject_available_kerykeion_celestial_points: Secondary subject's points
+
+    Returns:
+        SVG string for the celestial points
+
+    Raises:
+        KerykeionException: If secondary points are required but not provided
+    """
+    # Validate inputs
+    _validate_chart_inputs(chart_type, second_subject_available_kerykeion_celestial_points)
+
+    # Create configuration
+    config = ChartConfiguration(
+        radius=float(radius),
+        third_circle_radius=float(third_circle_radius),
+        first_house_degree=float(main_subject_first_house_degree_ut),
+        seventh_house_degree=float(main_subject_seventh_house_degree_ut),
+        chart_type=chart_type
+    )
+
+    # Initialize components
+    grouper = CelestialPointGrouper()
+    adjuster = PositionAdjuster()
+    renderer = SVGRenderer(config)
+
+    # Process main celestial points
+    output_parts = []
+
+    if available_kerykeion_celestial_points:
+        main_svg = _draw_main_points(
+            available_kerykeion_celestial_points,
+            available_planets_setting,
+            config,
+            grouper,
+            adjuster,
+            renderer
+        )
+        output_parts.append(main_svg)
+
+    # Process secondary points if needed
+    if _requires_secondary_points(chart_type) and second_subject_available_kerykeion_celestial_points:
+        secondary_renderer = SecondaryPointsRenderer(config)
+
+        secondary_abs_positions = [p.abs_pos for p in second_subject_available_kerykeion_celestial_points]
+        secondary_rel_positions = [p.position for p in second_subject_available_kerykeion_celestial_points]
+        exclude_points = list(get_args(Houses)) if chart_type == "Transit" else []
+
+        secondary_svg = secondary_renderer.draw_secondary_points(
+            secondary_abs_positions,
+            secondary_rel_positions,
+            available_planets_setting,
+            exclude_points
+        )
+        output_parts.append(secondary_svg)
+
+    return ''.join(output_parts)
+

kerykeion/charts/templates/aspect_grid_only.xml

@@ -1,6 +1,4 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!--- This file is part of Kerykeion and is based on
-OpenAstro.org -->
+<!--- This file is part of Kerykeion and is based on OpenAstro.org -->
 <svg
     xmlns="http://www.w3.org/2000/svg"
     xmlns:xlink="http://www.w3.org/1999/xlink"

kerykeion/charts/templates/chart.xml

@@ -1,6 +1,4 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<!--- This file is part of Kerykeion and is based on
-OpenAstro.org -->
+<!--- This file is part of Kerykeion and is based on OpenAstro.org -->
 <svg
     xmlns="http://www.w3.org/2000/svg"
     xmlns:xlink="http://www.w3.org/1999/xlink"

kerykeion/charts/templates/wheel_only.xml

@@ -1,4 +1,3 @@
-<?xml version='1.0' encoding='UTF-8'?>
 <!--- This file is part of Kerykeion and is based on OpenAstro.org -->
 <svg
     xmlns="http://www.w3.org/2000/svg"

kerykeion/kr_types/kr_models.py

@@ -79,18 +79,18 @@ class AstrologicalBaseModel(SubscriptableBaseModel):
     # Common identification data
     name: str
 
-    # Common location data
-    city: str
-    nation: str
-    lng: float
-    lat: float
-    tz_str: str
-
-    # Common time data
-    iso_formatted_local_datetime: str
-    iso_formatted_utc_datetime: str
-    julian_day: float
-    day_of_week: str
+    # Common location data (optional for composite charts)
+    city: Optional[str] = None
+    nation: Optional[str] = None
+    lng: Optional[float] = None
+    lat: Optional[float] = None
+    tz_str: Optional[str] = None
+
+    # Common time data (optional for composite charts)
+    iso_formatted_local_datetime: Optional[str] = None
+    iso_formatted_utc_datetime: Optional[str] = None
+    julian_day: Optional[float] = None
+    day_of_week: Optional[str] = None
 
     # Common configuration
     zodiac_type: ZodiacType
@@ -188,6 +188,17 @@ class AstrologicalSubjectModel(AstrologicalBaseModel):
     """
     Pydantic Model for Astrological Subject
     """
+    # Override base model to make location and time data required for subjects
+    city: str
+    nation: str
+    lng: float
+    lat: float
+    tz_str: str
+    iso_formatted_local_datetime: str
+    iso_formatted_utc_datetime: str
+    julian_day: float
+    day_of_week: str
+
     # Specific birth/event data
     year: int
     month: int

{kerykeion-5.0.0a6.dist-info → kerykeion-5.0.0a8.dist-info}/METADATA

@@ -1,40 +1,36 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: kerykeion
-Version: 5.0.0a6
+Version: 5.0.0a8
 Summary: A python library for astrology.
+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
-Keywords: astrology,ephemeris,astrology library,birtchart,svg,zodiac,zodiac-sing,astronomical-algorithms,synastry,astrology-calculator
-Author: Giacomo Battaglia
-Author-email: kerykeion.astrology@gmail.com
-Requires-Python: >=3.9,<4.0
+License-File: LICENSE
+Keywords: astrology,astrology library,astrology-calculator,astronomical-algorithms,birtchart,ephemeris,svg,synastry,zodiac,zodiac-sing
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Information Technology
-Classifier: License :: OSI Approved :: GNU Affero General Public License v3
 Classifier: License :: OSI Approved :: GNU General Public License (GPL)
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
+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: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Scientific/Engineering :: Astronomy
 Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
-Requires-Dist: pydantic (>=2.5,<3.0)
-Requires-Dist: pyswisseph (>=2.10.3.1,<3.0.0.0)
-Requires-Dist: pytz (>=2024.2,<2025.0)
-Requires-Dist: requests (>=2.32.3,<3.0.0)
-Requires-Dist: requests-cache (>=1.2.1,<2.0.0)
-Requires-Dist: scour (>=0.38.2,<0.39.0)
-Requires-Dist: simple-ascii-tables (>=1.0.0,<2.0.0)
-Requires-Dist: typing-extensions (>=4.12.2,<5.0.0)
-Project-URL: Homepage, https://www.kerykeion.net/
-Project-URL: Repository, https://github.com/g-battaglia/kerykeion
+Requires-Python: >=3.9
+Requires-Dist: pydantic>=2.5
+Requires-Dist: pyswisseph>=2.10.3.1
+Requires-Dist: pytz>=2024.2
+Requires-Dist: requests-cache>=1.2.1
+Requires-Dist: requests>=2.32.3
+Requires-Dist: scour>=0.38.2
+Requires-Dist: simple-ascii-tables>=1.0.0
+Requires-Dist: typing-extensions>=4.12.2
 Description-Content-Type: text/markdown
 
 <h1 align="center">Kerykeion</h1>
@@ -638,4 +634,3 @@ If using Kerykeion in published or academic work, please cite as follows:
 Battaglia, G. (2025). Kerykeion: A Python Library for Astrological Calculations and Chart Generation.
 https://github.com/g-battaglia/kerykeion
 ```
-

{kerykeion-5.0.0a6.dist-info → kerykeion-5.0.0a8.dist-info}/RECORD

@@ -1,27 +1,33 @@
 kerykeion/__init__.py,sha256=18VYgL_5JcB3JwzfICoHxtQTqzwlgUXHY5j4HG2gjZQ,920
+kerykeion/astrological_subject_factory.py,sha256=z8ehPW6_wT6fwayxAmST0oSdLMM1pAmHXuwncSF_A20,52340
+kerykeion/composite_subject_factory.py,sha256=d3omKRw7AlJFQVrOa1nBOu9jQx7W-2UrL8V7TKyVXHg,7551
+kerykeion/enums.py,sha256=nPXgP_ocsRnRno5H-yunZy3fp-hLZ9aYRaUb-2gBdvw,1199
+kerykeion/ephemeris_data.py,sha256=h56Y4FCTYPcIzSnDiKNXYzEpeiqU554ccUmfXENigls,10750
+kerykeion/fetch_geonames.py,sha256=e66Nh6yq9A4VjnuvVSiV1TW1IkJ9m3Q2LKPWrkOGgO0,4764
+kerykeion/planetary_return_factory.py,sha256=Y3jMHsI1epuBC4N3Mto0mubVE8BIT89dBh15eOATg2Y,11449
+kerykeion/relationship_score_factory.py,sha256=g0RL1sx_LsMlfX1XVDf-z2LrlZ_SAL_1C0kuOGhKhsA,8495
+kerykeion/report.py,sha256=w4KNQz0ADPPXE60PX6NVTxjppZ9q_naSbgYKQiX6Epk,2827
+kerykeion/transits_time_range.py,sha256=iJSkXcNKJBcfrN8gN9P0xGKLsRBwJs-mMuAtPsvUqNE,5505
+kerykeion/utilities.py,sha256=mD-oPKlbpwyXv5CXOS4aS6e6u0fFYl2lf9ptUr06jxs,22217
 kerykeion/aspects/__init__.py,sha256=9kx_Rx1NJx5SM7nDCSbI79S1neZ3c-q2NvQr-S6A9PY,292
 kerykeion/aspects/aspects_utils.py,sha256=NgxdeKd9CAPbzFlLe-yr9RFumM0Cc0kfWEONYREOFJ4,3252
 kerykeion/aspects/natal_aspects.py,sha256=SfI3ferjtyV47fBG6q3q1aczc-GFOwN4P7WpyZTgPSA,7269
 kerykeion/aspects/synastry_aspects.py,sha256=4ZBiFrbyyXxclnyaEIBeLJQO3uQVnpsqvI5Kj3-ijuI,5979
 kerykeion/aspects/transits_time_range.py,sha256=E03BJYcNK3kO30EC96Ys2EaH-EDyZF2nj4C7_LcFrOk,1182
-kerykeion/astrological_subject_factory.py,sha256=z8ehPW6_wT6fwayxAmST0oSdLMM1pAmHXuwncSF_A20,52340
 kerykeion/charts/__init__.py,sha256=i9NMZ7LdkllPlqQSi1or9gTobHbROGDKmJhBDO4R0mA,128
 kerykeion/charts/charts_utils.py,sha256=GCC20W4qHQXXKdUMlt72THHJxqp6ytj4X61oLONMSt4,62450
 kerykeion/charts/draw_planets.py,sha256=dbVCA4MFs7ChZKH4w1eErBiF_mluuxAD4fouBrXs-x0,17696
-kerykeion/charts/draw_planets_v2.py,sha256=IqyTLs1salrfJguwMtEpuscXg3kqyrrAAdXuGqzl-XQ,27630
+kerykeion/charts/draw_planets_v2.py,sha256=ft0KjngCIfYKNGlZ4cv7apX9V6uyHetIVOxbNRzEmWU,28210
+kerykeion/charts/draw_planets_v3.py,sha256=3nrpef56qBsc0hfCOGdfCOr-61C2c5aWcRSiBcQiAuo,25811
 kerykeion/charts/kerykeion_chart_svg.py,sha256=2Xhe2XvZLdoAIRxYh1MYceencbYJKxWXRoZZ30Kgra4,95638
-kerykeion/charts/templates/aspect_grid_only.xml,sha256=ZiBVeToVmCA8QxYlB_cfnsAO1NNeQAnJ_6rIYkr4F58,70091
-kerykeion/charts/templates/chart.xml,sha256=_VCtqsH7E97JUQbvx9i5OktdRLOAhlI2Znr7mEIMK8E,79839
-kerykeion/charts/templates/wheel_only.xml,sha256=hSV4FYD7qLKd93jq82B9mnGoH0PKyMRaqp3jL16T9YI,71287
+kerykeion/charts/templates/aspect_grid_only.xml,sha256=goTM5zXKZMZCZPxsJAk80PQvQCgo2QccJLyH4HHpguo,70052
+kerykeion/charts/templates/chart.xml,sha256=ZNfA19u1objUui1vCGJTvvwdE_Sg9R9O3LNdcNHEuaI,79800
+kerykeion/charts/templates/wheel_only.xml,sha256=zR2EJBy6Io69enkuRfHWZxYdyeQsXGpl9_BkY2f4L2c,71248
 kerykeion/charts/themes/classic.css,sha256=LYYYWQHNG7-vuPCq8F2EPl3LauWXVrY3Q_tpwM0klgo,4660
 kerykeion/charts/themes/dark-high-contrast.css,sha256=YW5X5-M0dz5Vy2oz-JyDNXJYHSmV83lYCodydC-KS1A,7506
 kerykeion/charts/themes/dark.css,sha256=XVspznDRNMXsFzk7hY7IB7AI58alPAV_-CgV3gCKyzg,7581
 kerykeion/charts/themes/light.css,sha256=5eyUzhVlRjG6lPHKnprLum0HuRtPIJhMBzpGfzoTjnQ,7590
 kerykeion/charts/themes/strawberry.css,sha256=UtcfRsCT-M9OZs_SoclWGZ0jDJiWvQjHTeI4M1jf7pQ,8314
-kerykeion/composite_subject_factory.py,sha256=d3omKRw7AlJFQVrOa1nBOu9jQx7W-2UrL8V7TKyVXHg,7551
-kerykeion/enums.py,sha256=nPXgP_ocsRnRno5H-yunZy3fp-hLZ9aYRaUb-2gBdvw,1199
-kerykeion/ephemeris_data.py,sha256=h56Y4FCTYPcIzSnDiKNXYzEpeiqU554ccUmfXENigls,10750
-kerykeion/fetch_geonames.py,sha256=e66Nh6yq9A4VjnuvVSiV1TW1IkJ9m3Q2LKPWrkOGgO0,4764
 kerykeion/house_comparison/__init__.py,sha256=FQutYoG1T_ljkjJ0OAFvkeH8rASwMK7ieCpH_hDFJWU,139
 kerykeion/house_comparison/house_comparison_factory.py,sha256=R3O3R786yH6W2c8cKma8P7FNXU6JGl29omRHmucNN_Q,3369
 kerykeion/house_comparison/house_comparison_models.py,sha256=R9EW5F3fiIKIm8qrwTxtXhNOGDpf1-Lh9hbM1uK83oE,1549
@@ -30,11 +36,8 @@ kerykeion/kr_types/__init__.py,sha256=jshJOccCQcYZuoOvrILRZH6imy4RBvKpFPujlNLFyG
 kerykeion/kr_types/chart_types.py,sha256=ou9mIMNrQ7vlgWW4e209z_wMa2XZa4OGvHBr-CGk_rs,2309
 kerykeion/kr_types/kerykeion_exception.py,sha256=kE1y0K0rmuz32b4K_ZppSsZ59I2Get0ZkvOkTE5HejI,314
 kerykeion/kr_types/kr_literals.py,sha256=4kJhzm_0LERiJEJks0KgDyThueMZj_F1OK2Far5SMZc,4870
-kerykeion/kr_types/kr_models.py,sha256=ncMzW63eTkDNMSX7JaxXpCQyA1k0yEeaNeLhAHc0y_w,8345
+kerykeion/kr_types/kr_models.py,sha256=nzq8no2dBd4b529ybznF46_VUEvDj5ZdDdlLRBE0RmM,8835
 kerykeion/kr_types/settings_models.py,sha256=qKlcn-Go1dAhC7oMFY_saogNcRa4WvKSewyvsKZt2S0,16604
-kerykeion/planetary_return_factory.py,sha256=Y3jMHsI1epuBC4N3Mto0mubVE8BIT89dBh15eOATg2Y,11449
-kerykeion/relationship_score_factory.py,sha256=g0RL1sx_LsMlfX1XVDf-z2LrlZ_SAL_1C0kuOGhKhsA,8495
-kerykeion/report.py,sha256=w4KNQz0ADPPXE60PX6NVTxjppZ9q_naSbgYKQiX6Epk,2827
 kerykeion/settings/__init__.py,sha256=QQNFCl7sgN27MKaVscqtpPk10HGz4wZS3I_7KEGMaVA,69
 kerykeion/settings/config_constants.py,sha256=R4fEe4WzRSq3BXqsnfgHj1oe_swkVMx3iGe-C_Zu0mw,1772
 kerykeion/settings/kerykeion_settings.py,sha256=umd8TZy-8ywowsd4TTkhwxSLLyX3xYj3A1zvNsTV_Y8,2955
@@ -45,10 +48,8 @@ kerykeion/settings/legacy/legacy_chart_aspects_settings.py,sha256=tO4tgPgPP07_wu
 kerykeion/settings/legacy/legacy_color_settings.py,sha256=gBUmGSNvvLzRYbdVtzwTDnMwWoh4tOCyT_9Q6aQRv_s,2620
 kerykeion/sweph/README.md,sha256=L7FtNAJTWtrZNGKa8MX87SjduFYPYxwWhaI5fmtzNZo,73
 kerykeion/sweph/seas_18.se1,sha256=X9nCqhZU43wJpq61WAdueVQJt9xL2UjrwPqn1Kdoa1s,223002
-kerykeion/transits_time_range.py,sha256=iJSkXcNKJBcfrN8gN9P0xGKLsRBwJs-mMuAtPsvUqNE,5505
-kerykeion/utilities.py,sha256=mD-oPKlbpwyXv5CXOS4aS6e6u0fFYl2lf9ptUr06jxs,22217
-kerykeion-5.0.0a6.dist-info/LICENSE,sha256=UTLH8EdbAsgQei4PA2PnBCPGLSZkq5J-dhkyJuXgWQU,34273
-kerykeion-5.0.0a6.dist-info/METADATA,sha256=nEomd4tVQo18cU9U5xSjE40Sjyy6cf9OsdZr6Nxt2PM,25398
-kerykeion-5.0.0a6.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-kerykeion-5.0.0a6.dist-info/entry_points.txt,sha256=5SmANYscFDDTdeovHvGQ-cnj0hdFvGoxPaWLCpyDFnQ,49
-kerykeion-5.0.0a6.dist-info/RECORD,,
+kerykeion-5.0.0a8.dist-info/METADATA,sha256=XRm8bm5JWbAt-t0A4LUUOedawGjeACYyYBQQ_oGqLlc,25100
+kerykeion-5.0.0a8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kerykeion-5.0.0a8.dist-info/entry_points.txt,sha256=j9J6dg4czXFgM3LDOxoWFl8UDU4LLe2bD_U0RgpyLGA,50
+kerykeion-5.0.0a8.dist-info/licenses/LICENSE,sha256=UTLH8EdbAsgQei4PA2PnBCPGLSZkq5J-dhkyJuXgWQU,34273
+kerykeion-5.0.0a8.dist-info/RECORD,,

{kerykeion-5.0.0a6.dist-info → kerykeion-5.0.0a8.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.3
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

kerykeion-5.0.0a8.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+create-docs = scripts.docs:main

kerykeion-5.0.0a6.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-create-docs=scripts.docs:main
-