kerykeion 4.14.2__py3-none-any.whl → 4.18.0__py3-none-any.whl

kerykeion/charts/kerykeion_chart_svg.py

@@ -5,24 +5,23 @@
 
 
 import logging
+from typing import get_args
 
 from kerykeion.settings.kerykeion_settings import get_settings
 from kerykeion.aspects.synastry_aspects import SynastryAspects
 from kerykeion.aspects.natal_aspects import NatalAspects
 from kerykeion.astrological_subject import AstrologicalSubject
-from kerykeion.kr_types import KerykeionException, ChartType
+from kerykeion.kr_types import KerykeionException, ChartType, KerykeionPointModel, Sign
 from kerykeion.kr_types import ChartTemplateDictionary
-from kerykeion.kr_types.settings_models import KerykeionSettingsCelestialPointModel
+from kerykeion.kr_types.kr_models import AstrologicalSubjectModel
+from kerykeion.kr_types.settings_models import KerykeionSettingsCelestialPointModel, KerykeionSettingsModel
+from kerykeion.kr_types.kr_literals import KerykeionChartTheme
 from kerykeion.charts.charts_utils import (
-    degreeDiff, 
-    sliceToX, 
-    sliceToY, 
     draw_zodiac_slice, 
     convert_latitude_coordinate_to_string, 
     convert_longitude_coordinate_to_string,
     draw_aspect_line,
     draw_elements_percentages,
-    convert_decimal_to_degree_string,
     draw_transit_ring_degree_steps,
     draw_degree_ring,
     draw_transit_ring,
@@ -31,17 +30,21 @@ from kerykeion.charts.charts_utils import (
     draw_third_circle,
     draw_aspect_grid,
     draw_houses_cusps_and_text_number,
-    draw_aspect_transit_grid,
-    draw_moon_phase
+    draw_transit_aspect_list,
+    draw_transit_aspect_grid,
+    draw_moon_phase,
+    draw_house_grid,
+    draw_planet_grid,
 )
+from kerykeion.charts.draw_planets import draw_planets # type: ignore
+from kerykeion.utilities import get_houses_list
 from pathlib import Path
 from scour.scour import scourString
 from string import Template
-from typing import Union, List
+from typing import Union, List, Literal
 from datetime import datetime
 
 
-
 class KerykeionChartSVG:
     """
     Creates the instance that can generate the chart with the
@@ -54,19 +57,26 @@ class KerykeionChartSVG:
         - new_output_directory: Set the output directory (default: home directory).
         - new_settings_file: Set the settings file (default: kr.config.json).
             In the settings file you can set the language, colors, planets, aspects, etc.
+        - theme: Set the theme for the chart (default: classic). If None the <style> tag will be empty.
+            That's useful if you want to use your own CSS file customizing the value of the default theme variables.
+        - double_chart_aspect_grid_type: Set the type of the aspect grid for the double chart (transit or synastry). (Default: list.)
+        - chart_language: Set the language for the chart (default: EN).
     """
     
     # Constants
+    _BASIC_CHART_VIEWBOX = "0 0 772.2 546.0"
+    _WIDE_CHART_VIEWBOX = "0 0 1060 546.0"
     _DEFAULT_HEIGHT = 546.0
     _DEFAULT_FULL_WIDTH = 1200
     _DEFAULT_NATAL_WIDTH = 772.2
+    _PLANET_IN_ZODIAC_EXTRA_POINTS = 10
 
     # Set at init
-    first_obj: AstrologicalSubject
-    second_obj: Union[AstrologicalSubject, None]
+    first_obj: Union[AstrologicalSubject, AstrologicalSubjectModel]
+    second_obj: Union[AstrologicalSubject, AstrologicalSubjectModel, None]
     chart_type: ChartType
     new_output_directory: Union[Path, None]
-    new_settings_file: Union[Path, None]
+    new_settings_file: Union[Path, None, KerykeionSettingsModel, dict]
     output_directory: Path
 
     # Internal properties
@@ -74,57 +84,43 @@ class KerykeionChartSVG:
     earth: float
     air: float
     water: float
-    c1: float
-    c2: float
-    c3: float
-    homedir: Path
-    xml_svg: Path
+    main_radius: float
+    first_circle_radius: float
+    second_circle_radius: float
+    third_circle_radius: float
     width: Union[float, int]
     language_settings: dict
     chart_colors_settings: dict
     planets_settings: dict
     aspects_settings: dict
-    planet_in_zodiac_extra_points: int
-    chart_settings: dict
-    user: AstrologicalSubject
+    user: Union[AstrologicalSubject, AstrologicalSubjectModel]
     available_planets_setting: List[KerykeionSettingsCelestialPointModel]
-    transit_ring_exclude_points_names: List[str]
-    points_deg_ut: list
-    points_deg: list
-    points_sign: list
-    points_retrograde: list
-    houses_sign_graph: list
-    t_points_deg_ut: list
-    t_points_deg: list
-    t_points_sign: list
-    t_points_retrograde: list
-    t_houses_sign_graph: list
     height: float
     location: str
     geolat: float
     geolon: float
-    zodiac: tuple
     template: str
 
     def __init__(
         self,
-        first_obj: AstrologicalSubject,
+        first_obj: Union[AstrologicalSubject, AstrologicalSubjectModel],
         chart_type: ChartType = "Natal",
-        second_obj: Union[AstrologicalSubject, None] = None,
+        second_obj: Union[AstrologicalSubject, AstrologicalSubjectModel, None] = None,
         new_output_directory: Union[str, None] = None,
-        new_settings_file: Union[Path, None] = None,
+        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: str = "EN",
     ):
         # Directories:
-        DATA_DIR = Path(__file__).parent
-        self.homedir = Path.home()
+        home_directory = Path.home()
         self.new_settings_file = new_settings_file
+        self.chart_language = chart_language
 
         if new_output_directory:
             self.output_directory = Path(new_output_directory)
         else:
-            self.output_directory = self.homedir
-
-        self.xml_svg = DATA_DIR / "templates/chart.xml"
+            self.output_directory = home_directory
 
         self.parse_json_settings(new_settings_file)
         self.chart_type = chart_type
@@ -139,58 +135,20 @@ class KerykeionChartSVG:
 
             self.available_planets_setting.append(body)
 
-        # House cusp points are excluded from the transit ring.
-        self.transit_ring_exclude_points_names = [
-            "First_House",
-            "Second_House",
-            "Third_House",
-            "Fourth_House",
-            "Fifth_House",
-            "Sixth_House",
-            "Seventh_House",
-            "Eighth_House",
-            "Ninth_House",
-            "Tenth_House",
-            "Eleventh_House",
-            "Twelfth_House"
-        ]
-
         # Available bodies
-        available_celestial_points = []
+        available_celestial_points_names = []
         for body in self.available_planets_setting:
-            available_celestial_points.append(body["name"].lower())
-        
-        # Make a list for the absolute degrees of the points of the graphic.
-        self.points_deg_ut = []
-        for planet in available_celestial_points:
-            self.points_deg_ut.append(self.user.get(planet).abs_pos)
-
-        # Make a list of the relative degrees of the points in the graphic.
-        self.points_deg = []
-        for planet in available_celestial_points:
-            self.points_deg.append(self.user.get(planet).position)
+            available_celestial_points_names.append(body["name"].lower())
 
-        # Make list of the points sign
-        self.points_sign = []
-        for planet in available_celestial_points:
-            self.points_sign.append(self.user.get(planet).sign_num)
-
-        # Make a list of points if they are retrograde or not.
-        self.points_retrograde = []
-        for planet in available_celestial_points:
-            self.points_retrograde.append(self.user.get(planet).retrograde)
+        self.available_kerykeion_celestial_points: list[KerykeionPointModel] = []
+        for body in available_celestial_points_names:
+            self.available_kerykeion_celestial_points.append(self.user.get(body))
 
         # Makes the sign number list.
-
-        self.houses_sign_graph = []
-        for h in self.user.houses_list:
-            self.houses_sign_graph.append(h["sign_num"])
-
         if self.chart_type == "Natal" or self.chart_type == "ExternalNatal":
             natal_aspects_instance = NatalAspects(self.user, new_settings_file=self.new_settings_file)
             self.aspects_list = natal_aspects_instance.relevant_aspects
 
-        # TODO: If not second should exit
         if self.chart_type == "Transit" or self.chart_type == "Synastry":
             if not second_obj:
                 raise KerykeionException("Second object is required for Transit or Synastry charts.")
@@ -198,29 +156,15 @@ class KerykeionChartSVG:
             # Kerykeion instance
             self.t_user = second_obj
 
-            # Make a list for the absolute degrees of the points of the graphic.
-            self.t_points_deg_ut = []
-            for planet in available_celestial_points:            
-                self.t_points_deg_ut.append(self.t_user.get(planet).abs_pos)
+            # Aspects
+            self.aspects_list = SynastryAspects(self.user, self.t_user, new_settings_file=self.new_settings_file).relevant_aspects
 
-            # Make a list of the relative degrees of the points in the graphic.
-            self.t_points_deg = []
-            for planet in available_celestial_points:
-                self.t_points_deg.append(self.t_user.get(planet).position)
+            self.t_available_kerykeion_celestial_points = []
+            for body in available_celestial_points_names:
+                self.t_available_kerykeion_celestial_points.append(self.t_user.get(body))
 
-            # Make list of the poits sign.
-            self.t_points_sign = []
-            for planet in available_celestial_points:
-                self.t_points_sign.append(self.t_user.get(planet).sign_num)
-
-            # Make a list of poits if they are retrograde or not.
-            self.t_points_retrograde = []
-            for planet in available_celestial_points:
-                self.t_points_retrograde.append(self.t_user.get(planet).retrograde)
-
-            self.t_houses_sign_graph = []
-            for h in self.t_user.houses_list:
-                self.t_houses_sign_graph.append(h["sign_num"])
+        # Double chart aspect grid type
+        self.double_chart_aspect_grid_type = double_chart_aspect_grid_type
 
         # screen size
         self.height = self._DEFAULT_HEIGHT
@@ -234,31 +178,45 @@ class KerykeionChartSVG:
         self.geolat = self.user.lat
         self.geolon =  self.user.lng
         
-        logging.info(f"{self.user.name} birth location: {self.location}, {self.geolat}, {self.geolon}")
-
         if self.chart_type == "Transit":
             self.t_name = self.language_settings["transit_name"]
 
-        # configuration
-        # ZOOM 1 = 100%
-        self.zoom = 1
-
-        self.zodiac = (
-            {"name": "aries", "element": "fire"},
-            {"name": "taurus", "element": "earth"},
-            {"name": "gemini", "element": "air"},
-            {"name": "cancer", "element": "water"},
-            {"name": "leo", "element": "fire"},
-            {"name": "virgo", "element": "earth"},
-            {"name": "libra", "element": "air"},
-            {"name": "scorpio", "element": "water"},
-            {"name": "sagittarius", "element": "fire"},
-            {"name": "capricorn", "element": "earth"},
-            {"name": "aquarius", "element": "air"},
-            {"name": "pisces", "element": "water"},
-        )
+        # Default radius for the chart
+        self.main_radius = 240
+
+        # Set circle radii based on chart type
+        if self.chart_type == "ExternalNatal":
+            self.first_circle_radius, self.second_circle_radius, self.third_circle_radius = 56, 92, 112
+        else:
+            self.first_circle_radius, self.second_circle_radius, self.third_circle_radius = 0, 36, 120
+
+        # Initialize element points
+        self.fire = 0.0
+        self.earth = 0.0
+        self.air = 0.0
+        self.water = 0.0
+
+        # Calculate element points from planets
+        self._calculate_elements_points_from_planets()
+
+        # Set up theme
+        if theme not in get_args(KerykeionChartTheme) and theme is not None:
+            raise KerykeionException(f"Theme {theme} is not available. Set None for default theme.")
 
-        self.template = None
+        self.set_up_theme(theme)
+
+    def set_up_theme(self, theme: Union[KerykeionChartTheme, None] = None) -> None:
+        """
+        Set the theme for the chart.
+        """
+        if theme is None:
+            self.color_style_tag = ""
+            return
+
+        theme_dir = Path(__file__).parent / "themes"
+
+        with open(theme_dir / f"{theme}.css", "r") as f:
+            self.color_style_tag = f.read()
 
     def set_output_directory(self, dir_path: Path) -> None:
         """
@@ -267,19 +225,16 @@ class KerykeionChartSVG:
         self.output_directory = dir_path
         logging.info(f"Output direcotry set to: {self.output_directory}")
 
-    def parse_json_settings(self, settings_file):
+    def parse_json_settings(self, settings_file_or_dict: Union[Path, dict, KerykeionSettingsModel, None]) -> None:
         """
         Parse the settings file.
         """
-        settings = get_settings(settings_file)
+        settings = get_settings(settings_file_or_dict)
 
-        language = settings["general_settings"]["language"]
-        self.language_settings = settings["language_settings"].get(language, "EN")
+        self.language_settings = settings["language_settings"][self.chart_language]
         self.chart_colors_settings = settings["chart_colors"]
         self.planets_settings = settings["celestial_points"]
         self.aspects_settings = settings["aspects"]
-        self.planet_in_zodiac_extra_points = settings["general_settings"]["planet_in_zodiac_extra_points"]
-        self.chart_settings = settings["chart_settings"]
 
     def _draw_zodiac_circle_slices(self, r):
         """
@@ -292,17 +247,17 @@ class KerykeionChartSVG:
         Returns:
             str: The SVG string representing the zodiac circle.
         """
-
+        sings = get_args(Sign)
         output = ""
-        for i, zodiac_element in enumerate(self.zodiac):
+        for i, sing in enumerate(sings):
             output += draw_zodiac_slice(
-                c1=self.c1,
+                c1=self.first_circle_radius,
                 chart_type=self.chart_type,
-                seventh_house_degree_ut=self.user.houses_degree_ut[6],
+                seventh_house_degree_ut=self.user.seventh_house.abs_pos,
                 num=i,
                 r=r,
                 style=f'fill:{self.chart_colors_settings[f"zodiac_bg_{i}"]}; fill-opacity: 0.5;',
-                type=zodiac_element["name"],
+                type=sing,
             )
 
         return output
@@ -310,19 +265,47 @@ class KerykeionChartSVG:
     def _calculate_elements_points_from_planets(self):
         """
         Calculate chart element points from a planet.
+        TODO: Refactor this method.
+        Should be completely rewritten. Maybe even part of the AstrologicalSubject class.
+        The points should include just the standard way of calculating the elements points.
         """
+
+        ZODIAC = (
+            {"name": "Ari", "element": "fire"},
+            {"name": "Tau", "element": "earth"},
+            {"name": "Gem", "element": "air"},
+            {"name": "Can", "element": "water"},
+            {"name": "Leo", "element": "fire"},
+            {"name": "Vir", "element": "earth"},
+            {"name": "Lib", "element": "air"},
+            {"name": "Sco", "element": "water"},
+            {"name": "Sag", "element": "fire"},
+            {"name": "Cap", "element": "earth"},
+            {"name": "Aqu", "element": "air"},
+            {"name": "Pis", "element": "water"},
+        )
         
+        # Available bodies
+        available_celestial_points_names = []
+        for body in self.available_planets_setting:
+            available_celestial_points_names.append(body["name"].lower())
+
+        # Make list of the points sign
+        points_sign = []
+        for planet in available_celestial_points_names:
+            points_sign.append(self.user.get(planet).sign_num)
+
         for i in range(len(self.available_planets_setting)):
             # element: get extra points if planet is in own zodiac sign.
             related_zodiac_signs = self.available_planets_setting[i]["related_zodiac_signs"]
-            cz = self.points_sign[i]
+            cz = points_sign[i]
             extra_points = 0
             if related_zodiac_signs != []:
                 for e in range(len(related_zodiac_signs)):
                     if int(related_zodiac_signs[e]) == int(cz):
-                        extra_points = self.planet_in_zodiac_extra_points
+                        extra_points = self._PLANET_IN_ZODIAC_EXTRA_POINTS
 
-            ele = self.zodiac[self.points_sign[i]]["element"]
+            ele = ZODIAC[points_sign[i]]["element"]
             if ele == "fire":
                 self.fire = self.fire + self.available_planets_setting[i]["element_points"] + extra_points
 
@@ -335,344 +318,6 @@ class KerykeionChartSVG:
             elif ele == "water":
                 self.water = self.water + self.available_planets_setting[i]["element_points"] + extra_points
 
-    def _make_planets(self, r):
-        planets_degut = {}
-        diff = range(len(self.available_planets_setting))
-
-        for i in range(len(self.available_planets_setting)):
-            # list of planets sorted by degree
-            logging.debug(f"planet: {i}, degree: {self.points_deg_ut[i]}")
-            planets_degut[self.points_deg_ut[i]] = i
-
-        """
-        FIXME: The planets_degut is a dictionary like:
-        {planet_degree: planet_index}
-        It should be replaced bu points_deg_ut
-        print(self.points_deg_ut)
-        print(planets_degut)
-        """
-
-        output = ""
-        keys = list(planets_degut.keys())
-        keys.sort()
-        switch = 0
-
-        planets_degrouped = {}
-        groups = []
-        planets_by_pos = list(range(len(planets_degut)))
-        planet_drange = 3.4
-        # get groups closely together
-        group_open = False
-        for e in range(len(keys)):
-            i = planets_degut[keys[e]]
-            # get distances between planets
-            if e == 0:
-                prev = self.points_deg_ut[planets_degut[keys[-1]]]
-                next = self.points_deg_ut[planets_degut[keys[1]]]
-            elif e == (len(keys) - 1):
-                prev = self.points_deg_ut[planets_degut[keys[e - 1]]]
-                next = self.points_deg_ut[planets_degut[keys[0]]]
-            else:
-                prev = self.points_deg_ut[planets_degut[keys[e - 1]]]
-                next = self.points_deg_ut[planets_degut[keys[e + 1]]]
-            diffa = degreeDiff(prev, self.points_deg_ut[i])
-            diffb = degreeDiff(next, self.points_deg_ut[i])
-            planets_by_pos[e] = [i, diffa, diffb]
-
-            logging.debug(f'{self.available_planets_setting[i]["label"]}, {diffa}, {diffb}')
-
-            if diffb < planet_drange:
-                if group_open:
-                    groups[-1].append([e, diffa, diffb, self.available_planets_setting[planets_degut[keys[e]]]["label"]])
-                else:
-                    group_open = True
-                    groups.append([])
-                    groups[-1].append([e, diffa, diffb, self.available_planets_setting[planets_degut[keys[e]]]["label"]])
-            else:
-                if group_open:
-                    groups[-1].append([e, diffa, diffb, self.available_planets_setting[planets_degut[keys[e]]]["label"]])
-                group_open = False
-
-        def zero(x):
-            return 0
-
-        planets_delta = list(map(zero, range(len(self.available_planets_setting))))
-
-        # print groups
-        # print planets_by_pos
-        for a in range(len(groups)):
-            # Two grouped planets
-            if len(groups[a]) == 2:
-                next_to_a = groups[a][0][0] - 1
-                if groups[a][1][0] == (len(planets_by_pos) - 1):
-                    next_to_b = 0
-                else:
-                    next_to_b = groups[a][1][0] + 1
-                # if both planets have room
-                if (groups[a][0][1] > (2 * planet_drange)) & (groups[a][1][2] > (2 * planet_drange)):
-                    planets_delta[groups[a][0][0]] = -(planet_drange - groups[a][0][2]) / 2
-                    planets_delta[groups[a][1][0]] = +(planet_drange - groups[a][0][2]) / 2
-                # if planet a has room
-                elif groups[a][0][1] > (2 * planet_drange):
-                    planets_delta[groups[a][0][0]] = -planet_drange
-                # if planet b has room
-                elif groups[a][1][2] > (2 * planet_drange):
-                    planets_delta[groups[a][1][0]] = +planet_drange
-
-                # if planets next to a and b have room move them
-                elif (planets_by_pos[next_to_a][1] > (2.4 * planet_drange)) & (planets_by_pos[next_to_b][2] > (2.4 * planet_drange)):
-                    planets_delta[(next_to_a)] = groups[a][0][1] - planet_drange * 2
-                    planets_delta[groups[a][0][0]] = -planet_drange * 0.5
-                    planets_delta[next_to_b] = -(groups[a][1][2] - planet_drange * 2)
-                    planets_delta[groups[a][1][0]] = +planet_drange * 0.5
-
-                # if planet next to a has room move them
-                elif planets_by_pos[next_to_a][1] > (2 * planet_drange):
-                    planets_delta[(next_to_a)] = groups[a][0][1] - planet_drange * 2.5
-                    planets_delta[groups[a][0][0]] = -planet_drange * 1.2
-
-                # if planet next to b has room move them
-                elif planets_by_pos[next_to_b][2] > (2 * planet_drange):
-                    planets_delta[next_to_b] = -(groups[a][1][2] - planet_drange * 2.5)
-                    planets_delta[groups[a][1][0]] = +planet_drange * 1.2
-
-            # Three grouped planets or more
-            xl = len(groups[a])
-            if xl >= 3:
-                available = groups[a][0][1]
-                for f in range(xl):
-                    available += groups[a][f][2]
-                need = (3 * planet_drange) + (1.2 * (xl - 1) * planet_drange)
-                leftover = available - need
-                xa = groups[a][0][1]
-                xb = groups[a][(xl - 1)][2]
-
-                # center
-                if (xa > (need * 0.5)) & (xb > (need * 0.5)):
-                    startA = xa - (need * 0.5)
-                # position relative to next planets
-                else:
-                    startA = (leftover / (xa + xb)) * xa
-                    startB = (leftover / (xa + xb)) * xb
-
-                if available > need:
-                    planets_delta[groups[a][0][0]] = startA - groups[a][0][1] + (1.5 * planet_drange)
-                    for f in range(xl - 1):
-                        planets_delta[groups[a][(f + 1)][0]] = 1.2 * planet_drange + planets_delta[groups[a][f][0]] - groups[a][f][2]
-
-        for e in range(len(keys)):
-            i = planets_degut[keys[e]]
-
-            # coordinates
-            if self.chart_type == "Transit" or self.chart_type == "Synastry":
-                if 22 < i < 27:
-                    rplanet = 76
-                elif switch == 1:
-                    rplanet = 110
-                    switch = 0
-                else:
-                    rplanet = 130
-                    switch = 1
-            else:
-                # if 22 < i < 27 it is asc,mc,dsc,ic (angles of chart)
-                # put on special line (rplanet is range from outer ring)
-                amin, bmin, cmin = 0, 0, 0
-                if self.chart_type == "ExternalNatal":
-                    amin = 74 - 10
-                    bmin = 94 - 10
-                    cmin = 40 - 10
-
-                if 22 < i < 27:
-                    rplanet = 40 - cmin
-                elif switch == 1:
-                    rplanet = 74 - amin
-                    switch = 0
-                else:
-                    rplanet = 94 - bmin
-                    switch = 1
-
-            rtext = 45
-
-            offset = (int(self.user.houses_degree_ut[6]) / -1) + int(self.points_deg_ut[i] + planets_delta[e])
-            trueoffset = (int(self.user.houses_degree_ut[6]) / -1) + int(self.points_deg_ut[i])
-
-            planet_x = sliceToX(0, (r - rplanet), offset) + rplanet
-            planet_y = sliceToY(0, (r - rplanet), offset) + rplanet
-            if self.chart_type == "Transit" or self.chart_type == "Synastry":
-                scale = 0.8
-                
-            elif self.chart_type == "ExternalNatal":
-                scale = 0.8
-                # line1
-                x1 = sliceToX(0, (r - self.c3), trueoffset) + self.c3
-                y1 = sliceToY(0, (r - self.c3), trueoffset) + self.c3
-                x2 = sliceToX(0, (r - rplanet - 30), trueoffset) + rplanet + 30
-                y2 = sliceToY(0, (r - rplanet - 30), trueoffset) + rplanet + 30
-                color = self.available_planets_setting[i]["color"]
-                output += (
-                    '<line x1="%s" y1="%s" x2="%s" y2="%s" style="stroke-width:1px;stroke:%s;stroke-opacity:.3;"/>\n'
-                    % (x1, y1, x2, y2, color)
-                )
-                # line2
-                x1 = sliceToX(0, (r - rplanet - 30), trueoffset) + rplanet + 30
-                y1 = sliceToY(0, (r - rplanet - 30), trueoffset) + rplanet + 30
-                x2 = sliceToX(0, (r - rplanet - 10), offset) + rplanet + 10
-                y2 = sliceToY(0, (r - rplanet - 10), offset) + rplanet + 10
-                output += (
-                    '<line x1="%s" y1="%s" x2="%s" y2="%s" style="stroke-width:1px;stroke:%s;stroke-opacity:.5;"/>\n'
-                    % (x1, y1, x2, y2, color)
-                )
-                
-            else:
-                scale = 1
-
-            planet_details = self.user[self.available_planets_setting[i]["name"].lower()]
-
-            output += f'<g kr:node="ChartPoint" kr:house="{planet_details['house']}" kr:sign="{planet_details['sign']}" kr:slug="{planet_details['name']}" transform="translate(-{12 * scale},-{12 * scale}) scale({scale})">'
-            output += f'<use x="{planet_x * (1/scale)}" y="{planet_y * (1/scale)}" xlink:href="#{self.available_planets_setting[i]["name"]}" />'
-            output += f'</g>'
-
-        # make transit degut and display planets
-        if self.chart_type == "Transit" or self.chart_type == "Synastry":
-            group_offset = {}
-            t_planets_degut = {}
-            list_range = len(self.available_planets_setting)
-
-            for i in range(list_range):
-                if self.chart_type == "Transit" and self.available_planets_setting[i]['name'] in self.transit_ring_exclude_points_names:
-                    continue
-                
-                group_offset[i] = 0
-                t_planets_degut[self.t_points_deg_ut[i]] = i
-        
-            t_keys = list(t_planets_degut.keys())
-            t_keys.sort()
-
-            # grab closely grouped planets
-            groups = []
-            in_group = False
-            for e in range(len(t_keys)):
-                i_a = t_planets_degut[t_keys[e]]
-                if e == (len(t_keys) - 1):
-                    i_b = t_planets_degut[t_keys[0]]
-                else:
-                    i_b = t_planets_degut[t_keys[e + 1]]
-
-                a = self.t_points_deg_ut[i_a]
-                b = self.t_points_deg_ut[i_b]
-                diff = degreeDiff(a, b)
-                if diff <= 2.5:
-                    if in_group:
-                        groups[-1].append(i_b)
-                    else:
-                        groups.append([i_a])
-                        groups[-1].append(i_b)
-                        in_group = True
-                else:
-                    in_group = False
-            # loop groups and set degrees display adjustment
-            for i in range(len(groups)):
-                if len(groups[i]) == 2:
-                    group_offset[groups[i][0]] = -1.0
-                    group_offset[groups[i][1]] = 1.0
-                elif len(groups[i]) == 3:
-                    group_offset[groups[i][0]] = -1.5
-                    group_offset[groups[i][1]] = 0
-                    group_offset[groups[i][2]] = 1.5
-                elif len(groups[i]) == 4:
-                    group_offset[groups[i][0]] = -2.0
-                    group_offset[groups[i][1]] = -1.0
-                    group_offset[groups[i][2]] = 1.0
-                    group_offset[groups[i][3]] = 2.0
-
-            switch = 0
-            
-            # Transit planets loop
-            for e in range(len(t_keys)):
-                if self.chart_type == "Transit" and self.available_planets_setting[e]["name"] in self.transit_ring_exclude_points_names:
-                    continue
-
-                i = t_planets_degut[t_keys[e]]
-
-                if 22 < i < 27:
-                    rplanet = 9
-                elif switch == 1:
-                    rplanet = 18
-                    switch = 0
-                else:
-                    rplanet = 26
-                    switch = 1
-
-                # Transit planet name
-                zeropoint = 360 - self.user.houses_degree_ut[6]
-                t_offset = zeropoint + self.t_points_deg_ut[i]
-                if t_offset > 360:
-                    t_offset = t_offset - 360
-                planet_x = sliceToX(0, (r - rplanet), t_offset) + rplanet
-                planet_y = sliceToY(0, (r - rplanet), t_offset) + rplanet
-                output += f'<g class="transit-planet-name" transform="translate(-6,-6)"><g transform="scale(0.5)"><use x="{planet_x*2}" y="{planet_y*2}" xlink:href="#{self.available_planets_setting[i]["name"]}" /></g></g>'
-
-                # Transit planet line
-                x1 = sliceToX(0, r + 3, t_offset) - 3
-                y1 = sliceToY(0, r + 3, t_offset) - 3
-                x2 = sliceToX(0, r - 3, t_offset) + 3
-                y2 = sliceToY(0, r - 3, t_offset) + 3
-                output += f'<line class="transit-planet-line" x1="{str(x1)}" y1="{str(y1)}" x2="{str(x2)}" y2="{str(y2)}" style="stroke: {self.available_planets_setting[i]["color"]}; stroke-width: 1px; stroke-opacity:.8;"/>'
-
-                # transit planet degree text
-                rotate = self.user.houses_degree_ut[0] - self.t_points_deg_ut[i]
-                textanchor = "end"
-                t_offset += group_offset[i]
-                rtext = -3.0
-
-                if -90 > rotate > -270:
-                    rotate = rotate + 180.0
-                    textanchor = "start"
-                if 270 > rotate > 90:
-                    rotate = rotate - 180.0
-                    textanchor = "start"
-
-                if textanchor == "end":
-                    xo = 1
-                else:
-                    xo = -1
-                deg_x = sliceToX(0, (r - rtext), t_offset + xo) + rtext
-                deg_y = sliceToY(0, (r - rtext), t_offset + xo) + rtext
-                degree = int(t_offset)
-                output += f'<g transform="translate({deg_x},{deg_y})">'
-                output += f'<text transform="rotate({rotate})" text-anchor="{textanchor}'
-                output += f'" style="fill: {self.available_planets_setting[i]["color"]}; font-size: 10px;">{convert_decimal_to_degree_string(self.t_points_deg[i], type="1")}'
-                output += "</text></g>"
-
-            # check transit
-            if self.chart_type == "Transit" or self.chart_type == "Synastry":
-                dropin = 36
-            else:
-                dropin = 0
-
-            # planet line
-            x1 = sliceToX(0, r - (dropin + 3), offset) + (dropin + 3)
-            y1 = sliceToY(0, r - (dropin + 3), offset) + (dropin + 3)
-            x2 = sliceToX(0, (r - (dropin - 3)), offset) + (dropin - 3)
-            y2 = sliceToY(0, (r - (dropin - 3)), offset) + (dropin - 3)
-
-            output += f'<line x1="{x1}" y1="{y1}" x2="{x2}" y2="{y2}" style="stroke: {self.available_planets_setting[i]["color"]}; stroke-width: 2px; stroke-opacity:.6;"/>'
-
-            # check transit
-            if self.chart_type == "Transit" or self.chart_type == "Synastry":
-                dropin = 160
-            else:
-                dropin = 120
-
-            x1 = sliceToX(0, r - dropin, offset) + dropin
-            y1 = sliceToY(0, r - dropin, offset) + dropin
-            x2 = sliceToX(0, (r - (dropin - 3)), offset) + (dropin - 3)
-            y2 = sliceToY(0, (r - (dropin - 3)), offset) + (dropin - 3)
-            output += f'<line x1="{x1}" y1="{y1}" x2="{x2}" y2="{y2}" style="stroke: {self.available_planets_setting[i]["color"]}; stroke-width: 2px; stroke-opacity:.6;"/>'
-
-        return output
-
-    # Aspect and aspect grid functions for natal type charts.
     def _draw_all_aspects_lines(self, r, ar):
         out = ""
         for aspect in self.aspects_list:
@@ -686,12 +331,8 @@ class KerykeionChartSVG:
 
         return out
 
-    # Aspect and aspect grid functions for transit type charts
     def _draw_all_transit_aspects_lines(self, r, ar):
         out = ""
-
-        self.aspects_list = SynastryAspects(self.user, self.t_user, new_settings_file=self.new_settings_file).relevant_aspects
-
         for aspect in self.aspects_list:
             out += draw_aspect_line(
                 r=r,
@@ -700,335 +341,200 @@ class KerykeionChartSVG:
                 color=self.aspects_settings[aspect["aid"]]["color"],
                 seventh_house_degree_ut=self.user.seventh_house.abs_pos
             )
-
-        return out
-
-    def _makePlanetGrid(self):
-        li = 10
-        offset = 0
-
-        out = '<g transform="translate(510,-20)">'
-        out += '<g transform="translate(140, -15)">'
-        out += f'<text text-anchor="end" style="fill:{self.chart_colors_settings["paper_0"]}; font-size: 14px;">{self.language_settings["planets_and_house"]} {self.user.name}:</text>'
-        out += "</g>"
-
-        end_of_line = None
-        for i in range(len(self.available_planets_setting)):
-            offset_between_lines = 14
-            end_of_line = "</g>"
-
-            # Guarda qui !!
-            if i == 27:
-                li = 10
-                offset = -120
-
-            # start of line
-            out += f'<g transform="translate({offset},{li})">'
-
-            # planet text
-            out += f'<text text-anchor="end" style="fill:{self.chart_colors_settings["paper_0"]}; font-size: 10px;">{self.language_settings["celestial_points"][self.available_planets_setting[i]["label"]]}</text>'
-
-            # planet symbol
-            out += f'<g transform="translate(5,-8)"><use transform="scale(0.4)" xlink:href="#{self.available_planets_setting[i]["name"]}" /></g>'
-
-            # planet degree
-            out += f'<text text-anchor="start" x="19" style="fill:{self.chart_colors_settings["paper_0"]}; font-size: 10px;">{convert_decimal_to_degree_string(self.points_deg[i])}</text>'
-
-            # zodiac
-            out += f'<g transform="translate(60,-8)"><use transform="scale(0.3)" xlink:href="#{self.zodiac[self.points_sign[i]]["name"]}" /></g>'
-
-            # planet retrograde
-            if self.points_retrograde[i]:
-                out += '<g transform="translate(74,-6)"><use transform="scale(.5)" xlink:href="#retrograde" /></g>'
-
-            # end of line
-            out += end_of_line
-
-            li = li + offset_between_lines
-
-        if self.chart_type == "Transit" or self.chart_type == "Synastry":
-            if self.chart_type == "Transit":
-                out += '<g transform="translate(320, -15)">'
-                out += f'<text text-anchor="end" style="fill:{self.chart_colors_settings["paper_0"]}; font-size: 14px;">{self.t_name}:</text>'
-            else:
-                out += '<g transform="translate(380, -15)">'
-                out += f'<text text-anchor="end" style="fill:{self.chart_colors_settings["paper_0"]}; font-size: 14px;">{self.language_settings["planets_and_house"]} {self.t_user.name}:</text>'
-
-            out += end_of_line
-
-            t_li = 10
-            t_offset = 250
-
-            for i in range(len(self.available_planets_setting)):
-                if i == 27:
-                    t_li = 10
-                    t_offset = -120
-
-                # start of line
-                out += f'<g transform="translate({t_offset},{t_li})">'
-
-                # planet text
-                out += f'<text text-anchor="end" style="fill:{self.chart_colors_settings["paper_0"]}; font-size: 10px;">{self.language_settings["celestial_points"][self.available_planets_setting[i]["label"]]}</text>'
-                # planet symbol
-                out += f'<g transform="translate(5,-8)"><use transform="scale(0.4)" xlink:href="#{self.available_planets_setting[i]["name"]}" /></g>'
-                # planet degree
-                out += f'<text text-anchor="start" x="19" style="fill:{self.chart_colors_settings["paper_0"]}; font-size: 10px;">{convert_decimal_to_degree_string(self.t_points_deg[i])}</text>'
-                # zodiac
-                out += f'<g transform="translate(60,-8)"><use transform="scale(0.3)" xlink:href="#{self.zodiac[self.t_points_sign[i]]["name"]}" /></g>'
-
-                # planet retrograde
-                if self.t_points_retrograde[i]:
-                    out += '<g transform="translate(74,-6)"><use transform="scale(.5)" xlink:href="#retrograde" /></g>'
-
-                # end of line
-                out += end_of_line
-
-                t_li = t_li + offset_between_lines
-
-        if end_of_line is None:
-            raise KerykeionException("End of line not found")
-
-        out += end_of_line
         return out
 
-    def _makeHouseGrid(self):
+    def _create_template_dictionary(self) -> ChartTemplateDictionary:
         """
-        Generate SVG code for a grid of astrological houses.
+        Create a dictionary containing the template data for generating an astrological chart.
 
         Returns:
-            str: The SVG code for the grid of houses.
+            ChartTemplateDictionary: A dictionary with template data for the chart.
         """
-        out = '<g transform="translate(610,-20)">'
+        # Initialize template dictionary
+        template_dict: ChartTemplateDictionary = dict()  # type: ignore
 
-        li = 10
-        for i in range(12):
-            if i < 9:
-                cusp = "&#160;&#160;" + str(i + 1)
-            else:
-                cusp = str(i + 1)
-            out += f'<g transform="translate(0,{li})">'
-            out += f'<text text-anchor="end" x="40" style="fill:{self.chart_colors_settings["paper_0"]}; font-size: 10px;">{self.language_settings["cusp"]} {cusp}:</text>'
-            out += f'<g transform="translate(40,-8)"><use transform="scale(0.3)" xlink:href="#{self.zodiac[self.houses_sign_graph[i]]["name"]}" /></g>'
-            out += f'<text x="53" style="fill:{self.chart_colors_settings["paper_0"]}; font-size: 10px;"> {convert_decimal_to_degree_string(self.user.houses_list[i]["position"])}</text>'
-            out += "</g>"
-            li = li + 14
+        # Set the color style tag
+        template_dict["color_style_tag"] = self.color_style_tag
 
-        out += "</g>"
+        # Set chart dimensions
+        template_dict["chart_height"] = self.height
+        template_dict["chart_width"] = self.width
 
-        if self.chart_type == "Synastry":
-            out += '<!-- Synastry Houses -->'
-            out += '<g transform="translate(850, -20)">'
-            li = 10
-
-            for i in range(12):
-                if i < 9:
-                    cusp = "&#160;&#160;" + str(i + 1)
-                else:
-                    cusp = str(i + 1)
-                out += '<g transform="translate(0,' + str(li) + ')">'
-                out += f'<text text-anchor="end" x="40" style="fill:{self.chart_colors_settings["paper_0"]}; font-size: 10px;">{self.language_settings["cusp"]} {cusp}:</text>'
-                out += f'<g transform="translate(40,-8)"><use transform="scale(0.3)" xlink:href="#{self.zodiac[self.t_houses_sign_graph[i]]["name"]}" /></g>'
-                out += f'<text x="53" style="fill:{self.chart_colors_settings["paper_0"]}; font-size: 10px;"> {convert_decimal_to_degree_string(self.t_user.houses_list[i]["position"])}</text>'
-                out += "</g>"
-                li = li + 14
-            out += "</g>"
+        # Set chart name
+        template_dict["stringName"] = f"{self.user.name}:" if self.chart_type in ["Synastry", "Transit"] else f'{self.language_settings["info"]}:'
 
-        return out
+        # Set viewbox based on chart type
+        template_dict['viewbox'] = self._BASIC_CHART_VIEWBOX if self.chart_type in ["Natal", "ExternalNatal"] else self._WIDE_CHART_VIEWBOX
 
-    def _createTemplateDictionary(self) -> ChartTemplateDictionary:
-        # self.chart_type = "Transit"
-        # empty element points
-        self.fire = 0.0
-        self.earth = 0.0
-        self.air = 0.0
-        self.water = 0.0
-
-        # Calculate the elements points
-        self._calculate_elements_points_from_planets()
-
-        rotate = "0"
-
-        # template dictionary
-        td: ChartTemplateDictionary = dict() # type: ignore
-        r = 240
-
-        # To increase the size of the chart, change the viewbox
-        if self.chart_type == "Natal" or self.chart_type == "ExternalNatal":
-            td['viewbox'] = self.chart_settings["basic_chart_viewBox"]
-        else:
-            td['viewbox'] = self.chart_settings["wide_chart_viewBox"]
-
-        if self.chart_type == "ExternalNatal":
-            self.c1 = 56
-            self.c2 = 92
-            self.c3 = 112
-        else:
-            self.c1 = 0
-            self.c2 = 36
-            self.c3 = 120
+        # Generate rings and circles based on chart type
+        if self.chart_type in ["Transit", "Synastry"]:
+            template_dict["transitRing"] = draw_transit_ring(self.main_radius, self.chart_colors_settings["paper_1"], self.chart_colors_settings["zodiac_transit_ring_3"])
+            template_dict["degreeRing"] = draw_transit_ring_degree_steps(self.main_radius, self.user.seventh_house.abs_pos)
+            template_dict["first_circle"] = draw_first_circle(self.main_radius, self.chart_colors_settings["zodiac_transit_ring_2"], self.chart_type)
+            template_dict["second_circle"] = draw_second_circle(self.main_radius, self.chart_colors_settings['zodiac_transit_ring_1'], self.chart_colors_settings['paper_1'], self.chart_type)
+            template_dict['third_circle'] = draw_third_circle(self.main_radius, self.chart_colors_settings['zodiac_transit_ring_0'], self.chart_colors_settings['paper_1'], self.chart_type, self.third_circle_radius)
 
-        # transit
-        if self.chart_type == "Transit" or self.chart_type == "Synastry":
-            td["transitRing"] = draw_transit_ring(r, self.chart_colors_settings["paper_1"], self.chart_colors_settings["zodiac_transit_ring_3"])
-            td["degreeRing"] = draw_transit_ring_degree_steps(r, self.user.seventh_house.abs_pos)
-
-            # circles
-            td["first_circle"] = draw_first_circle(r, self.chart_colors_settings["zodiac_transit_ring_2"], self.chart_type)
-            td["second_circle"] = draw_second_circle(r, self.chart_colors_settings['zodiac_transit_ring_1'], self.chart_colors_settings['paper_1'], self.chart_type)
-            td['third_circle'] = draw_third_circle(r, self.chart_colors_settings['zodiac_transit_ring_0'], self.chart_colors_settings['paper_1'], self.chart_type)
-
-            td["makeAspects"] = self._draw_all_transit_aspects_lines(r, (r - 160))
-
-            td["makeAspectGrid"] = draw_aspect_transit_grid(
-                self.language_settings["aspects"],
-                self.aspects_list,
-                self.planets_settings,
-                self.aspects_settings
-            )
+            if self.double_chart_aspect_grid_type == "list":
+                template_dict["makeAspectGrid"] = draw_transit_aspect_list(self.language_settings["aspects"], self.aspects_list, self.planets_settings, self.aspects_settings)
+            else:
+                template_dict["makeAspectGrid"] = draw_transit_aspect_grid(self.chart_colors_settings['paper_0'], self.available_planets_setting, self.aspects_list, 550, 450)
 
-        # Natal, External Natal
+            template_dict["makeAspects"] = self._draw_all_transit_aspects_lines(self.main_radius, self.main_radius - 160)
         else:
-            td["transitRing"] = ""
-            td["degreeRing"] = draw_degree_ring(r, self.c1, self.user.seventh_house.abs_pos, self.chart_colors_settings["paper_0"])
+            template_dict["transitRing"] = ""
+            template_dict["degreeRing"] = draw_degree_ring(self.main_radius, self.first_circle_radius, self.user.seventh_house.abs_pos, self.chart_colors_settings["paper_0"])
+            template_dict['first_circle'] = draw_first_circle(self.main_radius, self.chart_colors_settings["zodiac_radix_ring_2"], self.chart_type, self.first_circle_radius)
+            template_dict["second_circle"] = draw_second_circle(self.main_radius, self.chart_colors_settings["zodiac_radix_ring_1"], self.chart_colors_settings["paper_1"], self.chart_type, self.second_circle_radius)
+            template_dict['third_circle'] = draw_third_circle(self.main_radius, self.chart_colors_settings["zodiac_radix_ring_0"], self.chart_colors_settings["paper_1"], self.chart_type, self.third_circle_radius)
+            template_dict["makeAspectGrid"] = draw_aspect_grid(self.chart_colors_settings['paper_0'], self.available_planets_setting, self.aspects_list)
 
-            td['first_circle'] = draw_first_circle(r, self.chart_colors_settings["zodiac_radix_ring_2"], self.chart_type, self.c1)
-            td["second_circle"] = draw_second_circle(r, self.chart_colors_settings["zodiac_radix_ring_1"], self.chart_colors_settings["paper_1"], self.chart_type, self.c2)
-            td['third_circle'] = draw_third_circle(r,  self.chart_colors_settings["zodiac_radix_ring_0"], self.chart_colors_settings["paper_1"], self.chart_type, self.c3)
-            
-            td["makeAspects"] = self._draw_all_aspects_lines(r, (r - self.c3))
-            td["makeAspectGrid"] = draw_aspect_grid(self.chart_colors_settings['paper_0'], self.available_planets_setting, self.aspects_list)
-
-        td["chart_height"] = self.height
-        td["chart_width"] = self.width
+            template_dict["makeAspects"] = self._draw_all_aspects_lines(self.main_radius, self.main_radius - self.third_circle_radius)
 
-        # Chart Title
+        # Set chart title
         if self.chart_type == "Synastry":
-            td["stringTitle"] = f"{self.user.name} {self.language_settings['and_word']} {self.t_user.name}"
-
+            template_dict["stringTitle"] = f"{self.user.name} {self.language_settings['and_word']} {self.t_user.name}"
         elif self.chart_type == "Transit":
-            td["stringTitle"] = f"{self.language_settings['transits']} {self.t_user.day}/{self.t_user.month}/{self.t_user.year}"
-
+            template_dict["stringTitle"] = f"{self.language_settings['transits']} {self.t_user.day}/{self.t_user.month}/{self.t_user.year}"
         else:
-            td["stringTitle"] = self.user.name
-
-        # Chart Name
-        if self.chart_type == "Synastry" or self.chart_type == "Transit":
-            td["stringName"] = f"{self.user.name}:"
+            template_dict["stringTitle"] = self.user.name
+
+        # Set bottom left corner information
+        template_dict["bottomLeft0"] = f"{self.user.zodiac_type if self.user.zodiac_type == 'Tropic' else str(self.user.zodiac_type) + ' ' + str(self.user.sidereal_mode)}"
+        template_dict["bottomLeft1"] = f"{self.user.houses_system_name}"
+        if self.chart_type in ["Natal", "ExternalNatal", "Synastry"]:
+            template_dict["bottomLeft2"] = f'{self.language_settings.get("lunar_phase", "Lunar Phase")}: {self.language_settings.get("day", "Day")} {self.user.lunar_phase.get("moon_phase", "")}'
+            template_dict["bottomLeft3"] = f'{self.language_settings.get("lunar_phase", "Lunar Phase")}: {self.user.lunar_phase.moon_phase_name}'
+            template_dict["bottomLeft4"] = f'{self.user.perspective_type}'
         else:
-            td["stringName"] = f'{self.language_settings["info"]}:'
+            template_dict["bottomLeft2"] = f'{self.language_settings.get("lunar_phase", "Lunar Phase")}: {self.language_settings.get("day", "Day")} {self.t_user.lunar_phase.get("moon_phase", "")}'
+            template_dict["bottomLeft3"] = f'{self.language_settings.get("lunar_phase", "Lunar Phase")}: {self.t_user.lunar_phase.moon_phase_name}'
+            template_dict["bottomLeft4"] = f'{self.t_user.perspective_type}'
 
-        # Bottom Left Corner
-        if self.chart_type == "Natal" or self.chart_type == "ExternalNatal" or self.chart_type == "Synastry":
-            td["bottomLeft0"] = f"{self.user.zodiac_type if self.user.zodiac_type == 'Tropic' else self.user.zodiac_type + ' ' + self.user.sidereal_mode}"
-            td["bottomLeft1"] = f"{self.user.houses_system_name}"
-            td["bottomLeft2"] = f'{self.language_settings.get("lunar_phase", "Lunar Phase")}: {self.language_settings.get("day", "Day")} {self.user.lunar_phase.get("moon_phase", "")}'
-            td["bottomLeft3"] = f'{self.language_settings.get("lunar_phase", "Lunar Phase")}: {self.user.lunar_phase.moon_phase_name}'
-            td["bottomLeft4"] = f'{self.user.perspective_type}'
-
-        else:
-            td["bottomLeft0"] = f"{self.user.zodiac_type if self.user.zodiac_type == 'Tropic' else self.user.zodiac_type + ' ' + self.user.sidereal_mode}"
-            td["bottomLeft1"] = f"{self.user.houses_system_name}"
-            td["bottomLeft2"] = f'{self.language_settings.get("lunar_phase", "Lunar Phase")}: {self.language_settings.get("day", "Day")} {self.t_user.lunar_phase.get("moon_phase", "")}'
-            td["bottomLeft3"] = f'{self.language_settings.get("lunar_phase", "Lunar Phase")}: {self.t_user.lunar_phase.moon_phase_name}'
-            td["bottomLeft4"] = f'{self.t_user.perspective_type}'
-
-        td['moon_phase'] = draw_moon_phase(
-            self.user.lunar_phase["degrees_between_s_m"],
+        # Draw moon phase
+        template_dict['moon_phase'] = draw_moon_phase(
+            self.user.lunar_phase["degrees_between_s_m"], 
             self.geolat
         )
-        
-        # stringlocation
+
+        # Set location string
         if len(self.location) > 35:
-            split = self.location.split(",")
-            if len(split) > 1:
-                td["stringLocation"] = split[0] + ", " + split[-1]
-                if len(td["stringLocation"]) > 35:
-                    td["stringLocation"] = td["stringLocation"][:35] + "..."
+            split_location = self.location.split(",")
+            if len(split_location) > 1:
+                template_dict["stringLocation"] = split_location[0] + ", " + split_location[-1]
+                if len(template_dict["stringLocation"]) > 35:
+                    template_dict["stringLocation"] = template_dict["stringLocation"][:35] + "..."
             else:
-                td["stringLocation"] = self.location[:35] + "..."
+                template_dict["stringLocation"] = self.location[:35] + "..."
         else:
-            td["stringLocation"] = self.location
+            template_dict["stringLocation"] = self.location
 
+        # Set additional information for Synastry chart type
         if self.chart_type == "Synastry":
-            td["stringLat"] = f"{self.t_user.name}: "
-            td["stringLon"] = self.t_user.city
-            td["stringPosition"] = f"{self.t_user.year}-{self.t_user.month}-{self.t_user.day} {self.t_user.hour:02d}:{self.t_user.minute:02d}"
-
+            template_dict["stringLat"] = f"{self.t_user.name}: "
+            template_dict["stringLon"] = self.t_user.city
+            template_dict["stringPosition"] = f"{self.t_user.year}-{self.t_user.month}-{self.t_user.day} {self.t_user.hour:02d}:{self.t_user.minute:02d}"
         else:
-            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']
-            )
-
-            td["stringLat"] = f"{self.language_settings['latitude']}: {latitude_string}"
-            td["stringLon"] = f"{self.language_settings['longitude']}: {longitude_string}"
-            td["stringPosition"] = f"{self.language_settings['type']}: {self.chart_type}"
-
-        # paper_color_X
-        td["paper_color_0"] = self.chart_colors_settings["paper_0"]
-        td["paper_color_1"] = self.chart_colors_settings["paper_1"]
+            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'])
+            template_dict["stringLat"] = f"{self.language_settings['latitude']}: {latitude_string}"
+            template_dict["stringLon"] = f"{self.language_settings['longitude']}: {longitude_string}"
+            template_dict["stringPosition"] = f"{self.language_settings['type']}: {self.chart_type}"
+
+        # Set paper colors
+        template_dict["paper_color_0"] = self.chart_colors_settings["paper_0"]
+        template_dict["paper_color_1"] = self.chart_colors_settings["paper_1"]
+
+        # Set planet colors
+        for planet in self.planets_settings:
+            planet_id = planet["id"]
+            template_dict[f"planets_color_{planet_id}"] = planet["color"] # type: ignore
+
+        # Set zodiac colors
+        for i in range(12):
+            template_dict[f"zodiac_color_{i}"] = self.chart_colors_settings[f"zodiac_icon_{i}"] # type: ignore
 
-        # planets_color_X
-        for i in range(len(self.planets_settings)):
-            planet_id = self.planets_settings[i]["id"]
-            td[f"planets_color_{planet_id}"] = self.planets_settings[i]["color"]
+        # Set orb colors
+        for aspect in self.aspects_settings:
+            template_dict[f"orb_color_{aspect['degree']}"] = aspect['color'] # type: ignore
 
-        # zodiac_color_X
-        for i in range(12):
-            td[f"zodiac_color_{i}"] = self.chart_colors_settings[f"zodiac_icon_{i}"]
+        # Drawing functions
+        template_dict["makeZodiac"] = self._draw_zodiac_circle_slices(self.main_radius)
 
-        # orb_color_X
-        for i in range(len(self.aspects_settings)):
-            td[f"orb_color_{self.aspects_settings[i]['degree']}"] = self.aspects_settings[i]['color']
+        first_subject_houses_list = get_houses_list(self.user)
 
-        # config
-        td["cfgRotate"] = rotate
+        # Draw houses grid and cusps
+        if self.chart_type in ["Transit", "Synastry"]:
+            second_subject_houses_list = get_houses_list(self.t_user)
 
-        # ---
-        # Drawing Functions
-        #--- 
+            template_dict["makeHousesGrid"] = draw_house_grid(
+                main_subject_houses_list=first_subject_houses_list,
+                secondary_subject_houses_list=second_subject_houses_list,
+                chart_type=self.chart_type,
+                text_color=self.chart_colors_settings["paper_0"],
+                house_cusp_generale_name_label=self.language_settings["cusp"]
+            )
 
-        td["makeZodiac"] = self._draw_zodiac_circle_slices(r)
-        td["makeHousesGrid"] = self._makeHouseGrid()
-        
-        # Houses Cusps and Number
-        if self.chart_type == "Transit" or self.chart_type == "Synastry":
-            td["makeHouses"] = draw_houses_cusps_and_text_number(
-                r=r,
-                first_subject_houses_list_ut=self.user.houses_degree_ut,
+            template_dict["makeHouses"] = draw_houses_cusps_and_text_number(
+                r=self.main_radius,
+                first_subject_houses_list=first_subject_houses_list,
                 standard_house_cusp_color=self.chart_colors_settings["houses_radix_line"],
                 first_house_color=self.planets_settings[12]["color"],
                 tenth_house_color=self.planets_settings[13]["color"],
                 seventh_house_color=self.planets_settings[14]["color"],
                 fourth_house_color=self.planets_settings[15]["color"],
-                c1=self.c1,
-                c3=self.c3,
+                c1=self.first_circle_radius,
+                c3=self.third_circle_radius,
                 chart_type=self.chart_type,
-                second_subject_houses_list_ut=self.t_user.houses_degree_ut,
+                second_subject_houses_list=second_subject_houses_list,
                 transit_house_cusp_color=self.chart_colors_settings["houses_transit_line"],
             )
+
         else:
-            td["makeHouses"] = draw_houses_cusps_and_text_number(
-                r=r,
-                first_subject_houses_list_ut=self.user.houses_degree_ut,
+            template_dict["makeHousesGrid"] = draw_house_grid(
+                main_subject_houses_list=first_subject_houses_list,
+                chart_type=self.chart_type,
+                text_color=self.chart_colors_settings["paper_0"],
+                house_cusp_generale_name_label=self.language_settings["cusp"]
+            )
+
+            template_dict["makeHouses"] = draw_houses_cusps_and_text_number(
+                r=self.main_radius,
+                first_subject_houses_list=first_subject_houses_list,
                 standard_house_cusp_color=self.chart_colors_settings["houses_radix_line"],
                 first_house_color=self.planets_settings[12]["color"],
                 tenth_house_color=self.planets_settings[13]["color"],
                 seventh_house_color=self.planets_settings[14]["color"],
                 fourth_house_color=self.planets_settings[15]["color"],
-                c1=self.c1,
-                c3=self.c3,
+                c1=self.first_circle_radius,
+                c3=self.third_circle_radius,
                 chart_type=self.chart_type,
             )
 
-        td["makePlanets"] = self._make_planets(r)
-        td["elements_percentages"] = draw_elements_percentages(
+        # Draw planets
+        if self.chart_type in ["Transit", "Synastry"]:
+            template_dict["makePlanets"] = draw_planets(
+                available_kerykeion_celestial_points=self.available_kerykeion_celestial_points, 
+                available_planets_setting=self.available_planets_setting,
+                second_subject_available_kerykeion_celestial_points=self.t_available_kerykeion_celestial_points,
+                radius=self.main_radius, 
+                main_subject_first_house_degree_ut=self.user.first_house.abs_pos,
+                main_subject_seventh_house_degree_ut=self.user.seventh_house.abs_pos,
+                chart_type=self.chart_type, 
+                third_circle_radius=self.third_circle_radius,
+            )
+        else:
+            template_dict["makePlanets"] = draw_planets(
+                available_planets_setting=self.available_planets_setting,
+                chart_type=self.chart_type,
+                radius=self.main_radius, 
+                available_kerykeion_celestial_points=self.available_kerykeion_celestial_points,
+                third_circle_radius=self.third_circle_radius,
+                main_subject_first_house_degree_ut=self.user.first_house.abs_pos,
+                main_subject_seventh_house_degree_ut=self.user.seventh_house.abs_pos
+            )
+
+        # Draw elements percentages
+        template_dict["elements_percentages"] = draw_elements_percentages(
             self.language_settings['fire'],
             self.fire,
             self.language_settings['earth'],
@@ -1039,29 +545,56 @@ class KerykeionChartSVG:
             self.water,
         )
 
-        td["makePlanetGrid"] = self._makePlanetGrid()
+        # Draw planet grid
+        if self.chart_type in ["Transit", "Synastry"]:
+            if self.chart_type == "Transit":
+                second_subject_table_name = self.language_settings["transit_name"]
+            else:
+                second_subject_table_name = self.t_user.name
+            template_dict["makePlanetGrid"] = draw_planet_grid(
+                planets_and_houses_grid_title=self.language_settings["planets_and_house"],
+                subject_name=self.user.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"],
+                second_subject_name=second_subject_table_name,
+                second_subject_available_kerykeion_celestial_points=self.t_available_kerykeion_celestial_points,
+            )
+        else:
+            template_dict["makePlanetGrid"] = draw_planet_grid(
+                planets_and_houses_grid_title=self.language_settings["planets_and_house"],
+                subject_name=self.user.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"],
+            )
 
-        # Date time String
+        # Set date time string
         dt = datetime.fromisoformat(self.user.iso_formatted_local_datetime)
-        custom_format = dt.strftime('%Y-%-m-%-d %H:%M [%z]')  # Note the use of '-' to remove leading zeros
+        custom_format = dt.strftime('%Y-%m-%d %H:%M [%z]')
         custom_format = custom_format[:-3] + ':' + custom_format[-3:]
-        td["stringDateTime"] = f"{custom_format}"
+        template_dict["stringDateTime"] = f"{custom_format}"
 
-        return td
+        return template_dict
 
     def makeTemplate(self, minify: bool = False) -> str:
         """Creates the template for the SVG file"""
-        td = self._createTemplateDictionary()
+        td = self._create_template_dictionary()
 
+        DATA_DIR = Path(__file__).parent
+        xml_svg = DATA_DIR / "templates" / "chart.xml"
+        
         # read template
-        with open(self.xml_svg, "r", encoding="utf-8", errors="ignore") as f:
+        with open(xml_svg, "r", encoding="utf-8", errors="ignore") as f:
             template = Template(f.read()).substitute(td)
 
         # return filename
 
         logging.debug(f"Template dictionary keys: {td.keys()}")
 
-        self._createTemplateDictionary()
+        self._create_template_dictionary()
 
         if minify:
             template = scourString(template).replace('"', "'").replace("\n", "").replace("\t","").replace("    ", "").replace("  ", "")
@@ -1072,9 +605,9 @@ class KerykeionChartSVG:
         return template
 
     def makeSVG(self, minify: bool = False):
-        """Prints out the SVG file in the specifide folder"""
+        """Prints out the SVG file in the specified folder"""
 
-        if not (self.template):
+        if not hasattr(self, "template"):
             self.template = self.makeTemplate(minify)
 
         self.chartname = self.output_directory / f"{self.user.name} - {self.chart_type} Chart.svg"
@@ -1084,6 +617,70 @@ class KerykeionChartSVG:
 
         logging.info(f"SVG Generated Correctly in: {self.chartname}")
 
+    def makeWheelOnlyTemplate(self, minify: bool = False):
+        """Creates the template for the SVG file with only the wheel"""
+    
+        with open(Path(__file__).parent / "templates" / "wheel_only.xml", "r", encoding="utf-8", errors="ignore") as f:
+            template = f.read()
+
+        template_dict = self._create_template_dictionary()
+        template = Template(template).substitute(template_dict)
+        
+        if minify:
+            template = scourString(template).replace('"', "'").replace("\n", "").replace("\t","").replace("    ", "").replace("  ", "")
+            
+        else:
+            template = template.replace('"', "'")
+
+        return template
+
+    def makeWheelOnlySVG(self, minify: bool = False):
+        """Prints out the SVG file in the specified folder with only the wheel"""
+
+        template = self.makeWheelOnlyTemplate(minify)
+
+        self.chartname = self.output_directory / f"{self.user.name} - {self.chart_type} Chart - Wheel Only.svg"
+
+        with open(self.chartname, "w", encoding="utf-8", errors="ignore") as output_file:
+            output_file.write(template)
+
+        logging.info(f"SVG Generated Correctly in: {self.chartname}")
+
+    def makeAspectGridOnlyTemplate(self, minify: bool = False):
+        """Creates the template for the SVG file with only the aspect grid"""
+    
+        with open(Path(__file__).parent / "templates" / "aspect_grid_only.xml", "r", encoding="utf-8", errors="ignore") as f:
+            template = f.read()
+
+        template_dict = self._create_template_dictionary()
+
+        if self.chart_type in ["Transit", "Synastry"]:
+            aspects_grid = draw_transit_aspect_grid(self.chart_colors_settings['paper_0'], self.available_planets_setting, self.aspects_list)
+        else:
+            aspects_grid = draw_aspect_grid(self.chart_colors_settings['paper_0'], self.available_planets_setting, self.aspects_list, x_start=50, y_start=250)
+
+        template = Template(template).substitute({**template_dict, "makeAspectGrid": aspects_grid})
+        
+        if minify:
+            template = scourString(template).replace('"', "'").replace("\n", "").replace("\t","").replace("    ", "").replace("  ", "")
+            
+        else:
+            template = template.replace('"', "'")
+
+        return template
+
+    def makeAspectGridOnlySVG(self, minify: bool = False):
+        """Prints out the SVG file in the specified folder with only the aspect grid"""
+
+        template = self.makeAspectGridOnlyTemplate(minify)
+
+        self.chartname = self.output_directory / f"{self.user.name} - {self.chart_type} Chart - Aspect Grid Only.svg"
+
+        with open(self.chartname, "w", encoding="utf-8", errors="ignore") as output_file:
+            output_file.write(template)
+
+        logging.info(f"SVG Generated Correctly in: {self.chartname}")
+
 
 if __name__ == "__main__":
     from kerykeion.utilities import setup_logging
@@ -1154,4 +751,139 @@ if __name__ == "__main__":
     # With Topocentric Perspective
     topocentric_subject = AstrologicalSubject("John Lennon - Topocentric", 1940, 10, 9, 18, 30, "Liverpool", "GB", perspective_type="Topocentric")
     topocentric_chart = KerykeionChartSVG(topocentric_subject)
-    topocentric_chart.makeSVG()
+    topocentric_chart.makeSVG()
+
+    # Minified SVG
+    minified_subject = AstrologicalSubject("John Lennon - Minified", 1940, 10, 9, 18, 30, "Liverpool", "GB")
+    minified_chart = KerykeionChartSVG(minified_subject)
+    minified_chart.makeSVG(minify=True)
+
+    # Dark Theme Natal Chart
+    dark_theme_subject = AstrologicalSubject("John Lennon - Dark Theme", 1940, 10, 9, 18, 30, "Liverpool", "GB")
+    dark_theme_natal_chart = KerykeionChartSVG(dark_theme_subject, theme="dark")
+    dark_theme_natal_chart.makeSVG()
+
+    # Dark High Contrast Theme Natal Chart
+    dark_high_contrast_theme_subject = AstrologicalSubject("John Lennon - Dark High Contrast Theme", 1940, 10, 9, 18, 30, "Liverpool", "GB")
+    dark_high_contrast_theme_natal_chart = KerykeionChartSVG(dark_high_contrast_theme_subject, theme="dark-high-contrast")
+    dark_high_contrast_theme_natal_chart.makeSVG()
+
+    # Light Theme Natal Chart
+    light_theme_subject = AstrologicalSubject("John Lennon - Light Theme", 1940, 10, 9, 18, 30, "Liverpool", "GB")
+    light_theme_natal_chart = KerykeionChartSVG(light_theme_subject, theme="light")
+    light_theme_natal_chart.makeSVG()
+
+    # Dark Theme External Natal Chart
+    dark_theme_external_subject = AstrologicalSubject("John Lennon - Dark Theme External", 1940, 10, 9, 18, 30, "Liverpool", "GB")
+    dark_theme_external_chart = KerykeionChartSVG(dark_theme_external_subject, "ExternalNatal", second, theme="dark")
+    dark_theme_external_chart.makeSVG()
+
+    # Dark Theme Synastry Chart
+    dark_theme_synastry_subject = AstrologicalSubject("John Lennon - DTS", 1940, 10, 9, 18, 30, "Liverpool", "GB")
+    dark_theme_synastry_chart = KerykeionChartSVG(dark_theme_synastry_subject, "Synastry", second, theme="dark")
+    dark_theme_synastry_chart.makeSVG()
+
+    # Wheel Natal Only Chart
+    wheel_only_subject = AstrologicalSubject("John Lennon - Wheel Only", 1940, 10, 9, 18, 30, "Liverpool", "GB")
+    wheel_only_chart = KerykeionChartSVG(wheel_only_subject)
+    wheel_only_chart.makeWheelOnlySVG()
+
+    # Wheel External Natal Only Chart
+    wheel_external_subject = AstrologicalSubject("John Lennon - Wheel External Only", 1940, 10, 9, 18, 30, "Liverpool", "GB")
+    wheel_external_chart = KerykeionChartSVG(wheel_external_subject, "ExternalNatal", second)
+    wheel_external_chart.makeWheelOnlySVG()
+
+    # Wheel Synastry Only Chart
+    wheel_synastry_subject = AstrologicalSubject("John Lennon - Wheel Synastry Only", 1940, 10, 9, 18, 30, "Liverpool", "GB")
+    wheel_synastry_chart = KerykeionChartSVG(wheel_synastry_subject, "Synastry", second)
+    wheel_synastry_chart.makeWheelOnlySVG()
+
+    # Wheel Transit Only Chart
+    wheel_transit_subject = AstrologicalSubject("John Lennon - Wheel Transit Only", 1940, 10, 9, 18, 30, "Liverpool", "GB")
+    wheel_transit_chart = KerykeionChartSVG(wheel_transit_subject, "Transit", second)
+    wheel_transit_chart.makeWheelOnlySVG()
+
+    # Wheel Sidereal Birth Chart (Lahiri) Dark Theme
+    sidereal_dark_subject = AstrologicalSubject("John Lennon Lahiri - Dark Theme", 1940, 10, 9, 18, 30, "Liverpool", "GB", zodiac_type="Sidereal", sidereal_mode="LAHIRI")
+    sidereal_dark_chart = KerykeionChartSVG(sidereal_dark_subject, theme="dark")
+    sidereal_dark_chart.makeWheelOnlySVG()
+
+    # Wheel Sidereal Birth Chart (Fagan-Bradley) Light Theme
+    sidereal_light_subject = AstrologicalSubject("John Lennon Fagan-Bradley - Light Theme", 1940, 10, 9, 18, 30, "Liverpool", "GB", zodiac_type="Sidereal", sidereal_mode="FAGAN_BRADLEY")
+    sidereal_light_chart = KerykeionChartSVG(sidereal_light_subject, theme="light")
+    sidereal_light_chart.makeWheelOnlySVG()
+
+    # Aspect Grid Only Natal Chart
+    aspect_grid_only_subject = AstrologicalSubject("John Lennon - Aspect Grid Only", 1940, 10, 9, 18, 30, "Liverpool", "GB")
+    aspect_grid_only_chart = KerykeionChartSVG(aspect_grid_only_subject)
+    aspect_grid_only_chart.makeAspectGridOnlySVG()
+
+    # Aspect Grid Only Dark Theme Natal Chart
+    aspect_grid_dark_subject = AstrologicalSubject("John Lennon - Aspect Grid Dark Theme", 1940, 10, 9, 18, 30, "Liverpool", "GB")
+    aspect_grid_dark_chart = KerykeionChartSVG(aspect_grid_dark_subject, theme="dark")
+    aspect_grid_dark_chart.makeAspectGridOnlySVG()
+
+    # Aspect Grid Only Light Theme Natal Chart
+    aspect_grid_light_subject = AstrologicalSubject("John Lennon - Aspect Grid Light Theme", 1940, 10, 9, 18, 30, "Liverpool", "GB")
+    aspect_grid_light_chart = KerykeionChartSVG(aspect_grid_light_subject, theme="light")
+    aspect_grid_light_chart.makeAspectGridOnlySVG()
+
+    # Synastry Chart Aspect Grid Only
+    aspect_grid_synastry_subject = AstrologicalSubject("John Lennon - Aspect Grid Synastry", 1940, 10, 9, 18, 30, "Liverpool", "GB")
+    aspect_grid_synastry_chart = KerykeionChartSVG(aspect_grid_synastry_subject, "Synastry", second)
+    aspect_grid_synastry_chart.makeAspectGridOnlySVG()
+
+    # Transit Chart Aspect Grid Only
+    aspect_grid_transit_subject = AstrologicalSubject("John Lennon - Aspect Grid Transit", 1940, 10, 9, 18, 30, "Liverpool", "GB")
+    aspect_grid_transit_chart = KerykeionChartSVG(aspect_grid_transit_subject, "Transit", second)
+    aspect_grid_transit_chart.makeAspectGridOnlySVG()
+
+    # Synastry Chart Aspect Grid Only Dark Theme
+    aspect_grid_dark_synastry_subject = AstrologicalSubject("John Lennon - Aspect Grid Dark Synastry", 1940, 10, 9, 18, 30, "Liverpool", "GB")
+    aspect_grid_dark_synastry_chart = KerykeionChartSVG(aspect_grid_dark_synastry_subject, "Synastry", second, theme="dark")
+    aspect_grid_dark_synastry_chart.makeAspectGridOnlySVG()
+
+    # Transit Chart With draw_transit_aspect_grid table
+    transit_chart_with_table_grid_subject = AstrologicalSubject("John Lennon - TCWTG", 1940, 10, 9, 18, 30, "Liverpool", "GB")
+    transit_chart_with_table_grid = KerykeionChartSVG(transit_chart_with_table_grid_subject, "Transit", second, double_chart_aspect_grid_type="table", theme="dark")
+    transit_chart_with_table_grid.makeSVG()
+
+    # Chines Language Chart
+    chinese_subject = AstrologicalSubject("Hua Chenyu", 1990, 2, 7, 12, 0, "Hunan", "CN")
+    chinese_chart = KerykeionChartSVG(chinese_subject, chart_language="CN")
+    chinese_chart.makeSVG()
+
+    # French Language Chart
+    french_subject = AstrologicalSubject("Jeanne Moreau", 1928, 1, 23, 10, 0, "Paris", "FR")
+    french_chart = KerykeionChartSVG(french_subject, chart_language="FR")
+    french_chart.makeSVG()
+
+    # Spanish Language Chart
+    spanish_subject = AstrologicalSubject("Antonio Banderas", 1960, 8, 10, 12, 0, "Malaga", "ES")
+    spanish_chart = KerykeionChartSVG(spanish_subject, chart_language="ES")
+    spanish_chart.makeSVG()
+
+    # Portuguese Language Chart
+    portuguese_subject = AstrologicalSubject("Cristiano Ronaldo", 1985, 2, 5, 5, 25, "Funchal", "PT")
+    portuguese_chart = KerykeionChartSVG(portuguese_subject, chart_language="PT")
+    portuguese_chart.makeSVG()
+
+    # Italian Language Chart
+    italian_subject = AstrologicalSubject("Sophia Loren", 1934, 9, 20, 2, 0, "Rome", "IT")
+    italian_chart = KerykeionChartSVG(italian_subject, chart_language="IT")
+    italian_chart.makeSVG()
+
+    # Russian Language Chart
+    russian_subject = AstrologicalSubject("Mikhail Bulgakov", 1891, 5, 15, 12, 0, "Kiev", "UA")
+    russian_chart = KerykeionChartSVG(russian_subject, chart_language="RU")
+    russian_chart.makeSVG()
+
+    # Turkish Language Chart
+    turkish_subject = AstrologicalSubject("Mehmet Oz", 1960, 6, 11, 12, 0, "Istanbul", "TR")
+    turkish_chart = KerykeionChartSVG(turkish_subject, chart_language="TR")
+    turkish_chart.makeSVG()
+
+    # German Language Chart
+    german_subject = AstrologicalSubject("Albert Einstein", 1879, 3, 14, 11, 30, "Ulm", "DE")
+    german_chart = KerykeionChartSVG(german_subject, chart_language="DE")
+    german_chart.makeSVG()