kerykeion 5.0.0b2__py3-none-any.whl → 5.0.0b5__py3-none-any.whl

kerykeion/charts/chart_drawer.py

@@ -5,19 +5,23 @@
 
 
 import logging
-import swisseph as swe
-from typing import get_args, Union, Any
+from copy import deepcopy
+from math import ceil
+from datetime import datetime
+from pathlib import Path
+from string import Template
+from typing import Any, Mapping, Optional, Union, get_args
 
+import swisseph as swe
+from scour.scour import scourString
 
-from kerykeion.schemas.kr_models import ChartDataModel
-from kerykeion.settings.config_constants import DEFAULT_ACTIVE_POINTS
-from kerykeion.settings.kerykeion_settings import get_settings
 from kerykeion.house_comparison.house_comparison_factory import HouseComparisonFactory
 from kerykeion.schemas import (
     KerykeionException,
     ChartType,
     Sign,
     ActiveAspect,
+    KerykeionPointModel,
 )
 from kerykeion.schemas import ChartTemplateModel
 from kerykeion.schemas.kr_models import (
@@ -27,13 +31,17 @@ from kerykeion.schemas.kr_models import (
 )
 from kerykeion.schemas.settings_models import (
     KerykeionSettingsCelestialPointModel,
-    KerykeionSettingsModel,
+    KerykeionLanguageModel,
 )
 from kerykeion.schemas.kr_literals import (
     KerykeionChartTheme,
     KerykeionChartLanguage,
     AstrologicalPoint,
 )
+from kerykeion.schemas.kr_models import ChartDataModel
+from kerykeion.settings import LANGUAGE_SETTINGS
+from kerykeion.settings.config_constants import DEFAULT_ACTIVE_POINTS
+from kerykeion.settings.translations import get_translations, load_language_settings
 from kerykeion.charts.charts_utils import (
     draw_zodiac_slice,
     convert_latitude_coordinate_to_string,
@@ -62,14 +70,12 @@ from kerykeion.charts.charts_utils import (
 )
 from kerykeion.charts.draw_planets import draw_planets
 from kerykeion.utilities import get_houses_list, inline_css_variables_in_svg, distribute_percentages_to_100
-from kerykeion.settings.legacy.legacy_color_settings import DEFAULT_CHART_COLORS
-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 pathlib import Path
-from scour.scour import scourString
-from string import Template
+from kerykeion.settings.chart_defaults import (
+    DEFAULT_CHART_COLORS,
+    DEFAULT_CELESTIAL_POINTS_SETTINGS,
+    DEFAULT_CHART_ASPECTS_SETTINGS,
+)
 from typing import List, Literal
-from datetime import datetime
 
 
 class ChartDrawer:
@@ -98,14 +104,16 @@ class ChartDrawer:
             Pre-computed chart data from ChartDataFactory containing all subjects, aspects,
             element/quality distributions, and other analytical data. This is the ONLY source
             of chart information - no calculations are performed by ChartDrawer.
-        new_settings_file (Path | dict | KerykeionSettingsModel, optional):
-            Path or settings object to override default chart configuration (colors, fonts, aspects).
         theme (KerykeionChartTheme, optional):
             CSS theme for the chart. If None, no default styles are applied. Defaults to 'classic'.
         double_chart_aspect_grid_type (Literal['list', 'table'], optional):
             Specifies rendering style for double-chart aspect grids. Defaults to 'list'.
         chart_language (KerykeionChartLanguage, optional):
             Language code for chart labels. Defaults to 'EN'.
+        language_pack (dict | None, optional):
+            Additional translations merged over the bundled defaults for the
+            selected language. Useful to introduce new languages or override
+            existing labels.
         transparent_background (bool, optional):
             Whether to use a transparent background instead of the theme color. Defaults to False.
 
@@ -157,10 +165,14 @@ class ChartDrawer:
 
     _DEFAULT_HEIGHT = 550
     _DEFAULT_FULL_WIDTH = 1250
+    _DEFAULT_SYNASTRY_WIDTH = 1570
     _DEFAULT_NATAL_WIDTH = 870
     _DEFAULT_FULL_WIDTH_WITH_TABLE = 1250
     _DEFAULT_ULTRA_WIDE_WIDTH = 1320
 
+    _ASPECT_LIST_ASPECTS_PER_COLUMN = 14
+    _ASPECT_LIST_COLUMN_WIDTH = 105
+
     _BASE_VERTICAL_OFFSETS = {
         "wheel": 50,
         "grid": 0,
@@ -185,7 +197,6 @@ class ChartDrawer:
     first_obj: Union[AstrologicalSubjectModel, CompositeSubjectModel, PlanetReturnModel]
     second_obj: Union[AstrologicalSubjectModel, PlanetReturnModel, None]
     chart_type: ChartType
-    new_settings_file: Union[Path, None, KerykeionSettingsModel, dict]
     theme: Union[KerykeionChartTheme, None]
     double_chart_aspect_grid_type: Literal["list", "table"]
     chart_language: KerykeionChartLanguage
@@ -194,6 +205,8 @@ class ChartDrawer:
     transparent_background: bool
     external_view: bool
     custom_title: Union[str, None]
+    _language_model: KerykeionLanguageModel
+    _fallback_language_model: KerykeionLanguageModel
 
     # Internal properties
     fire: float
@@ -219,10 +232,10 @@ class ChartDrawer:
         self,
         chart_data: "ChartDataModel",
         *,
-        new_settings_file: Union[Path, None, KerykeionSettingsModel, dict] = None,
         theme: Union[KerykeionChartTheme, None] = "classic",
         double_chart_aspect_grid_type: Literal["list", "table"] = "list",
         chart_language: KerykeionChartLanguage = "EN",
+        language_pack: Optional[Mapping[str, Any]] = None,
         external_view: bool = False,
         transparent_background: bool = False,
         colors_settings: dict = DEFAULT_CHART_COLORS,
@@ -239,14 +252,16 @@ class ChartDrawer:
             chart_data (ChartDataModel):
                 Pre-computed chart data from ChartDataFactory containing all subjects,
                 aspects, element/quality distributions, and other analytical data.
-            new_settings_file (Path, dict, or KerykeionSettingsModel, optional):
-                Custom settings source for chart colors, fonts, and aspects.
             theme (KerykeionChartTheme or None, optional):
                 CSS theme to apply; None for default styling.
             double_chart_aspect_grid_type (Literal['list','table'], optional):
                 Layout style for double-chart aspect grids ('list' or 'table').
             chart_language (KerykeionChartLanguage, optional):
                 Language code for chart labels (e.g., 'EN', 'IT').
+            language_pack (dict | None, optional):
+                Additional translations merged over the bundled defaults for the
+                selected language. Useful to introduce new languages or override
+                existing labels.
             external_view (bool, optional):
                 Whether to use external visualization (planets on outer ring) for single-subject charts. Defaults to False.
             transparent_background (bool, optional):
@@ -257,14 +272,13 @@ class ChartDrawer:
         # --------------------
         # COMMON INITIALIZATION
         # --------------------
-        self.new_settings_file = new_settings_file
         self.chart_language = chart_language
         self.double_chart_aspect_grid_type = double_chart_aspect_grid_type
         self.transparent_background = transparent_background
         self.external_view = external_view
-        self.chart_colors_settings = colors_settings
-        self.planets_settings = celestial_points_settings
-        self.aspects_settings = aspects_settings
+        self.chart_colors_settings = deepcopy(colors_settings)
+        self.planets_settings = [dict(body) for body in celestial_points_settings]
+        self.aspects_settings = [dict(aspect) for aspect in aspects_settings]
         self.custom_title = custom_title
         self.auto_size = auto_size
         self._padding = padding
@@ -287,7 +301,7 @@ class ChartDrawer:
             self.second_obj = getattr(chart_data, 'second_subject')
 
         # Load settings
-        self.parse_json_settings(new_settings_file)
+        self._load_language_settings(language_pack)
 
         # Default radius for all charts
         self.main_radius = 240
@@ -308,10 +322,18 @@ class ChartDrawer:
 
         # Set available celestial points
         available_celestial_points_names = [body["name"].lower() for body in self.available_planets_setting]
-        self.available_kerykeion_celestial_points = []
-        for body in available_celestial_points_names:
-            if hasattr(self.first_obj, body):
-                self.available_kerykeion_celestial_points.append(self.first_obj.get(body))  # type: ignore[arg-type]
+        self.available_kerykeion_celestial_points = self._collect_subject_points(
+            self.first_obj,
+            available_celestial_points_names,
+        )
+
+        # Collect secondary subject points for dual charts using the same active set
+        self.t_available_kerykeion_celestial_points: list[KerykeionPointModel] = []
+        if self.second_obj is not None:
+            self.t_available_kerykeion_celestial_points = self._collect_subject_points(
+                self.second_obj,
+                available_celestial_points_names,
+            )
 
         # ------------------------
         # CHART TYPE SPECIFIC SETUP FROM CHART DATA
@@ -364,9 +386,6 @@ class ChartDrawer:
             # Extract aspects from pre-computed chart data
             self.aspects_list = chart_data.aspects.relevant_aspects
 
-            # Secondary subject available points
-            self.t_available_kerykeion_celestial_points = self.available_kerykeion_celestial_points
-
             # Screen size
             self.height = self._DEFAULT_HEIGHT
             if self.double_chart_aspect_grid_type == "table":
@@ -388,12 +407,9 @@ class ChartDrawer:
             # Extract aspects from pre-computed chart data
             self.aspects_list = chart_data.aspects.relevant_aspects
 
-            # Secondary subject available points
-            self.t_available_kerykeion_celestial_points = self.available_kerykeion_celestial_points
-
             # Screen size
             self.height = self._DEFAULT_HEIGHT
-            self.width = self._DEFAULT_FULL_WIDTH
+            self.width = self._DEFAULT_SYNASTRY_WIDTH
 
             # Get location and coordinates
             self.location, self.geolat, self.geolon = self._get_location_info()
@@ -409,9 +425,6 @@ class ChartDrawer:
             # Extract aspects from pre-computed chart data
             self.aspects_list = chart_data.aspects.relevant_aspects
 
-            # Secondary subject available points
-            self.t_available_kerykeion_celestial_points = self.available_kerykeion_celestial_points
-
             # Screen size
             self.height = self._DEFAULT_HEIGHT
             self.width = self._DEFAULT_ULTRA_WIDE_WIDTH
@@ -462,17 +475,11 @@ class ChartDrawer:
 
         self.set_up_theme(theme)
 
-        # Optionally expand width dynamically to fit content
-        if self.auto_size:
-            try:
-                required_width = self._estimate_required_width_full()
-                if required_width > self.width:
-                    self.width = required_width
-            except Exception as e:
-                # Keep default on any unexpected issue; do not break rendering
-                logging.debug(f"Auto-size width calculation failed: {e}")
-
         self._apply_dynamic_height_adjustment()
+        self._adjust_height_for_extended_aspect_columns()
+        # Reconcile width with the updated layout once height adjustments are known.
+        if self.auto_size:
+            self._update_width_to_content()
 
     def _count_active_planets(self) -> int:
         """Return number of active celestial points in the current chart."""
@@ -485,6 +492,15 @@ class ChartDrawer:
         offsets = self._BASE_VERTICAL_OFFSETS.copy()
 
         minimum_height = self._DEFAULT_HEIGHT
+
+        if self.chart_type == "Synastry":
+            self._apply_synastry_height_adjustment(
+                active_points_count=active_points_count,
+                offsets=offsets,
+                minimum_height=minimum_height,
+            )
+            return
+
         if active_points_count <= 20:
             self.height = max(self.height, minimum_height)
             self._vertical_offsets = offsets
@@ -515,6 +531,135 @@ class ChartDrawer:
 
         self._vertical_offsets = offsets
 
+    def _adjust_height_for_extended_aspect_columns(self) -> None:
+        """Ensure tall aspect columns fit within the SVG for double-chart lists."""
+        if self.double_chart_aspect_grid_type != "list":
+            return
+
+        if self.chart_type not in ("Synastry", "Transit", "DualReturnChart"):
+            return
+
+        total_aspects = len(self.aspects_list) if hasattr(self, "aspects_list") else 0
+        if total_aspects == 0:
+            return
+
+        aspects_per_column = 14
+        extended_column_start = 11  # Zero-based column index where tall columns begin
+        base_capacity = aspects_per_column * extended_column_start
+
+        if total_aspects <= base_capacity:
+            return
+
+        translate_y = 273
+        bottom_padding = 40
+        title_clearance = 18
+        line_height = 14
+        baseline_index = aspects_per_column - 1
+        top_limit_index = ceil((-translate_y + title_clearance) / line_height)
+        max_capacity_by_top = baseline_index - top_limit_index + 1
+
+        if max_capacity_by_top <= aspects_per_column:
+            return
+
+        target_capacity = max_capacity_by_top
+        required_available_height = target_capacity * line_height
+        required_height = translate_y + bottom_padding + required_available_height
+
+        if required_height <= self.height:
+            return
+
+        delta = required_height - self.height
+        self.height = required_height
+
+        offsets = self._vertical_offsets
+        # Keep bottom-anchored groups aligned after changing the overall height.
+        offsets["wheel"] += delta
+        offsets["aspect_grid"] += delta
+        offsets["aspect_list"] += delta
+        offsets["lunar_phase"] += delta
+        offsets["bottom_left"] += delta
+        self._vertical_offsets = offsets
+
+    def _apply_synastry_height_adjustment(
+        self,
+        *,
+        active_points_count: int,
+        offsets: dict[str, int],
+        minimum_height: int,
+    ) -> None:
+        """Specialised dynamic height handling for Synastry charts.
+
+        With the planet grids locked to a single column, every additional active
+        point extends multiple tables vertically (planets, houses, comparisons).
+        We therefore scale the height using the actual line spacing used by those
+        tables (≈14px) and keep the bottom anchored elements aligned.
+        """
+        base_rows = 14  # Up to 16 active points fit without extra height
+        extra_rows = max(active_points_count - base_rows, 0)
+
+        synastry_row_height = 15
+        comparison_padding_per_row = 4  # Keeps house comparison grids within view.
+        extra_height = extra_rows * (synastry_row_height + comparison_padding_per_row)
+
+        self.height = max(self.height, minimum_height + extra_height)
+
+        delta_height = max(self.height - minimum_height, 0)
+
+        offsets["wheel"] += delta_height
+        offsets["aspect_grid"] += delta_height
+        offsets["aspect_list"] += delta_height
+        offsets["lunar_phase"] += delta_height
+        offsets["bottom_left"] += delta_height
+
+        row_height_ratio = synastry_row_height / max(self._ROW_HEIGHT, 1)
+        synastry_top_shift_factor = max(
+            self._TOP_SHIFT_FACTOR,
+            int(ceil(self._TOP_SHIFT_FACTOR * row_height_ratio)),
+        )
+        shift = min(extra_rows * synastry_top_shift_factor, self._MAX_TOP_SHIFT)
+
+        base_grid_padding = 36
+        grid_padding_per_row = 6
+        base_header_padding = 12
+        header_padding_per_row = 4
+        min_title_to_grid_gap = 36
+
+        grid_shift = shift + base_grid_padding + (extra_rows * grid_padding_per_row)
+        grid_shift = min(grid_shift, shift + self._MAX_TOP_SHIFT)
+
+        top_shift = (shift // 2) + base_header_padding + (extra_rows * header_padding_per_row)
+
+        max_allowed_shift = shift + self._MAX_TOP_SHIFT
+        missing_gap = min_title_to_grid_gap - (grid_shift - top_shift)
+        grid_shift = min(grid_shift + missing_gap, max_allowed_shift)
+        if grid_shift - top_shift < min_title_to_grid_gap:
+            top_shift = max(0, grid_shift - min_title_to_grid_gap)
+
+        offsets["grid"] += grid_shift
+        offsets["title"] += top_shift
+        offsets["elements"] += top_shift
+        offsets["qualities"] += top_shift
+
+        self._vertical_offsets = offsets
+
+    def _collect_subject_points(
+        self,
+        subject: Union[AstrologicalSubjectModel, CompositeSubjectModel, PlanetReturnModel],
+        point_attribute_names: list[str],
+    ) -> list[KerykeionPointModel]:
+        """Collect ordered active celestial points for a subject."""
+
+        collected: list[KerykeionPointModel] = []
+
+        for raw_name in point_attribute_names:
+            attr_name = raw_name if hasattr(subject, raw_name) else raw_name.lower()
+            point = getattr(subject, attr_name, None)
+            if point is None:
+                continue
+            collected.append(point)
+
+        return collected
+
     def _dynamic_viewbox(self) -> str:
         """Return the viewBox string based on current width/height."""
         return f"0 0 {int(self.width)} {int(self.height)}"
@@ -604,14 +749,10 @@ class ChartDrawer:
         if self.chart_type in ("Transit", "Synastry", "DualReturnChart"):
             # Double-chart aspects placement
             if self.double_chart_aspect_grid_type == "list":
-                # Columnar list placed at translate(565,273), ~100-110px per column, 14 aspects per column
-                aspects_per_column = 14
                 total_aspects = len(self.aspects_list) if hasattr(self, "aspects_list") else 0
-                columns = max((total_aspects + aspects_per_column - 1) // aspects_per_column, 1)
-                # Respect the max columns cap used in rendering: DualReturn=7, others=6
-                max_cols_cap = 7
-                columns = min(columns, max_cols_cap)
-                aspect_list_right = 565 + (columns * 110)
+                columns = self._calculate_double_chart_aspect_columns(total_aspects, self.height)
+                columns = max(columns, 1)
+                aspect_list_right = 565 + (columns * self._ASPECT_LIST_COLUMN_WIDTH)
                 extents.append(aspect_list_right)
             else:
                 # Grid table placed with x_indent ~550, width ~ 14px per cell across n_active+1
@@ -626,6 +767,9 @@ class ChartDrawer:
                 # Secondary houses grid default x ~ 1015
                 secondary_houses_grid_right = 1015 + 120
                 extents.append(secondary_houses_grid_right)
+                first_house_comparison_grid_right = 1090 + 180
+                second_house_comparison_grid_right = 1290 + 180
+                extents.extend([first_house_comparison_grid_right, second_house_comparison_grid_right])
 
             if self.chart_type == "Transit":
                 # House comparison grid at x ~ 1030
@@ -640,6 +784,84 @@ class ChartDrawer:
         # Conservative safety padding
         return int(max(extents) + self._padding)
 
+    def _calculate_double_chart_aspect_columns(
+        self,
+        total_aspects: int,
+        chart_height: Optional[int],
+    ) -> int:
+        """Return how many columns the double-chart aspect list needs.
+
+        The first 11 columns follow the legacy 14-rows layout. Starting from the
+        12th column we can fit more rows thanks to the taller chart height that
+        gets computed earlier, so we re-use the same capacity as the SVG builder.
+        """
+        if total_aspects <= 0:
+            return 0
+
+        per_column = self._ASPECT_LIST_ASPECTS_PER_COLUMN
+        extended_start = 10  # 0-based index where tall columns begin
+        base_capacity = per_column * extended_start
+
+        full_height_capacity = self._calculate_full_height_column_capacity(chart_height)
+
+        if total_aspects <= base_capacity:
+            return ceil(total_aspects / per_column)
+
+        remaining = max(total_aspects - base_capacity, 0)
+        extra_columns = ceil(remaining / full_height_capacity) if remaining > 0 else 0
+        return extended_start + extra_columns
+
+    def _calculate_full_height_column_capacity(
+        self,
+        chart_height: Optional[int],
+    ) -> int:
+        """Compute the row capacity for columns that use the tall layout."""
+        per_column = self._ASPECT_LIST_ASPECTS_PER_COLUMN
+
+        if chart_height is None:
+            return per_column
+
+        translate_y = 273
+        bottom_padding = 40
+        title_clearance = 18
+        line_height = 14
+        baseline_index = per_column - 1
+        top_limit_index = ceil((-translate_y + title_clearance) / line_height)
+        max_capacity_by_top = baseline_index - top_limit_index + 1
+
+        available_height = max(chart_height - translate_y - bottom_padding, line_height)
+        allowed_capacity = max(per_column, int(available_height // line_height))
+
+        # Respect both the physical height of the SVG and the visual limit
+        # imposed by the title area.
+        return max(per_column, min(allowed_capacity, max_capacity_by_top))
+
+    def _minimum_width_for_chart_type(self) -> int:
+        """Baseline width to avoid compressing core groups too tightly."""
+        wheel_right = 100 + (2 * self.main_radius)
+        baseline = wheel_right + self._padding
+
+        if self.chart_type in ("Natal", "Composite", "SingleReturnChart"):
+            return max(int(baseline), self._DEFAULT_NATAL_WIDTH)
+        if self.chart_type == "Synastry":
+            return max(int(baseline), self._DEFAULT_SYNASTRY_WIDTH // 2)
+        if self.chart_type == "DualReturnChart":
+            return max(int(baseline), self._DEFAULT_ULTRA_WIDE_WIDTH // 2)
+        if self.chart_type == "Transit":
+            return max(int(baseline), self._DEFAULT_FULL_WIDTH // 2)
+        return max(int(baseline), self._DEFAULT_NATAL_WIDTH)
+
+    def _update_width_to_content(self) -> None:
+        """Resize the chart width so the farthest element fits comfortably."""
+        try:
+            required_width = self._estimate_required_width_full()
+        except Exception as e:
+            logging.debug(f"Auto-size width calculation failed: {e}")
+            return
+
+        minimum_width = self._minimum_width_for_chart_type()
+        self.width = max(required_width, minimum_width)
+
     def _get_location_info(self) -> tuple[str, float, float]:
         """
         Determine location information based on chart type and subjects.
@@ -687,17 +909,31 @@ class ChartDrawer:
         with open(theme_dir / f"{theme}.css", "r") as f:
             self.color_style_tag = f.read()
 
-    def parse_json_settings(self, settings_file_or_dict: Union[Path, dict, KerykeionSettingsModel, None]) -> None:
-        """
-        Load and parse chart configuration settings.
-
-        Args:
-            settings_file_or_dict (Path, dict, or KerykeionSettingsModel):
-                Source for custom chart settings.
-        """
-        settings = get_settings(settings_file_or_dict)
-
-        self.language_settings = settings["language_settings"][self.chart_language]
+    def _load_language_settings(
+        self,
+        language_pack: Optional[Mapping[str, Any]],
+    ) -> None:
+        """Resolve language models for the requested chart language."""
+        overrides = {self.chart_language: dict(language_pack)} if language_pack else None
+        languages = load_language_settings(overrides)
+
+        fallback_data = languages.get("EN")
+        if fallback_data is None:
+            raise KerykeionException("English translations are missing from LANGUAGE_SETTINGS.")
+
+        base_data = languages.get(self.chart_language, fallback_data)
+        selected_model = KerykeionLanguageModel(**base_data)
+        fallback_model = KerykeionLanguageModel(**fallback_data)
+
+        self._fallback_language_model = fallback_model
+        self._language_model = selected_model
+        self._fallback_language_dict = fallback_model.model_dump()
+        self._language_dict = selected_model.model_dump()
+        self.language_settings = self._language_dict  # Backward compatibility
+
+    def _translate(self, key: str, default: Any) -> Any:
+        fallback_value = get_translations(key, default, language_dict=self._fallback_language_dict)
+        return get_translations(key, fallback_value, language_dict=self._language_dict)
 
     def _draw_zodiac_circle_slices(self, r):
         """
@@ -774,7 +1010,7 @@ class ChartDrawer:
                 )
         return out
 
-    def _truncate_name(self, name: str, max_length: int = 50) -> str:
+    def _truncate_name(self, name: str, max_length: int = 50, ellipsis_symbol: str = "…", truncate_at_space: bool = False) -> str:
         """
         Truncate a name if it's too long, preserving readability.
 
@@ -785,9 +1021,13 @@ class ChartDrawer:
         Returns:
             str: Truncated name with ellipsis if needed
         """
+        if truncate_at_space:
+            name = name.split(" ")[0]
+
         if len(name) <= max_length:
             return name
-        return name[:max_length-1] + "…"
+
+        return name[:max_length-1] + ellipsis_symbol
 
     def _get_chart_title(self) -> str:
         """
@@ -805,52 +1045,49 @@ class ChartDrawer:
 
         # Generate default title based on chart type
         if self.chart_type == "Natal":
-            natal_label = self.language_settings.get("birth_chart", "Natal")
+            natal_label = self._translate("birth_chart", "Natal")
             truncated_name = self._truncate_name(self.first_obj.name)
             return f'{truncated_name} - {natal_label}'
 
         elif self.chart_type == "Composite":
-            composite_label = self.language_settings.get("composite_chart", "Composite")
-            and_word = self.language_settings.get("and_word", "&")
+            composite_label = self._translate("composite_chart", "Composite")
+            and_word = self._translate("and_word", "&")
             name1 = self._truncate_name(self.first_obj.first_subject.name) # type: ignore
             name2 = self._truncate_name(self.first_obj.second_subject.name) # type: ignore
             return f"{composite_label}: {name1} {and_word} {name2}"
 
         elif self.chart_type == "Transit":
-            transit_label = self.language_settings.get("transits", "Transits")
-            from datetime import datetime
+            transit_label = self._translate("transits", "Transits")
             date_obj = datetime.fromisoformat(self.second_obj.iso_formatted_local_datetime) # type: ignore
             date_str = date_obj.strftime("%d/%m/%y")
             truncated_name = self._truncate_name(self.first_obj.name)
             return f"{truncated_name} - {transit_label} {date_str}"
 
         elif self.chart_type == "Synastry":
-            synastry_label = self.language_settings.get("synastry_chart", "Synastry")
-            and_word = self.language_settings.get("and_word", "&")
+            synastry_label = self._translate("synastry_chart", "Synastry")
+            and_word = self._translate("and_word", "&")
             name1 = self._truncate_name(self.first_obj.name)
             name2 = self._truncate_name(self.second_obj.name) # type: ignore
             return f"{synastry_label}: {name1} {and_word} {name2}"
 
         elif self.chart_type == "DualReturnChart":
-            from datetime import datetime
             year = datetime.fromisoformat(self.second_obj.iso_formatted_local_datetime).year # type: ignore
             truncated_name = self._truncate_name(self.first_obj.name)
             if self.second_obj is not None and isinstance(self.second_obj, PlanetReturnModel) and self.second_obj.return_type == "Solar":
-                solar_label = self.language_settings.get("solar_return", "Solar")
+                solar_label = self._translate("solar_return", "Solar")
                 return f"{truncated_name} - {solar_label} {year}"
             else:
-                lunar_label = self.language_settings.get("lunar_return", "Lunar")
+                lunar_label = self._translate("lunar_return", "Lunar")
                 return f"{truncated_name} - {lunar_label} {year}"
 
         elif self.chart_type == "SingleReturnChart":
-            from datetime import datetime
             year = datetime.fromisoformat(self.first_obj.iso_formatted_local_datetime).year # type: ignore
             truncated_name = self._truncate_name(self.first_obj.name)
             if isinstance(self.first_obj, PlanetReturnModel) and self.first_obj.return_type == "Solar":
-                solar_label = self.language_settings.get("solar_return", "Solar")
+                solar_label = self._translate("solar_return", "Solar")
                 return f"{truncated_name} - {solar_label} {year}"
             else:
-                lunar_label = self.language_settings.get("lunar_return", "Lunar")
+                lunar_label = self._translate("lunar_return", "Lunar")
                 return f"{truncated_name} - {lunar_label} {year}"
 
         # Fallback for unknown chart types
@@ -929,11 +1166,11 @@ class ChartDrawer:
         water_percentage = element_percentages["water"]
 
         # Element Percentages
-        template_dict["elements_string"] = f"{self.language_settings.get('elements', 'Elements')}:"
-        template_dict["fire_string"] = f"{self.language_settings['fire']} {fire_percentage}%"
-        template_dict["earth_string"] = f"{self.language_settings['earth']} {earth_percentage}%"
-        template_dict["air_string"] = f"{self.language_settings['air']} {air_percentage}%"
-        template_dict["water_string"] = f"{self.language_settings['water']} {water_percentage}%"
+        template_dict["elements_string"] = f"{self._translate('elements', 'Elements')}:"
+        template_dict["fire_string"] = f"{self._translate('fire', 'Fire')} {fire_percentage}%"
+        template_dict["earth_string"] = f"{self._translate('earth', 'Earth')} {earth_percentage}%"
+        template_dict["air_string"] = f"{self._translate('air', 'Air')} {air_percentage}%"
+        template_dict["water_string"] = f"{self._translate('water', 'Water')} {water_percentage}%"
 
 
         # Qualities Percentages
@@ -944,10 +1181,10 @@ class ChartDrawer:
         fixed_percentage = quality_percentages["fixed"]
         mutable_percentage = quality_percentages["mutable"]
 
-        template_dict["qualities_string"] = f"{self.language_settings.get('qualities', 'Qualities')}:"
-        template_dict["cardinal_string"] = f"{self.language_settings.get('cardinal', 'Cardinal')} {cardinal_percentage}%"
-        template_dict["fixed_string"] = f"{self.language_settings.get('fixed', 'Fixed')} {fixed_percentage}%"
-        template_dict["mutable_string"] = f"{self.language_settings.get('mutable', 'Mutable')} {mutable_percentage}%"
+        template_dict["qualities_string"] = f"{self._translate('qualities', 'Qualities')}:"
+        template_dict["cardinal_string"] = f"{self._translate('cardinal', 'Cardinal')} {cardinal_percentage}%"
+        template_dict["fixed_string"] = f"{self._translate('fixed', 'Fixed')} {fixed_percentage}%"
+        template_dict["mutable_string"] = f"{self._translate('mutable', 'Mutable')} {mutable_percentage}%"
 
         # Get houses list for main subject
         first_subject_houses_list = get_houses_list(self.first_obj)
@@ -1007,37 +1244,60 @@ class ChartDrawer:
             template_dict["makeAspects"] = self._draw_all_aspects_lines(self.main_radius, self.main_radius - self.third_circle_radius)
 
             # Top left section
-            latitude_string = convert_latitude_coordinate_to_string(self.geolat, self.language_settings["north"], self.language_settings["south"])
-            longitude_string = convert_longitude_coordinate_to_string(self.geolon, self.language_settings["east"], self.language_settings["west"])
+            latitude_string = convert_latitude_coordinate_to_string(
+                self.geolat,
+                self._translate("north", "North"),
+                self._translate("south", "South"),
+            )
+            longitude_string = convert_longitude_coordinate_to_string(
+                self.geolon,
+                self._translate("east", "East"),
+                self._translate("west", "West"),
+            )
 
-            template_dict["top_left_0"] = f'{self.language_settings.get("location", "Location")}:'
+            template_dict["top_left_0"] = f'{self._translate("location", "Location")}:'
             template_dict["top_left_1"] = f"{self.first_obj.city}, {self.first_obj.nation}"
-            template_dict["top_left_2"] = f"{self.language_settings['latitude']}: {latitude_string}"
-            template_dict["top_left_3"] = f"{self.language_settings['longitude']}: {longitude_string}"
+            template_dict["top_left_2"] = f"{self._translate('latitude', 'Latitude')}: {latitude_string}"
+            template_dict["top_left_3"] = f"{self._translate('longitude', 'Longitude')}: {longitude_string}"
             template_dict["top_left_4"] = format_datetime_with_timezone(self.first_obj.iso_formatted_local_datetime) # type: ignore
-            localized_weekday = self.language_settings.get('weekdays', {}).get(self.first_obj.day_of_week, self.first_obj.day_of_week)  # type: ignore
-            template_dict["top_left_5"] = f"{self.language_settings.get('day_of_week', 'Day of Week')}: {localized_weekday}" # type: ignore
+            localized_weekday = self._translate(
+                f"weekdays.{self.first_obj.day_of_week}",
+                self.first_obj.day_of_week,  # type: ignore[arg-type]
+            )
+            template_dict["top_left_5"] = f"{self._translate('day_of_week', 'Day of Week')}: {localized_weekday}" # type: ignore
 
             # Bottom left section
             if self.first_obj.zodiac_type == "Tropic":
-                zodiac_info = f"{self.language_settings.get('zodiac', 'Zodiac')}: {self.language_settings.get('tropical', 'Tropical')}"
+                zodiac_info = f"{self._translate('zodiac', 'Zodiac')}: {self._translate('tropical', 'Tropical')}"
             else:
                 mode_const = "SIDM_" + self.first_obj.sidereal_mode # type: ignore
                 mode_name = swe.get_ayanamsa_name(getattr(swe, mode_const))
-                zodiac_info = f"{self.language_settings.get('ayanamsa', 'Ayanamsa')}: {mode_name}"
+                zodiac_info = f"{self._translate('ayanamsa', 'Ayanamsa')}: {mode_name}"
 
             template_dict["bottom_left_0"] = zodiac_info
-            template_dict["bottom_left_1"] = f"{self.language_settings.get('domification', 'Domification')}: {self.language_settings.get('houses_system_' + self.first_obj.houses_system_identifier, self.first_obj.houses_system_name)}"
+            template_dict["bottom_left_1"] = (
+                f"{self._translate('domification', 'Domification')}: "
+                f"{self._translate('houses_system_' + self.first_obj.houses_system_identifier, self.first_obj.houses_system_name)}"
+            )
 
             # Lunar phase information (optional)
             if self.first_obj.lunar_phase is not None:
-                template_dict["bottom_left_2"] = f'{self.language_settings.get("lunation_day", "Lunation Day")}: {self.first_obj.lunar_phase.get("moon_phase", "")}'
-                template_dict["bottom_left_3"] = f'{self.language_settings.get("lunar_phase", "Lunar Phase")}: {self.language_settings.get(self.first_obj.lunar_phase.moon_phase_name.lower().replace(" ", "_"), self.first_obj.lunar_phase.moon_phase_name)}'
+                template_dict["bottom_left_2"] = (
+                    f'{self._translate("lunation_day", "Lunation Day")}: '
+                    f'{self.first_obj.lunar_phase.get("moon_phase", "")}'
+                )
+                template_dict["bottom_left_3"] = (
+                    f'{self._translate("lunar_phase", "Lunar Phase")}: '
+                    f'{self._translate(self.first_obj.lunar_phase.moon_phase_name.lower().replace(" ", "_"), self.first_obj.lunar_phase.moon_phase_name)}'
+                )
             else:
                 template_dict["bottom_left_2"] = ""
                 template_dict["bottom_left_3"] = ""
 
-            template_dict["bottom_left_4"] = f'{self.language_settings.get("perspective_type", "Perspective")}: {self.language_settings.get(self.first_obj.perspective_type.lower().replace(" ", "_"), self.first_obj.perspective_type)}'
+            template_dict["bottom_left_4"] = (
+                f'{self._translate("perspective_type", "Perspective")}: '
+                f'{self._translate(self.first_obj.perspective_type.lower().replace(" ", "_"), self.first_obj.perspective_type)}'
+            )
 
             # Moon phase section calculations
             if self.first_obj.lunar_phase is not None:
@@ -1049,7 +1309,7 @@ class ChartDrawer:
             template_dict["makeMainHousesGrid"] = draw_main_house_grid(
                 main_subject_houses_list=first_subject_houses_list,
                 text_color=self.chart_colors_settings["paper_0"],
-                house_cusp_generale_name_label=self.language_settings["cusp"],
+                house_cusp_generale_name_label=self._translate("cusp", "Cusp"),
             )
             template_dict["makeSecondaryHousesGrid"] = ""
 
@@ -1079,12 +1339,12 @@ class ChartDrawer:
             )
 
             template_dict["makeMainPlanetGrid"] = draw_main_planet_grid(
-                planets_and_houses_grid_title=self.language_settings["planets_and_house"],
+                planets_and_houses_grid_title=self._translate("planets_and_house", "Points for"),
                 subject_name=self.first_obj.name,
                 available_kerykeion_celestial_points=self.available_kerykeion_celestial_points,
                 chart_type=self.chart_type,
                 text_color=self.chart_colors_settings["paper_0"],
-                celestial_point_language=self.language_settings["celestial_points"],
+                celestial_point_language=self._language_model.celestial_points,
             )
             template_dict["makeSecondaryPlanetGrid"] = ""
             template_dict["makeHouseComparisonGrid"] = ""
@@ -1140,25 +1400,25 @@ class ChartDrawer:
             # First subject
             latitude = convert_latitude_coordinate_to_string(
                 self.first_obj.first_subject.lat, # type: ignore
-                self.language_settings["north_letter"],
-                self.language_settings["south_letter"],
+                self._translate("north_letter", "N"),
+                self._translate("south_letter", "S"),
             )
             longitude = convert_longitude_coordinate_to_string(
                 self.first_obj.first_subject.lng, # type: ignore
-                self.language_settings["east_letter"],
-                self.language_settings["west_letter"],
+                self._translate("east_letter", "E"),
+                self._translate("west_letter", "W"),
             )
 
             # Second subject
             latitude_string = convert_latitude_coordinate_to_string(
                 self.first_obj.second_subject.lat, # type: ignore
-                self.language_settings["north_letter"],
-                self.language_settings["south_letter"],
+                self._translate("north_letter", "N"),
+                self._translate("south_letter", "S"),
             )
             longitude_string = convert_longitude_coordinate_to_string(
                 self.first_obj.second_subject.lng, # type: ignore
-                self.language_settings["east_letter"],
-                self.language_settings["west_letter"],
+                self._translate("east_letter", "E"),
+                self._translate("west_letter", "W"),
             )
 
             template_dict["top_left_0"] = f"{self.first_obj.first_subject.name}" # type: ignore
@@ -1170,16 +1430,16 @@ class ChartDrawer:
 
             # Bottom left section
             if self.first_obj.zodiac_type == "Tropic":
-                zodiac_info = f"{self.language_settings.get('zodiac', 'Zodiac')}: {self.language_settings.get('tropical', 'Tropical')}"
+                zodiac_info = f"{self._translate('zodiac', 'Zodiac')}: {self._translate('tropical', 'Tropical')}"
             else:
                 mode_const = "SIDM_" + self.first_obj.sidereal_mode # type: ignore
                 mode_name = swe.get_ayanamsa_name(getattr(swe, mode_const))
-                zodiac_info = f"{self.language_settings.get('ayanamsa', 'Ayanamsa')}: {mode_name}"
+                zodiac_info = f"{self._translate('ayanamsa', 'Ayanamsa')}: {mode_name}"
 
             template_dict["bottom_left_0"] = zodiac_info
-            template_dict["bottom_left_1"] = f"{self.language_settings.get('houses_system_' + self.first_obj.houses_system_identifier, self.first_obj.houses_system_name)} {self.language_settings.get('houses', 'Houses')}"
-            template_dict["bottom_left_2"] = f'{self.language_settings.get("perspective_type", "Perspective")}: {self.first_obj.first_subject.perspective_type}' # type: ignore
-            template_dict["bottom_left_3"] = f'{self.language_settings.get("composite_chart", "Composite Chart")} - {self.language_settings.get("midpoints", "Midpoints")}'
+            template_dict["bottom_left_1"] = f"{self._translate('houses_system_' + self.first_obj.houses_system_identifier, self.first_obj.houses_system_name)} {self._translate('houses', 'Houses')}"
+            template_dict["bottom_left_2"] = f'{self._translate("perspective_type", "Perspective")}: {self.first_obj.first_subject.perspective_type}' # type: ignore
+            template_dict["bottom_left_3"] = f'{self._translate("composite_chart", "Composite Chart")} - {self._translate("midpoints", "Midpoints")}'
             template_dict["bottom_left_4"] = ""
 
             # Moon phase section calculations
@@ -1192,7 +1452,7 @@ class ChartDrawer:
             template_dict["makeMainHousesGrid"] = draw_main_house_grid(
                 main_subject_houses_list=first_subject_houses_list,
                 text_color=self.chart_colors_settings["paper_0"],
-                house_cusp_generale_name_label=self.language_settings["cusp"],
+                house_cusp_generale_name_label=self._translate("cusp", "Cusp"),
             )
             template_dict["makeSecondaryHousesGrid"] = ""
 
@@ -1221,15 +1481,19 @@ class ChartDrawer:
                 external_view=self.external_view,
             )
 
-            subject_name = f"{self.first_obj.first_subject.name} {self.language_settings['and_word']} {self.first_obj.second_subject.name}" # type: ignore
+            subject_name = (
+                f"{self.first_obj.first_subject.name}"
+                f" {self._translate('and_word', '&')} "
+                f"{self.first_obj.second_subject.name}"
+            )  # type: ignore
 
             template_dict["makeMainPlanetGrid"] = draw_main_planet_grid(
-                planets_and_houses_grid_title=self.language_settings["planets_and_house"],
+                planets_and_houses_grid_title=self._translate("planets_and_house", "Points for"),
                 subject_name=subject_name,
                 available_kerykeion_celestial_points=self.available_kerykeion_celestial_points,
                 chart_type=self.chart_type,
                 text_color=self.chart_colors_settings["paper_0"],
-                celestial_point_language=self.language_settings["celestial_points"],
+                celestial_point_language=self._language_model.celestial_points,
             )
             template_dict["makeSecondaryPlanetGrid"] = ""
             template_dict["makeHouseComparisonGrid"] = ""
@@ -1288,9 +1552,15 @@ class ChartDrawer:
 
             # Aspects
             if self.double_chart_aspect_grid_type == "list":
-                title = f'{self.first_obj.name} - {self.language_settings.get("transit_aspects", "Transit Aspects")}'
+                title = f'{self.first_obj.name} - {self._translate("transit_aspects", "Transit Aspects")}'
                 template_dict["makeAspectGrid"] = ""
-                template_dict["makeDoubleChartAspectList"] = draw_transit_aspect_list(title, self.aspects_list, self.planets_settings, self.aspects_settings)  # type: ignore[arg-type]  # type: ignore[arg-type]
+                template_dict["makeDoubleChartAspectList"] = draw_transit_aspect_list(
+                    title,
+                    self.aspects_list,
+                    self.planets_settings,
+                    self.aspects_settings,
+                    chart_height=self.height,
+                )  # type: ignore[arg-type]
             else:
                 template_dict["makeAspectGrid"] = ""
                 template_dict["makeDoubleChartAspectList"] = draw_transit_aspect_grid(
@@ -1304,36 +1574,36 @@ class ChartDrawer:
             template_dict["makeAspects"] = self._draw_all_transit_aspects_lines(self.main_radius, self.main_radius - 160)
 
             # Top left section
-            latitude_string = convert_latitude_coordinate_to_string(self.geolat, self.language_settings["north"], self.language_settings["south"])
-            longitude_string = convert_longitude_coordinate_to_string(self.geolon, self.language_settings["east"], self.language_settings["west"])
+            latitude_string = convert_latitude_coordinate_to_string(self.geolat, self._translate("north", "North"), self._translate("south", "South"))
+            longitude_string = convert_longitude_coordinate_to_string(self.geolon, self._translate("east", "East"), self._translate("west", "West"))
 
-            template_dict["top_left_0"] = template_dict["top_left_0"] = f'{self.first_obj.name}'
+            template_dict["top_left_0"] = f"{self.first_obj.name}"
             template_dict["top_left_1"] = f"{format_location_string(self.first_obj.city)}, {self.first_obj.nation}" # type: ignore
             template_dict["top_left_2"] = format_datetime_with_timezone(self.first_obj.iso_formatted_local_datetime) # type: ignore
-            template_dict["top_left_3"] = f"{self.language_settings['latitude']}: {latitude_string}"
-            template_dict["top_left_4"] = f"{self.language_settings['longitude']}: {longitude_string}"
-            template_dict["top_left_5"] = ""#f"{self.language_settings['type']}: {self.language_settings.get(self.chart_type, self.chart_type)}"
+            template_dict["top_left_3"] = f"{self._translate('latitude', 'Latitude')}: {latitude_string}"
+            template_dict["top_left_4"] = f"{self._translate('longitude', 'Longitude')}: {longitude_string}"
+            template_dict["top_left_5"] = ""#f"{self._translate('type', 'Type')}: {self._translate(self.chart_type, self.chart_type)}"
 
             # Bottom left section
             if self.first_obj.zodiac_type == "Tropic":
-                zodiac_info = f"{self.language_settings.get('zodiac', 'Zodiac')}: {self.language_settings.get('tropical', 'Tropical')}"
+                zodiac_info = f"{self._translate('zodiac', 'Zodiac')}: {self._translate('tropical', 'Tropical')}"
             else:
                 mode_const = "SIDM_" + self.first_obj.sidereal_mode # type: ignore
                 mode_name = swe.get_ayanamsa_name(getattr(swe, mode_const))
-                zodiac_info = f"{self.language_settings.get('ayanamsa', 'Ayanamsa')}: {mode_name}"
+                zodiac_info = f"{self._translate('ayanamsa', 'Ayanamsa')}: {mode_name}"
 
             template_dict["bottom_left_0"] = zodiac_info
-            template_dict["bottom_left_1"] = f"{self.language_settings.get('domification', 'Domification')}: {self.language_settings.get('houses_system_' + self.first_obj.houses_system_identifier, self.first_obj.houses_system_name)}"
+            template_dict["bottom_left_1"] = f"{self._translate('domification', 'Domification')}: {self._translate('houses_system_' + self.first_obj.houses_system_identifier, self.first_obj.houses_system_name)}"
 
             # Lunar phase information from second object (Transit) (optional)
             if self.second_obj is not None and hasattr(self.second_obj, 'lunar_phase') and self.second_obj.lunar_phase is not None:
-                template_dict["bottom_left_2"] = f'{self.language_settings.get("lunation_day", "Lunation Day")}: {self.second_obj.lunar_phase.get("moon_phase", "")}' # type: ignore
-                template_dict["bottom_left_3"] = f'{self.language_settings.get("lunar_phase", "Lunar Phase")}: {self.language_settings.get(self.second_obj.lunar_phase.moon_phase_name.lower().replace(" ", "_"), self.second_obj.lunar_phase.moon_phase_name)}'
+                template_dict["bottom_left_2"] = f'{self._translate("lunation_day", "Lunation Day")}: {self.second_obj.lunar_phase.get("moon_phase", "")}' # type: ignore
+                template_dict["bottom_left_3"] = f'{self._translate("lunar_phase", "Lunar Phase")}: {self._translate(self.second_obj.lunar_phase.moon_phase_name.lower().replace(" ", "_"), self.second_obj.lunar_phase.moon_phase_name)}'
             else:
                 template_dict["bottom_left_2"] = ""
                 template_dict["bottom_left_3"] = ""
 
-            template_dict["bottom_left_4"] = f'{self.language_settings.get("perspective_type", "Perspective")}: {self.language_settings.get(self.second_obj.perspective_type.lower().replace(" ", "_"), self.second_obj.perspective_type)}' # type: ignore
+            template_dict["bottom_left_4"] = f'{self._translate("perspective_type", "Perspective")}: {self._translate(self.second_obj.perspective_type.lower().replace(" ", "_"), self.second_obj.perspective_type)}' # type: ignore
 
             # Moon phase section calculations - use first_obj for visualization
             if self.first_obj.lunar_phase is not None:
@@ -1345,12 +1615,12 @@ class ChartDrawer:
             template_dict["makeMainHousesGrid"] = draw_main_house_grid(
                 main_subject_houses_list=first_subject_houses_list,
                 text_color=self.chart_colors_settings["paper_0"],
-                house_cusp_generale_name_label=self.language_settings["cusp"],
+                house_cusp_generale_name_label=self._translate("cusp", "Cusp"),
             )
             # template_dict["makeSecondaryHousesGrid"] = draw_secondary_house_grid(
             #     secondary_subject_houses_list=second_subject_houses_list,
             #     text_color=self.chart_colors_settings["paper_0"],
-            #     house_cusp_generale_name_label=self.language_settings["cusp"],
+            #     house_cusp_generale_name_label=self._translate("cusp", "Cusp"),
             # )
             template_dict["makeSecondaryHousesGrid"] = ""
 
@@ -1383,15 +1653,17 @@ class ChartDrawer:
             )
 
             # Planet grids
-            first_return_grid_title = f"{self.first_obj.name} ({self.language_settings.get('inner_wheel', 'Inner Wheel')})"
-            second_return_grid_title = f"{self.language_settings.get('Transit', 'Transit')} ({self.language_settings.get('outer_wheel', 'Outer Wheel')})"
+            first_name_label = self._truncate_name(self.first_obj.name)
+            transit_label = self._translate("transit", "Transit")
+            first_return_grid_title = f"{first_name_label} ({self._translate('inner_wheel', 'Inner Wheel')})"
+            second_return_grid_title = f"{transit_label} ({self._translate('outer_wheel', 'Outer Wheel')})"
             template_dict["makeMainPlanetGrid"] = draw_main_planet_grid(
                 planets_and_houses_grid_title="",
                 subject_name=first_return_grid_title,
                 available_kerykeion_celestial_points=self.available_kerykeion_celestial_points,
                 chart_type=self.chart_type,
                 text_color=self.chart_colors_settings["paper_0"],
-                celestial_point_language=self.language_settings["celestial_points"],
+                celestial_point_language=self._language_model.celestial_points,
             )
 
             template_dict["makeSecondaryPlanetGrid"] = draw_secondary_planet_grid(
@@ -1400,7 +1672,7 @@ class ChartDrawer:
                 second_subject_available_kerykeion_celestial_points=self.t_available_kerykeion_celestial_points,
                 chart_type=self.chart_type,
                 text_color=self.chart_colors_settings["paper_0"],
-                celestial_point_language=self.language_settings["celestial_points"],
+                celestial_point_language=self._language_model.celestial_points,
             )
 
             # House comparison grid
@@ -1413,12 +1685,12 @@ class ChartDrawer:
 
             template_dict["makeHouseComparisonGrid"] = draw_single_house_comparison_grid(
                 house_comparison,
-                celestial_point_language=self.language_settings.get("celestial_points", "Celestial Points"),
+                celestial_point_language=self._language_model.celestial_points,
                 active_points=self.active_points,
                 points_owner_subject_number=2, # The second subject is the Transit
-                house_position_comparison_label=self.language_settings.get("house_position_comparison", "House Position Comparison"),
-                return_point_label=self.language_settings.get("transit_point", "Transit Point"),
-                natal_house_label=self.language_settings.get("house_position", "Natal House"),
+                house_position_comparison_label=self._translate("house_position_comparison", "House Position Comparison"),
+                return_point_label=self._translate("transit_point", "Transit Point"),
+                natal_house_label=self._translate("house_position", "Natal House"),
                 x_position=980,
             )
 
@@ -1464,10 +1736,11 @@ class ChartDrawer:
             if self.double_chart_aspect_grid_type == "list":
                 template_dict["makeAspectGrid"] = ""
                 template_dict["makeDoubleChartAspectList"] = draw_transit_aspect_list(
-                    f"{self.first_obj.name} - {self.second_obj.name} {self.language_settings.get('synastry_aspects', 'Synastry Aspects')}",  # type: ignore[union-attr]
+                    f"{self.first_obj.name} - {self.second_obj.name} {self._translate('synastry_aspects', 'Synastry Aspects')}",  # type: ignore[union-attr]
                     self.aspects_list,
                     self.planets_settings,  # type: ignore[arg-type]
-                    self.aspects_settings  # type: ignore[arg-type]
+                    self.aspects_settings,  # type: ignore[arg-type]
+                    chart_height=self.height,
                 )
             else:
                 template_dict["makeAspectGrid"] = ""
@@ -1491,18 +1764,18 @@ class ChartDrawer:
 
             # Bottom left section
             if self.first_obj.zodiac_type == "Tropic":
-                zodiac_info = f"{self.language_settings.get('zodiac', 'Zodiac')}: {self.language_settings.get('tropical', 'Tropical')}"
+                zodiac_info = f"{self._translate('zodiac', 'Zodiac')}: {self._translate('tropical', 'Tropical')}"
             else:
                 mode_const = "SIDM_" + self.first_obj.sidereal_mode # type: ignore
                 mode_name = swe.get_ayanamsa_name(getattr(swe, mode_const))
-                zodiac_info = f"{self.language_settings.get('ayanamsa', 'Ayanamsa')}: {mode_name}"
+                zodiac_info = f"{self._translate('ayanamsa', 'Ayanamsa')}: {mode_name}"
 
             template_dict["bottom_left_0"] = ""
             # FIXME!
             template_dict["bottom_left_1"] = "" # f"Compatibility Score: {16}/44" # type: ignore
             template_dict["bottom_left_2"] = zodiac_info
-            template_dict["bottom_left_3"] = f"{self.language_settings.get('houses_system_' + self.first_obj.houses_system_identifier, self.first_obj.houses_system_name)} {self.language_settings.get('houses', 'Houses')}"
-            template_dict["bottom_left_4"] = f'{self.language_settings.get("perspective_type", "Perspective")}: {self.language_settings.get(self.first_obj.perspective_type.lower().replace(" ", "_"), self.first_obj.perspective_type)}'
+            template_dict["bottom_left_3"] = f"{self._translate('houses_system_' + self.first_obj.houses_system_identifier, self.first_obj.houses_system_name)} {self._translate('houses', 'Houses')}"
+            template_dict["bottom_left_4"] = f'{self._translate("perspective_type", "Perspective")}: {self._translate(self.first_obj.perspective_type.lower().replace(" ", "_"), self.first_obj.perspective_type)}'
 
             # Moon phase section calculations
             template_dict["makeLunarPhase"] = ""
@@ -1511,13 +1784,13 @@ class ChartDrawer:
             template_dict["makeMainHousesGrid"] = draw_main_house_grid(
                 main_subject_houses_list=first_subject_houses_list,
                 text_color=self.chart_colors_settings["paper_0"],
-                house_cusp_generale_name_label=self.language_settings["cusp"],
+                house_cusp_generale_name_label=self._translate("cusp", "Cusp"),
             )
 
             template_dict["makeSecondaryHousesGrid"] = draw_secondary_house_grid(
                 secondary_subject_houses_list=second_subject_houses_list,
                 text_color=self.chart_colors_settings["paper_0"],
-                house_cusp_generale_name_label=self.language_settings["cusp"],
+                house_cusp_generale_name_label=self._translate("cusp", "Cusp"),
             )
 
             template_dict["makeHouses"] = draw_houses_cusps_and_text_number(
@@ -1549,23 +1822,63 @@ class ChartDrawer:
             )
 
             # Planet grid
+            first_name_label = self._truncate_name(self.first_obj.name, 18, "…")  # type: ignore[union-attr]
+            second_name_label = self._truncate_name(self.second_obj.name, 18, "…")  # type: ignore[union-attr]
             template_dict["makeMainPlanetGrid"] = draw_main_planet_grid(
                 planets_and_houses_grid_title="",
-                subject_name=f"{self.first_obj.name} ({self.language_settings.get('inner_wheel', 'Inner Wheel')})",
+                subject_name=f"{first_name_label} ({self._translate('inner_wheel', 'Inner Wheel')})",
                 available_kerykeion_celestial_points=self.available_kerykeion_celestial_points,
                 chart_type=self.chart_type,
                 text_color=self.chart_colors_settings["paper_0"],
-                celestial_point_language=self.language_settings["celestial_points"],
+                celestial_point_language=self._language_model.celestial_points,
             )
             template_dict["makeSecondaryPlanetGrid"] = draw_secondary_planet_grid(
                 planets_and_houses_grid_title="",
-                second_subject_name= f"{self.second_obj.name} ({self.language_settings.get('outer_wheel', 'Outer Wheel')})", # type: ignore
+                second_subject_name= f"{second_name_label} ({self._translate('outer_wheel', 'Outer Wheel')})", # type: ignore
                 second_subject_available_kerykeion_celestial_points=self.t_available_kerykeion_celestial_points,
                 chart_type=self.chart_type,
                 text_color=self.chart_colors_settings["paper_0"],
-                celestial_point_language=self.language_settings["celestial_points"],
+                celestial_point_language=self._language_model.celestial_points,
             )
-            template_dict["makeHouseComparisonGrid"] = ""
+            house_comparison_factory = HouseComparisonFactory(
+                first_subject=self.first_obj,  # type: ignore[arg-type]
+                second_subject=self.second_obj,  # type: ignore[arg-type]
+                active_points=self.active_points,
+            )
+            house_comparison = house_comparison_factory.get_house_comparison()
+
+            first_subject_label = self._truncate_name(self.first_obj.name, 8, "…", True)  # type: ignore[union-attr]
+            second_subject_label = self._truncate_name(self.second_obj.name, 8, "…", True)  # type: ignore[union-attr]
+            point_column_label = self._translate("point", "Point")
+            comparison_label = self._translate("house_position_comparison", "House Position Comparison")
+
+            first_subject_grid = draw_house_comparison_grid(
+                house_comparison,
+                celestial_point_language=self._language_model.celestial_points,
+                active_points=self.active_points,
+                points_owner_subject_number=1,
+                house_position_comparison_label=comparison_label,
+                return_point_label=first_subject_label + " " + point_column_label,
+                return_label=first_subject_label,
+                radix_label=second_subject_label,
+                x_position=1090,
+                y_position=0,
+            )
+
+            second_subject_grid = draw_house_comparison_grid(
+                house_comparison,
+                celestial_point_language=self._language_model.celestial_points,
+                active_points=self.active_points,
+                points_owner_subject_number=2,
+                house_position_comparison_label="",
+                return_point_label=second_subject_label + " " + point_column_label,
+                return_label=second_subject_label,
+                radix_label=first_subject_label,
+                x_position=1290,
+                y_position=0,
+            )
+
+            template_dict["makeHouseComparisonGrid"] = first_subject_grid + second_subject_grid
 
         elif self.chart_type == "DualReturnChart":
             # Set viewbox dynamically
@@ -1607,9 +1920,16 @@ class ChartDrawer:
 
             # Aspects
             if self.double_chart_aspect_grid_type == "list":
-                title = self.language_settings.get("return_aspects", "Natal to Return Aspects")
+                title = self._translate("return_aspects", "Natal to Return Aspects")
                 template_dict["makeAspectGrid"] = ""
-                template_dict["makeDoubleChartAspectList"] = draw_transit_aspect_list(title, self.aspects_list, self.planets_settings, self.aspects_settings, max_columns=7)  # type: ignore[arg-type]  # type: ignore[arg-type]
+                template_dict["makeDoubleChartAspectList"] = draw_transit_aspect_list(
+                    title,
+                    self.aspects_list,
+                    self.planets_settings,
+                    self.aspects_settings,
+                    max_columns=7,
+                    chart_height=self.height,
+                )  # type: ignore[arg-type]
             else:
                 template_dict["makeAspectGrid"] = ""
                 template_dict["makeDoubleChartAspectList"] = draw_transit_aspect_grid(
@@ -1625,17 +1945,17 @@ class ChartDrawer:
 
             # Top left section
             # Subject
-            latitude_string = convert_latitude_coordinate_to_string(self.first_obj.lat, self.language_settings["north"], self.language_settings["south"]) # type: ignore
-            longitude_string = convert_longitude_coordinate_to_string(self.first_obj.lng, self.language_settings["east"], self.language_settings["west"]) # type: ignore
+            latitude_string = convert_latitude_coordinate_to_string(self.first_obj.lat, self._translate("north", "North"), self._translate("south", "South")) # type: ignore
+            longitude_string = convert_longitude_coordinate_to_string(self.first_obj.lng, self._translate("east", "East"), self._translate("west", "West")) # type: ignore
 
             # Return
-            return_latitude_string = convert_latitude_coordinate_to_string(self.second_obj.lat, self.language_settings["north"], self.language_settings["south"]) # type: ignore
-            return_longitude_string = convert_longitude_coordinate_to_string(self.second_obj.lng, self.language_settings["east"], self.language_settings["west"]) # type: ignore
+            return_latitude_string = convert_latitude_coordinate_to_string(self.second_obj.lat, self._translate("north", "North"), self._translate("south", "South")) # type: ignore
+            return_longitude_string = convert_longitude_coordinate_to_string(self.second_obj.lng, self._translate("east", "East"), self._translate("west", "West")) # type: ignore
 
             if self.second_obj is not None and hasattr(self.second_obj, 'return_type') and self.second_obj.return_type == "Solar":
-                template_dict["top_left_0"] = f"{self.language_settings.get('solar_return', 'Solar Return')}:"
+                template_dict["top_left_0"] = f"{self._translate('solar_return', 'Solar Return')}:"
             else:
-                template_dict["top_left_0"] = f"{self.language_settings.get('lunar_return', 'Lunar Return')}:"
+                template_dict["top_left_0"] = f"{self._translate('lunar_return', 'Lunar Return')}:"
             template_dict["top_left_1"] = format_datetime_with_timezone(self.second_obj.iso_formatted_local_datetime) # type: ignore
             template_dict["top_left_2"] = f"{return_latitude_string} / {return_longitude_string}"
             template_dict["top_left_3"] = f"{self.first_obj.name}"
@@ -1644,24 +1964,24 @@ class ChartDrawer:
 
             # Bottom left section
             if self.first_obj.zodiac_type == "Tropic":
-                zodiac_info = f"{self.language_settings.get('zodiac', 'Zodiac')}: {self.language_settings.get('tropical', 'Tropical')}"
+                zodiac_info = f"{self._translate('zodiac', 'Zodiac')}: {self._translate('tropical', 'Tropical')}"
             else:
                 mode_const = "SIDM_" + self.first_obj.sidereal_mode # type: ignore
                 mode_name = swe.get_ayanamsa_name(getattr(swe, mode_const))
-                zodiac_info = f"{self.language_settings.get('ayanamsa', 'Ayanamsa')}: {mode_name}"
+                zodiac_info = f"{self._translate('ayanamsa', 'Ayanamsa')}: {mode_name}"
 
             template_dict["bottom_left_0"] = zodiac_info
-            template_dict["bottom_left_1"] = f"{self.language_settings.get('domification', 'Domification')}: {self.language_settings.get('houses_system_' + self.first_obj.houses_system_identifier, self.first_obj.houses_system_name)}"
+            template_dict["bottom_left_1"] = f"{self._translate('domification', 'Domification')}: {self._translate('houses_system_' + self.first_obj.houses_system_identifier, self.first_obj.houses_system_name)}"
 
             # Lunar phase information (optional)
             if self.first_obj.lunar_phase is not None:
-                template_dict["bottom_left_2"] = f'{self.language_settings.get("lunation_day", "Lunation Day")}: {self.first_obj.lunar_phase.get("moon_phase", "")}'
-                template_dict["bottom_left_3"] = f'{self.language_settings.get("lunar_phase", "Lunar Phase")}: {self.language_settings.get(self.first_obj.lunar_phase.moon_phase_name.lower().replace(" ", "_"), self.first_obj.lunar_phase.moon_phase_name)}'
+                template_dict["bottom_left_2"] = f'{self._translate("lunation_day", "Lunation Day")}: {self.first_obj.lunar_phase.get("moon_phase", "")}'
+                template_dict["bottom_left_3"] = f'{self._translate("lunar_phase", "Lunar Phase")}: {self._translate(self.first_obj.lunar_phase.moon_phase_name.lower().replace(" ", "_"), self.first_obj.lunar_phase.moon_phase_name)}'
             else:
                 template_dict["bottom_left_2"] = ""
                 template_dict["bottom_left_3"] = ""
 
-            template_dict["bottom_left_4"] = f'{self.language_settings.get("perspective_type", "Perspective")}: {self.language_settings.get(self.first_obj.perspective_type.lower().replace(" ", "_"), self.first_obj.perspective_type)}'
+            template_dict["bottom_left_4"] = f'{self._translate("perspective_type", "Perspective")}: {self._translate(self.first_obj.perspective_type.lower().replace(" ", "_"), self.first_obj.perspective_type)}'
 
             # Moon phase section calculations
             if self.first_obj.lunar_phase is not None:
@@ -1673,13 +1993,13 @@ class ChartDrawer:
             template_dict["makeMainHousesGrid"] = draw_main_house_grid(
                 main_subject_houses_list=first_subject_houses_list,
                 text_color=self.chart_colors_settings["paper_0"],
-                house_cusp_generale_name_label=self.language_settings["cusp"],
+                house_cusp_generale_name_label=self._translate("cusp", "Cusp"),
             )
 
             template_dict["makeSecondaryHousesGrid"] = draw_secondary_house_grid(
                 secondary_subject_houses_list=second_subject_houses_list,
                 text_color=self.chart_colors_settings["paper_0"],
-                house_cusp_generale_name_label=self.language_settings["cusp"],
+                house_cusp_generale_name_label=self._translate("cusp", "Cusp"),
             )
 
             template_dict["makeHouses"] = draw_houses_cusps_and_text_number(
@@ -1711,19 +2031,20 @@ class ChartDrawer:
             )
 
             # Planet grid
+            first_name_label = self._truncate_name(self.first_obj.name)
             if self.second_obj is not None and hasattr(self.second_obj, 'return_type') and self.second_obj.return_type == "Solar":
-                first_return_grid_title = f"{self.first_obj.name} ({self.language_settings.get('inner_wheel', 'Inner Wheel')})"
-                second_return_grid_title = f"{self.language_settings.get('solar_return', 'Solar Return')} ({self.language_settings.get('outer_wheel', 'Outer Wheel')})"
+                first_return_grid_title = f"{first_name_label} ({self._translate('inner_wheel', 'Inner Wheel')})"
+                second_return_grid_title = f"{self._translate('solar_return', 'Solar Return')} ({self._translate('outer_wheel', 'Outer Wheel')})"
             else:
-                first_return_grid_title = f"{self.first_obj.name} ({self.language_settings.get('inner_wheel', 'Inner Wheel')})"
-                second_return_grid_title = f'{self.language_settings.get("lunar_return", "Lunar Return")} ({self.language_settings.get("outer_wheel", "Outer Wheel")})'
+                first_return_grid_title = f"{first_name_label} ({self._translate('inner_wheel', 'Inner Wheel')})"
+                second_return_grid_title = f'{self._translate("lunar_return", "Lunar Return")} ({self._translate("outer_wheel", "Outer Wheel")})'
             template_dict["makeMainPlanetGrid"] = draw_main_planet_grid(
                 planets_and_houses_grid_title="",
                 subject_name=first_return_grid_title,
                 available_kerykeion_celestial_points=self.available_kerykeion_celestial_points,
                 chart_type=self.chart_type,
                 text_color=self.chart_colors_settings["paper_0"],
-                celestial_point_language=self.language_settings["celestial_points"],
+                celestial_point_language=self._language_model.celestial_points,
             )
             template_dict["makeSecondaryPlanetGrid"] = draw_secondary_planet_grid(
                 planets_and_houses_grid_title="",
@@ -1731,7 +2052,7 @@ class ChartDrawer:
                 second_subject_available_kerykeion_celestial_points=self.t_available_kerykeion_celestial_points,
                 chart_type=self.chart_type,
                 text_color=self.chart_colors_settings["paper_0"],
-                celestial_point_language=self.language_settings["celestial_points"],
+                celestial_point_language=self._language_model.celestial_points,
             )
 
             house_comparison_factory = HouseComparisonFactory(
@@ -1743,13 +2064,13 @@ class ChartDrawer:
 
             template_dict["makeHouseComparisonGrid"] = draw_house_comparison_grid(
                 house_comparison,
-                celestial_point_language=self.language_settings["celestial_points"],
+                celestial_point_language=self._language_model.celestial_points,
                 active_points=self.active_points,
                 points_owner_subject_number=2, # The second subject is the Solar Return
-                house_position_comparison_label=self.language_settings.get("house_position_comparison", "House Position Comparison"),
-                return_point_label=self.language_settings.get("return_point", "Return Point"),
-                return_label=self.language_settings.get("Return", "DualReturnChart"),
-                radix_label=self.language_settings.get("Natal", "Natal"),
+                house_position_comparison_label=self._translate("house_position_comparison", "House Position Comparison"),
+                return_point_label=self._translate("return_point", "Return Point"),
+                return_label=self._translate("Return", "DualReturnChart"),
+                radix_label=self._translate("Natal", "Natal"),
             )
 
         elif self.chart_type == "SingleReturnChart":
@@ -1800,40 +2121,40 @@ class ChartDrawer:
             template_dict["makeAspects"] = self._draw_all_aspects_lines(self.main_radius, self.main_radius - self.third_circle_radius)
 
             # Top left section
-            latitude_string = convert_latitude_coordinate_to_string(self.geolat, self.language_settings["north"], self.language_settings["south"])
-            longitude_string = convert_longitude_coordinate_to_string(self.geolon, self.language_settings["east"], self.language_settings["west"])
+            latitude_string = convert_latitude_coordinate_to_string(self.geolat, self._translate("north", "North"), self._translate("south", "South"))
+            longitude_string = convert_longitude_coordinate_to_string(self.geolon, self._translate("east", "East"), self._translate("west", "West"))
 
-            template_dict["top_left_0"] = f'{self.language_settings["info"]}:'
+            template_dict["top_left_0"] = f'{self._translate("info", "Info")}:'
             template_dict["top_left_1"] = format_datetime_with_timezone(self.first_obj.iso_formatted_local_datetime) # type: ignore
             template_dict["top_left_2"] = f"{self.first_obj.city}, {self.first_obj.nation}"
-            template_dict["top_left_3"] = f"{self.language_settings['latitude']}: {latitude_string}"
-            template_dict["top_left_4"] = f"{self.language_settings['longitude']}: {longitude_string}"
+            template_dict["top_left_3"] = f"{self._translate('latitude', 'Latitude')}: {latitude_string}"
+            template_dict["top_left_4"] = f"{self._translate('longitude', 'Longitude')}: {longitude_string}"
 
             if hasattr(self.first_obj, 'return_type') and self.first_obj.return_type == "Solar":
-                template_dict["top_left_5"] = f"{self.language_settings['type']}: {self.language_settings.get('solar_return', 'Solar Return')}"
+                template_dict["top_left_5"] = f"{self._translate('type', 'Type')}: {self._translate('solar_return', 'Solar Return')}"
             else:
-                template_dict["top_left_5"] = f"{self.language_settings['type']}: {self.language_settings.get('lunar_return', 'Lunar Return')}"
+                template_dict["top_left_5"] = f"{self._translate('type', 'Type')}: {self._translate('lunar_return', 'Lunar Return')}"
 
             # Bottom left section
             if self.first_obj.zodiac_type == "Tropic":
-                zodiac_info = f"{self.language_settings.get('zodiac', 'Zodiac')}: {self.language_settings.get('tropical', 'Tropical')}"
+                zodiac_info = f"{self._translate('zodiac', 'Zodiac')}: {self._translate('tropical', 'Tropical')}"
             else:
                 mode_const = "SIDM_" + self.first_obj.sidereal_mode # type: ignore
                 mode_name = swe.get_ayanamsa_name(getattr(swe, mode_const))
-                zodiac_info = f"{self.language_settings.get('ayanamsa', 'Ayanamsa')}: {mode_name}"
+                zodiac_info = f"{self._translate('ayanamsa', 'Ayanamsa')}: {mode_name}"
 
             template_dict["bottom_left_0"] = zodiac_info
-            template_dict["bottom_left_1"] = f"{self.language_settings.get('houses_system_' + self.first_obj.houses_system_identifier, self.first_obj.houses_system_name)} {self.language_settings.get('houses', 'Houses')}"
+            template_dict["bottom_left_1"] = f"{self._translate('houses_system_' + self.first_obj.houses_system_identifier, self.first_obj.houses_system_name)} {self._translate('houses', 'Houses')}"
 
             # Lunar phase information (optional)
             if self.first_obj.lunar_phase is not None:
-                template_dict["bottom_left_2"] = f'{self.language_settings.get("lunation_day", "Lunation Day")}: {self.first_obj.lunar_phase.get("moon_phase", "")}'
-                template_dict["bottom_left_3"] = f'{self.language_settings.get("lunar_phase", "Lunar Phase")}: {self.language_settings.get(self.first_obj.lunar_phase.moon_phase_name.lower().replace(" ", "_"), self.first_obj.lunar_phase.moon_phase_name)}'
+                template_dict["bottom_left_2"] = f'{self._translate("lunation_day", "Lunation Day")}: {self.first_obj.lunar_phase.get("moon_phase", "")}'
+                template_dict["bottom_left_3"] = f'{self._translate("lunar_phase", "Lunar Phase")}: {self._translate(self.first_obj.lunar_phase.moon_phase_name.lower().replace(" ", "_"), self.first_obj.lunar_phase.moon_phase_name)}'
             else:
                 template_dict["bottom_left_2"] = ""
                 template_dict["bottom_left_3"] = ""
 
-            template_dict["bottom_left_4"] = f'{self.language_settings.get("perspective_type", "Perspective")}: {self.language_settings.get(self.first_obj.perspective_type.lower().replace(" ", "_"), self.first_obj.perspective_type)}'
+            template_dict["bottom_left_4"] = f'{self._translate("perspective_type", "Perspective")}: {self._translate(self.first_obj.perspective_type.lower().replace(" ", "_"), self.first_obj.perspective_type)}'
 
             # Moon phase section calculations
             if self.first_obj.lunar_phase is not None:
@@ -1845,7 +2166,7 @@ class ChartDrawer:
             template_dict["makeMainHousesGrid"] = draw_main_house_grid(
                 main_subject_houses_list=first_subject_houses_list,
                 text_color=self.chart_colors_settings["paper_0"],
-                house_cusp_generale_name_label=self.language_settings["cusp"],
+                house_cusp_generale_name_label=self._translate("cusp", "Cusp"),
             )
             template_dict["makeSecondaryHousesGrid"] = ""
 
@@ -1875,12 +2196,12 @@ class ChartDrawer:
             )
 
             template_dict["makeMainPlanetGrid"] = draw_main_planet_grid(
-                planets_and_houses_grid_title=self.language_settings["planets_and_house"],
+                planets_and_houses_grid_title=self._translate("planets_and_house", "Points for"),
                 subject_name=self.first_obj.name,
                 available_kerykeion_celestial_points=self.available_kerykeion_celestial_points,
                 chart_type=self.chart_type,
                 text_color=self.chart_colors_settings["paper_0"],
-                celestial_point_language=self.language_settings["celestial_points"],
+                celestial_point_language=self._language_model.celestial_points,
             )
             template_dict["makeSecondaryPlanetGrid"] = ""
             template_dict["makeHouseComparisonGrid"] = ""