kerykeion 4.0.6__py3-none-any.whl → 4.8.1__py3-none-any.whl

kerykeion/charts/kerykeion_chart_svg.py

@@ -1,30 +1,39 @@
 # -*- coding: utf-8 -*-
 """
-    This is part of Kerykeion (C) 2023 Giacomo Battaglia
+    This is part of Kerykeion (C) 2024 Giacomo Battaglia
 """
 
 
-import pytz
+import logging
 
-from datetime import datetime
-from kerykeion.settings.kerykeion_settings import get_settings_dict
+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.chart_types import ChartTemplateModel
-from kerykeion.charts.charts_utils import decHourJoin, degreeDiff, offsetToTz, sliceToX, sliceToY
-from logging import getLogger, basicConfig
+from kerykeion.kr_types import ChartTemplateDictionary
+from kerykeion.kr_types.settings_models import KerykeionSettingsCelestialPointModel
+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,
+    draw_first_circle,
+    draw_second_circle
+)
 from pathlib import Path
+from scour.scour import scourString
 from string import Template
-from typing import Union
-
+from typing import Union, List
 
-logger = getLogger(__name__)
-basicConfig(
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    level="INFO"
-)
 
 
 class KerykeionChartSVG:
@@ -40,7 +49,13 @@ class KerykeionChartSVG:
         - lang: language settings (default: "EN")
         - new_settings_file: Set the settings file (default: kr.config.json)
     """
+    
+    # Constants
+    _DEFAULT_HEIGHT = 546.0
+    _DEFAULT_FULL_WIDTH = 1200
+    _DEFAULT_NATAL_WIDTH = 772.2
 
+    # Set at init
     first_obj: AstrologicalSubject
     second_obj: Union[AstrologicalSubject, None]
     chart_type: ChartType
@@ -48,6 +63,44 @@ class KerykeionChartSVG:
     new_settings_file: Union[Path, None]
     output_directory: Path
 
+    # Internal properties
+    fire: float
+    earth: float
+    air: float
+    water: float
+    c1: float
+    c2: float
+    c3: float
+    homedir: Path
+    xml_svg: Path
+    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
+    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
+    zoom: int
+    zodiac: tuple
+    template: str
+
     def __init__(
         self,
         first_obj: AstrologicalSubject,
@@ -68,56 +121,59 @@ class KerykeionChartSVG:
 
         self.xml_svg = DATA_DIR / "templates/chart.xml"
 
-        # SVG Width
-        self.natal_width = 772.2
-        self.full_width = 1200
-
         self.parse_json_settings(new_settings_file)
         self.chart_type = chart_type
 
         # Kerykeion instance
         self.user = first_obj
 
-        # Make a list for the absolute degrees of the points of the graphic.
-        self.points_deg_ut = self.user.planets_degrees_ut + [
-            self.user.houses_degree_ut[0],
-            self.user.houses_degree_ut[9],
-            self.user.houses_degree_ut[6],
-            self.user.houses_degree_ut[3],
+        self.available_planets_setting = []
+        for body in self.planets_settings:
+            if body['is_active'] == False:
+                continue
+
+            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 = []
+        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 self.user.planets_list:
-            self.points_deg.append(planet["position"])
-
-        self.points_deg = self.points_deg + [
-            self.user.houses_list[0]["position"],
-            self.user.houses_list[9]["position"],
-            self.user.houses_list[6]["position"],
-            self.user.houses_list[3]["position"],
-        ]
+        for planet in available_celestial_points:
+            self.points_deg.append(self.user.get(planet).position)
 
         # Make list of the points sign
         self.points_sign = []
-
-        for planet in self.user.planets_list:
-            self.points_sign.append(planet["sign_num"])
-
-        self.points_sign = self.points_sign + [
-            self.user.houses_list[0]["sign_num"],
-            self.user.houses_list[9]["sign_num"],
-            self.user.houses_list[6]["sign_num"],
-            self.user.houses_list[3]["sign_num"],
-        ]
+        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 self.user.planets_list:
-            self.points_retrograde.append(planet["retrograde"])
-
-        self.points_retrograde = self.points_retrograde + [False, False, False, False]
+        for planet in available_celestial_points:
+            self.points_retrograde.append(self.user.get(planet).retrograde)
 
         # Makes the sign number list.
 
@@ -127,7 +183,7 @@ class KerykeionChartSVG:
 
         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.get_relevant_aspects()
+            self.aspects_list = natal_aspects_instance.relevant_aspects
 
         # TODO: If not second should exit
         if self.chart_type == "Transit" or self.chart_type == "Synastry":
@@ -138,112 +194,46 @@ class KerykeionChartSVG:
             self.t_user = second_obj
 
             # Make a list for the absolute degrees of the points of the graphic.
-
-            self.t_points_deg_ut = self.t_user.planets_degrees_ut + [
-                self.t_user.houses_degree_ut[0],
-                self.t_user.houses_degree_ut[9],
-                self.t_user.houses_degree_ut[6],
-                self.t_user.houses_degree_ut[3],
-            ]
+            self.t_points_deg_ut = []
+            for planet in available_celestial_points:            
+                self.t_points_deg_ut.append(self.t_user.get(planet).abs_pos)
 
             # Make a list of the relative degrees of the points in the graphic.
-
             self.t_points_deg = []
-            for planet in self.t_user.planets_list:
-                self.t_points_deg.append(planet["position"])
-
-            self.t_points_deg = self.t_points_deg + [
-                self.t_user.houses_list[0]["position"],
-                self.t_user.houses_list[9]["position"],
-                self.t_user.houses_list[6]["position"],
-                self.t_user.houses_list[3]["position"],
-            ]
+            for planet in available_celestial_points:
+                self.t_points_deg.append(self.t_user.get(planet).position)
 
             # Make list of the poits sign.
-
             self.t_points_sign = []
-
-            for planet in self.t_user.planets_list:
-                self.t_points_sign.append(planet["sign_num"])
-
-            self.t_points_sign = self.t_points_sign + [
-                self.t_user.houses_list[0]["sign_num"],
-                self.t_user.houses_list[9]["sign_num"],
-                self.t_user.houses_list[6]["sign_num"],
-                self.t_user.houses_list[3]["sign_num"],
-            ]
+            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 self.t_user.planets_list:
-                self.t_points_retrograde.append(planet["retrograde"])
-
-            self.t_points_retrograde = self.t_points_retrograde + [False, False, False, False]
+            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"])
 
         # screen size
-        if self.chart_type == "Natal":
-            self.screen_width = 772.2
+        
+        self.height = self._DEFAULT_HEIGHT
+        if self.chart_type == "Synastry" or self.chart_type == "Transit":
+            self.width = self._DEFAULT_FULL_WIDTH
         else:
-            self.screen_width = 1200
-        self.screen_height = 772.2
-
-        # check for home
-        self.home_location = self.user.city
-        self.home_geolat = self.user.lat
-        self.home_geolon = self.user.lng
-        self.home_countrycode = self.user.nation
-        self.home_timezonestr = self.user.tz_str
-
-        print(f"{self.user.name} birth location: {self.home_location}, {self.home_geolat}, {self.home_geolon}")
+            self.width = self._DEFAULT_NATAL_WIDTH
 
         # default location
-        self.location = self.home_location
-        self.geolat = float(self.home_geolat)
-        self.geolon = float(self.home_geolon)
-        self.countrycode = self.home_countrycode
-        self.timezonestr = self.home_timezonestr
-
-        # current datetime
-        now = datetime.now()
-
-        # aware datetime object
-        dt_input = datetime(now.year, now.month, now.day, now.hour, now.minute, now.second)
-        dt = pytz.timezone(self.timezonestr).localize(dt_input)
-
-        # naive utc datetime object
-        dt_utc = dt.replace(tzinfo=None) - dt.utcoffset()  # type: ignore
-
-        # Default
-        self.name = self.user.name
-        self.charttype = self.chart_type
-        self.year = self.user.utc.year
-        self.month = self.user.utc.month
-        self.day = self.user.utc.day
-        self.hour = self.user.utc.hour + self.user.utc.minute / 100
-        self.timezone = offsetToTz(dt.utcoffset())
-        self.altitude = 25
-        self.geonameid = None
-
-        # Transit
+        self.location = self.user.city
+        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_geolon = self.geolon
-            self.t_geolat = self.geolat
-            self.t_altitude = self.altitude
             self.t_name = self.language_settings["transit_name"]
-            self.t_year = dt_utc.year
-            self.t_month = dt_utc.month
-            self.t_day = dt_utc.day
-            self.t_hour = decHourJoin(dt_utc.hour, dt_utc.minute, dt_utc.second)
-            self.t_timezone = offsetToTz(dt.utcoffset())
-            self.t_altitude = 25
-            self.t_geonameid = None
 
         # configuration
         # ZOOM 1 = 100%
@@ -264,22 +254,20 @@ class KerykeionChartSVG:
             {"name": "pisces", "element": "water"},
         )
 
-        # Immediately generate template.
-        self.template = self.makeTemplate()
+        self.template = None
 
     def set_output_directory(self, dir_path: Path) -> None:
         """
         Sets the output direcotry and returns it's path.
         """
         self.output_directory = dir_path
-        dir_string = f"Output direcotry set to: {self.output_directory}"
-        return print(dir_string)
+        logging.info(f"Output direcotry set to: {self.output_directory}")
 
     def parse_json_settings(self, settings_file):
         """
         Parse the settings file.
         """
-        settings = get_settings_dict(settings_file)
+        settings = get_settings(settings_file)
 
         language = settings["general_settings"]["language"]
         self.language_settings = settings["language_settings"].get(language, "EN")
@@ -289,163 +277,30 @@ class KerykeionChartSVG:
         self.planet_in_zodiac_extra_points = settings["general_settings"]["planet_in_zodiac_extra_points"]
         self.chart_settings = settings["chart_settings"]
 
-    def _transitRing(self, r) -> str:
-        """
-        Draws the transit ring.
-        """
-        radius_offset = 18
-
-        out = f'<circle cx="{r}" cy="{r}" r="{r - radius_offset}" style="fill: none; stroke: {self.chart_colors_settings["paper_1"]}; stroke-width: 36px; stroke-opacity: .4;"/>'
-        out += f'<circle cx="{r}" cy="{r}" r="{r}" style="fill: none; stroke: {self.chart_colors_settings["zodiac_transit_ring_3"]}; stroke-width: 1px; stroke-opacity: .6;"/>'
-
-        return out
-
-    def _degreeRing(self, r) -> str:
+    def _draw_zodiac_circle_slices(self, r):
         """
-        Draws the degree ring.
-        """
-        out = ""
-        for i in range(72):
-            offset = float(i * 5) - self.user.houses_degree_ut[6]
-            if offset < 0:
-                offset = offset + 360.0
-            elif offset > 360:
-                offset = offset - 360.0
-            x1 = sliceToX(0, r - self.c1, offset) + self.c1
-            y1 = sliceToY(0, r - self.c1, offset) + self.c1
-            x2 = sliceToX(0, r + 2 - self.c1, offset) - 2 + self.c1
-            y2 = sliceToY(0, r + 2 - self.c1, offset) - 2 + self.c1
-
-            out += f'<line x1="{x1}" y1="{y1}" x2="{x2}" y2="{y2}" style="stroke: {self.chart_colors_settings["paper_0"]}; stroke-width: 1px; stroke-opacity:.9;"/>'
-
-        return out
-
-    def _degreeTransitRing(self, r):
-        out = ""
-        for i in range(72):
-            offset = float(i * 5) - self.user.houses_degree_ut[6]
-            if offset < 0:
-                offset = offset + 360.0
-            elif offset > 360:
-                offset = offset - 360.0
-            x1 = sliceToX(0, r, offset)
-            y1 = sliceToY(0, r, offset)
-            x2 = sliceToX(0, r + 2, offset) - 2
-            y2 = sliceToY(0, r + 2, offset) - 2
-            out += f'<line x1="{x1}" y1="{y1}" x2="{x2}" y2="{y2}" style="stroke: #F00; stroke-width: 1px; stroke-opacity:.9;"/>'
-
-        return out
-
-    def _lat2str(self, coord):
-        """Converts a floating point latitude to string with
-        degree, minutes and seconds and the appropriate sign
-        (north or south). Eg. 52.1234567 -> 52°7'25" N
+        Generate the SVG string representing the zodiac circle
+        with the 12 slices for each zodiac sign.
 
         Args:
-            coord (float): latitude in floating point format
-        Returns:
-            str: latitude in string format with degree, minutes,
-             seconds and sign (N/S)
-        """
-
-        sign = self.language_settings["north"]
-        if coord < 0.0:
-            sign = self.language_settings["south"]
-            coord = abs(coord)
-        deg = int(coord)
-        min = int((float(coord) - deg) * 60)
-        sec = int(round(float(((float(coord) - deg) * 60) - min) * 60.0))
-        return f"{deg}°{min}'{sec}\" {sign}"
+            r (float): The radius of the zodiac slices.
 
-    def _lon2str(self, coord):
-        """Converts a floating point longitude to string with
-        degree, minutes and seconds and the appropriate sign
-        (east or west). Eg. 52.1234567 -> 52°7'25" E
-
-        Args:
-            coord (float): longitude in floating point format
         Returns:
-            str: longitude in string format with degree, minutes,
-                seconds and sign (E/W)
+            str: The SVG string representing the zodiac circle.
         """
 
-        sign = self.language_settings["east"]
-        if coord < 0.0:
-            sign = self.language_settings["west"]
-            coord = abs(coord)
-        deg = int(coord)
-        min = int((float(coord) - deg) * 60)
-        sec = int(round(float(((float(coord) - deg) * 60) - min) * 60.0))
-        return f"{deg}°{min}'{sec}\" {sign}"
-
-    def _dec2deg(self, dec, type="3"):
-        """Coverts decimal float to degrees in format
-        a°b'c".
-        """
-
-        dec = float(dec)
-        a = int(dec)
-        a_new = (dec - float(a)) * 60.0
-        b_rounded = int(round(a_new))
-        b = int(a_new)
-        c = int(round((a_new - float(b)) * 60.0))
-        if type == "3":
-            out = f"{a:02d}&#176;{b:02d}&#39;{c:02d}&#34;"
-        elif type == "2":
-            out = f"{a:02d}&#176;{b_rounded:02d}&#39;"
-        elif type == "1":
-            out = f"{a:02d}&#176;"
-        else:
-            raise KerykeionException(f"Wrong type: {type}, it must be 1, 2 or 3.")
-        return str(out)
-
-    def _drawAspect(self, r, ar, degA, degB, color):
-        """
-        Draws svg aspects: ring, aspect ring, degreeA degreeB
-        """
-        offset = (int(self.user.houses_degree_ut[6]) / -1) + int(degA)
-        x1 = sliceToX(0, ar, offset) + (r - ar)
-        y1 = sliceToY(0, ar, offset) + (r - ar)
-        offset = (int(self.user.houses_degree_ut[6]) / -1) + int(degB)
-        x2 = sliceToX(0, ar, offset) + (r - ar)
-        y2 = sliceToY(0, ar, offset) + (r - ar)
-        out = f'            <line x1="{x1}" y1="{y1}" x2="{x2}" y2="{y2}" style="stroke: {color}; stroke-width: 1; stroke-opacity: .9;"/>'
-
-        return out
-
-    def _zodiacSlice(self, num, r, style, type):
-        # pie slices
-        offset = 360 - self.user.houses_degree_ut[6]
-        # check transit
-        if self.chart_type == "Transit" or self.chart_type == "Synastry":
-            dropin = 0
-        else:
-            dropin = self.c1
-        slice = f'<path d="M{str(r)},{str(r)} L{str(dropin + sliceToX(num, r - dropin, offset))},{str(dropin + sliceToY(num, r - dropin, offset))} A{str(r - dropin)},{str(r - dropin)} 0 0,0 {str(dropin + sliceToX(num + 1, r - dropin, offset))},{str(dropin + sliceToY(num + 1, r - dropin, offset))} z" style="{style}"/>'
-
-        # symbols
-        offset = offset + 15
-        # check transit
-        if self.chart_type == "Transit" or self.chart_type == "Synastry":
-            dropin = 54
-        else:
-            dropin = 18 + self.c1
-        sign = f'<g transform="translate(-16,-16)"><use x="{str(dropin + sliceToX(num, r - dropin, offset))}" y="{str(dropin + sliceToY(num, r - dropin, offset))}" xlink:href="#{type}" /></g>'
-
-        return slice + "" + sign
-
-    def _makeZodiac(self, r):
         output = ""
-        for i in range(len(self.zodiac)):
-            output = (
-                output
-                + self._zodiacSlice(
-                    i,
-                    r,
-                    f'fill:{self.chart_colors_settings[f"zodiac_bg_{i}"]}; fill-opacity: 0.5;',
-                    self.zodiac[i]["name"],
-                )
+        for i, zodiac_element in enumerate(self.zodiac):
+            output += draw_zodiac_slice(
+                c1=self.c1,
+                chart_type=self.chart_type,
+                seventh_house_degree_ut=self.user.houses_degree_ut[6],
+                num=i,
+                r=r,
+                style=f'fill:{self.chart_colors_settings[f"zodiac_bg_{i}"]}; fill-opacity: 0.5;',
+                type=zodiac_element["name"],
             )
+
         return output
 
     def _makeHouses(self, r):
@@ -535,44 +390,50 @@ class KerykeionChartSVG:
 
         return path
 
-    def _value_element_from_planet(self, i):
+    def _calculate_elements_points_from_planets(self):
         """
         Calculate chart element points from a planet.
         """
+        
+        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]
+            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
 
-        # element: get extra points if planet is in own zodiac sign.
-        related_zodiac_signs = self.planets_settings[i]["related_zodiac_signs"]
-        cz = self.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
-
-        ele = self.zodiac[self.points_sign[i]]["element"]
-        if ele == "fire":
-            self.fire = self.fire + self.planets_settings[i]["element_points"] + extra_points
+            ele = self.zodiac[self.points_sign[i]]["element"]
+            if ele == "fire":
+                self.fire = self.fire + self.available_planets_setting[i]["element_points"] + extra_points
 
-        elif ele == "earth":
-            self.earth = self.earth + self.planets_settings[i]["element_points"] + extra_points
+            elif ele == "earth":
+                self.earth = self.earth + self.available_planets_setting[i]["element_points"] + extra_points
 
-        elif ele == "air":
-            self.air = self.air + self.planets_settings[i]["element_points"] + extra_points
+            elif ele == "air":
+                self.air = self.air + self.available_planets_setting[i]["element_points"] + extra_points
 
-        elif ele == "water":
-            self.water = self.water + self.planets_settings[i]["element_points"] + extra_points
+            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.planets_settings))
+        diff = range(len(self.available_planets_setting))
 
-        for i in range(len(self.planets_settings)):
-            if self.planets_settings[i]["is_active"] == 1:
-                # list of planets sorted by degree
-                logger.debug(f"planet: {i}, degree: {self.points_deg_ut[i]}")
-                planets_degut[self.points_deg_ut[i]] = i
+        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
 
-            self._value_element_from_planet(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())
@@ -601,24 +462,24 @@ class KerykeionChartSVG:
             diffb = degreeDiff(next, self.points_deg_ut[i])
             planets_by_pos[e] = [i, diffa, diffb]
 
-            logger.debug(f'{self.planets_settings[i]["label"]}, {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.planets_settings[planets_degut[keys[e]]]["label"]])
+                    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.planets_settings[planets_degut[keys[e]]]["label"]])
+                    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.planets_settings[planets_degut[keys[e]]]["label"]])
+                    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.planets_settings))))
+        planets_delta = list(map(zero, range(len(self.available_planets_setting))))
 
         # print groups
         # print planets_by_pos
@@ -730,7 +591,7 @@ class KerykeionChartSVG:
                 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.planets_settings[i]["color"]
+                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)
@@ -748,20 +609,21 @@ class KerykeionChartSVG:
             else:
                 scale = 1
             # output planet
-            output += f'<g transform="translate(-{12 * scale},-{12 * scale})"><g transform="scale({scale})"><use x="{planet_x * (1/scale)}" y="{planet_y * (1/scale)}" xlink:href="#{self.planets_settings[i]["name"]}" /></g></g>'
+            output += f'<g transform="translate(-{12 * scale},-{12 * scale})"><g transform="scale({scale})"><use x="{planet_x * (1/scale)}" y="{planet_y * (1/scale)}" xlink:href="#{self.available_planets_setting[i]["name"]}" /></g></g>'
 
         # make transit degut and display planets
         if self.chart_type == "Transit" or self.chart_type == "Synastry":
             group_offset = {}
             t_planets_degut = {}
-            if self.chart_type == "Transit":
-                list_range = len(self.planets_settings) - 4
-            else:
-                list_range = len(self.planets_settings)
+            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
-                if self.planets_settings[i]["is_active"] == 1:
-                    t_planets_degut[self.t_points_deg_ut[i]] = i
+                t_planets_degut[self.t_points_deg_ut[i]] = i
+        
             t_keys = list(t_planets_degut.keys())
             t_keys.sort()
 
@@ -803,7 +665,12 @@ class KerykeionChartSVG:
                     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:
@@ -815,20 +682,21 @@ class KerykeionChartSVG:
                     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 transform="translate(-6,-6)"><g transform="scale(0.5)"><use x="{planet_x*2}" y="{planet_y*2}" xlink:href="#{self.planets_settings[i]["name"]}" /></g></g>'
+                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
+                # 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 x1="{str(x1)}" y1="{str(y1)}" x2="{str(x2)}" y2="{str(y2)}" style="stroke: {self.planets_settings[i]["color"]}; stroke-width: 1px; stroke-opacity:.8;"/>'
+                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]
@@ -852,7 +720,7 @@ class KerykeionChartSVG:
                 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.planets_settings[i]["color"]}; font-size: 10px;">{self._dec2deg(self.t_points_deg[i], type="1")}'
+                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
@@ -867,7 +735,7 @@ class KerykeionChartSVG:
             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.planets_settings[i]["color"]}; stroke-width: 2px; stroke-opacity:.6;"/>'
+            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":
@@ -879,7 +747,7 @@ class KerykeionChartSVG:
             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.planets_settings[i]["color"]}; stroke-width: 2px; stroke-opacity:.6;"/>'
+            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
 
@@ -897,7 +765,7 @@ class KerykeionChartSVG:
         tr = {}  # 6
         qc = {}  # 9
         sext = {}  # 3
-        for i in range(len(self.planets_settings)):
+        for i in range(len(self.available_planets_setting)):
             a = self.points_deg_ut[i]
             qc[i] = {}
             sext[i] = {}
@@ -906,14 +774,14 @@ class KerykeionChartSVG:
             tr[i] = {}
             conj[i] = {}
             # skip some points
-            n = self.planets_settings[i]["name"]
+            n = self.available_planets_setting[i]["name"]
             if n == "earth" or n == "True_Node" or n == "osc. apogee" or n == "intp. apogee" or n == "intp. perigee":
                 continue
             if n == "Dsc" or n == "Ic":
                 continue
-            for j in range(len(self.planets_settings)):
+            for j in range(len(self.available_planets_setting)):
                 # skip some points
-                n = self.planets_settings[j]["name"]
+                n = self.available_planets_setting[j]["name"]
                 if n == "earth" or n == "True_Node" or n == "osc. apogee" or n == "intp. apogee" or n == "intp. perigee":
                     continue
                 if n == "Dsc" or n == "Ic":
@@ -966,12 +834,12 @@ class KerykeionChartSVG:
                 for l, w in opp[k].items():
                     for a, b in sq.items():
                         if k in sq[a] and l in sq[a]:
-                            logger.debug(f"Got tsquare {a} {k} {l}")
+                            logging.debug(f"Got tsquare {a} {k} {l}")
                             if k > l:
-                                tsquare[f"{a},{l},{k}"] = f"{self.planets_settings[a]['label']} => {self.planets_settings[l]['label']}, {self.planets_settings[k]['label']}"
+                                tsquare[f"{a},{l},{k}"] = f"{self.available_planets_setting[a]['label']} => {self.available_planets_setting[l]['label']}, {self.available_planets_setting[k]['label']}"
 
                             else:
-                                tsquare[f"{a},{k},{l}"] = f"{self.planets_settings[a]['label']} => {self.planets_settings[k]['label']}, {self.planets_settings[l]['label']}"
+                                tsquare[f"{a},{k},{l}"] = f"{self.available_planets_setting[a]['label']} => {self.available_planets_setting[k]['label']}, {self.available_planets_setting[l]['label']}"
 
         stellium = {}
         # check for 4 continuous conjunctions
@@ -1000,10 +868,10 @@ class KerykeionChartSVG:
                                             l = [k, n, p, r]
                                             l.sort()
                                             stellium["%s %s %s %s" % (l[0], l[1], l[2], l[3])] = "%s %s %s %s" % (
-                                                self.planets_settings[l[0]]["label"],
-                                                self.planets_settings[l[1]]["label"],
-                                                self.planets_settings[l[2]]["label"],
-                                                self.planets_settings[l[3]]["label"],
+                                                self.available_planets_setting[l[0]]["label"],
+                                                self.available_planets_setting[l[1]]["label"],
+                                                self.available_planets_setting[l[2]]["label"],
+                                                self.available_planets_setting[l[3]]["label"],
                                             )
         # print yots
         out = '<g transform="translate(-30,380)">'
@@ -1014,15 +882,15 @@ class KerykeionChartSVG:
 
                 # first planet symbol
                 out += f'<g transform="translate(20,{y})">'
-                out += f'<use transform="scale(0.4)" x="0" y="-20" xlink:href="#{self.planets_settings[yot[k][0]]["name"]}" /></g>'
+                out += f'<use transform="scale(0.4)" x="0" y="-20" xlink:href="#{self.available_planets_setting[yot[k][0]]["name"]}" /></g>'
 
                 # second planet symbol
                 out += f'<g transform="translate(30,{y})">'
-                out += f'<use transform="scale(0.4)" x="0" y="-20" xlink:href="#{self.planets_settings[yot[k][1]]["name"]}" /></g>'
+                out += f'<use transform="scale(0.4)" x="0" y="-20" xlink:href="#{self.available_planets_setting[yot[k][1]]["name"]}" /></g>'
 
                 # third planet symbol
                 out += f'<g transform="translate(40,{y})">'
-                out += f'<use transform="scale(0.4)" x="0" y="-20" xlink:href="#{self.planets_settings[yot[k][2]]["name"]}" /></g>'
+                out += f'<use transform="scale(0.4)" x="0" y="-20" xlink:href="#{self.available_planets_setting[yot[k][2]]["name"]}" /></g>'
 
                 y = y + 14
         # finalize
@@ -1034,12 +902,13 @@ class KerykeionChartSVG:
     def _makeAspects(self, r, ar):
         out = ""
         for element in self.aspects_list:
-            out += self._drawAspect(
-                r,
-                ar,
-                element["p1_abs_pos"],
-                element["p2_abs_pos"],
-                self.aspects_settings[element["aid"]]["color"],
+            out += draw_aspect_line(
+                r=r,
+                ar=ar,
+                degA=element["p1_abs_pos"],
+                degB=element["p2_abs_pos"],
+                color=self.aspects_settings[element["aid"]]["color"],
+                seventh_house_degree_ut=self.user.seventh_house.abs_pos
             )
 
         return out
@@ -1050,29 +919,27 @@ class KerykeionChartSVG:
         xindent = 380
         yindent = 468
         box = 14
-        revr = list(range(len(self.planets_settings)))
+        revr = list(range(len(self.available_planets_setting)))
         revr.reverse()
         counter = 0
         for a in revr:
             counter += 1
-            if self.planets_settings[a]["is_active"] == 1:
-                out += f'<rect x="{xindent}" y="{yindent}" width="{box}" height="{box}" style="{style}"/>'
-                out += f'<use transform="scale(0.4)" x="{(xindent+2)*2.5}" y="{(yindent+1)*2.5}" xlink:href="#{self.planets_settings[a]["name"]}" />'
-
-                xindent = xindent + box
-                yindent = yindent - box
-                revr2 = list(range(a))
-                revr2.reverse()
-                xorb = xindent
-                yorb = yindent + box
-                for b in revr2:
-                    if self.planets_settings[b]["is_active"] == 1:
-                        out += f'<rect x="{xorb}" y="{yorb}" width="{box}" height="{box}" style="{style}"/>'
-
-                        xorb = xorb + box
-                        for element in self.aspects_list:
-                            if (element["p1"] == a and element["p2"] == b) or (element["p1"] == b and element["p2"] == a):
-                                out += f'<use  x="{xorb-box+1}" y="{yorb+1}" xlink:href="#orb{element["aspect_degrees"]}" />'
+            out += f'<rect x="{xindent}" y="{yindent}" width="{box}" height="{box}" style="{style}"/>'
+            out += f'<use transform="scale(0.4)" x="{(xindent+2)*2.5}" y="{(yindent+1)*2.5}" xlink:href="#{self.available_planets_setting[a]["name"]}" />'
+
+            xindent = xindent + box
+            yindent = yindent - box
+            revr2 = list(range(a))
+            revr2.reverse()
+            xorb = xindent
+            yorb = yindent + box
+            for b in revr2:
+                out += f'<rect x="{xorb}" y="{yorb}" width="{box}" height="{box}" style="{style}"/>'
+
+                xorb = xorb + box
+                for element in self.aspects_list:
+                    if (element["p1"] == a and element["p2"] == b) or (element["p1"] == b and element["p2"] == a):
+                        out += f'<use  x="{xorb-box+1}" y="{yorb+1}" xlink:href="#orb{element["aspect_degrees"]}" />'
 
         return out
 
@@ -1080,15 +947,16 @@ class KerykeionChartSVG:
     def _makeAspectsTransit(self, r, ar):
         out = ""
 
-        self.aspects_list = SynastryAspects(self.user, self.t_user, new_settings_file=self.new_settings_file).get_relevant_aspects()
+        self.aspects_list = SynastryAspects(self.user, self.t_user, new_settings_file=self.new_settings_file).relevant_aspects
 
         for element in self.aspects_list:
-            out += self._drawAspect(
-                r,
-                ar,
-                element["p1_abs_pos"],
-                element["p2_abs_pos"],
-                self.aspects_settings[element["aid"]]["color"],
+            out += draw_aspect_line(
+                r=r,
+                ar=ar,
+                degA=element["p1_abs_pos"],
+                degB=element["p2_abs_pos"],
+                color=self.aspects_settings[element["aid"]]["color"],
+                seventh_house_degree_ut=self.user.seventh_house.abs_pos
             )
 
         return out
@@ -1126,55 +994,37 @@ class KerykeionChartSVG:
                     line = 0
 
             out += f'<g transform="translate({nl},{line})">'
+            
             # first planet symbol
-
-            # TODO: (next((item for item in self.planets_settings if item["id"] == self.aspects_list[i]["p1"]))) It preventes the use ot numeric ID, but it is not working.
             out += f'<use transform="scale(0.4)" x="0" y="3" xlink:href="#{self.planets_settings[self.aspects_list[i]["p1"]]["name"]}" />'
             
             # aspect symbol
             out += f'<use  x="15" y="0" xlink:href="#orb{self.aspects_settings[self.aspects_list[i]["aid"]]["degree"]}" />'
+            
             # second planet symbol
             out += '<g transform="translate(30,0)">'
-            
-            # TODO: (next((item for item in self.planets_settings if item["id"] == self.aspects_list[i]["p3"])))
             out += '<use transform="scale(0.4)" x="0" y="3" xlink:href="#%s" />' % (self.planets_settings[self.aspects_list[i]["p2"]]["name"]) 
             
             out += "</g>"
             # difference in degrees
-            out += f'<text y="8" x="45" style="fill:{self.chart_colors_settings["paper_0"]}; font-size: 10px;">{self._dec2deg(self.aspects_list[i]["orbit"])}</text>'
+            out += f'<text y="8" x="45" style="fill:{self.chart_colors_settings["paper_0"]}; font-size: 10px;">{convert_decimal_to_degree_string(self.aspects_list[i]["orbit"])}</text>'
             # line
             out += "</g>"
             line = line + 14
         out += "</g>"
         return out
 
-    def _makeElements(self, r):
-        total = self.fire + self.earth + self.air + self.water
-        pf = int(round(100 * self.fire / total))
-        pe = int(round(100 * self.earth / total))
-        pa = int(round(100 * self.air / total))
-        pw = int(round(100 * self.water / total))
-
-        out = '<g transform="translate(-30,79)">'
-        out += f'<text y="0" style="fill:#ff6600; font-size: 10px;">{self.language_settings["fire"]}  {str(pf)}%</text>'
-        out += f'<text y="12" style="fill:#6a2d04; font-size: 10px;">{self.language_settings["earth"]} {str(pe)}%</text>'
-        out += f'<text y="24" style="fill:#6f76d1; font-size: 10px;">{self.language_settings["air"]}   {str(pa)}%</text>'
-        out += f'<text y="36" style="fill:#630e73; font-size: 10px;">{self.language_settings["water"]} {str(pw)}%</text>'
-        out += "</g>"
-
-        return out
-
     def _makePlanetGrid(self):
         li = 10
         offset = 0
 
         out = '<g transform="translate(500,-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.name}:</text>'
+        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.planets_settings)):
+        for i in range(len(self.available_planets_setting)):
             offset_between_lines = 14
             end_of_line = "</g>"
 
@@ -1183,30 +1033,29 @@ class KerykeionChartSVG:
                 li = 10
                 offset = -120
 
-            if self.planets_settings[i]["is_active"] == 1:
-                # start of line
-                out += f'<g transform="translate({offset},{li})">'
+            # 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.planets_settings[i]["label"]]}</text>'
+            # 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.planets_settings[i]["name"]}" /></g>'
+            # 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;">{self._dec2deg(self.points_deg[i])}</text>'
+            # 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>'
+            # 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>'
+            # 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
+            # end of line
+            out += end_of_line
 
-                li = li + offset_between_lines
+            li = li + offset_between_lines
 
         if self.chart_type == "Transit" or self.chart_type == "Synastry":
             if self.chart_type == "Transit":
@@ -1221,32 +1070,31 @@ class KerykeionChartSVG:
             t_li = 10
             t_offset = 250
 
-            for i in range(len(self.planets_settings)):
+            for i in range(len(self.available_planets_setting)):
                 if i == 27:
                     t_li = 10
                     t_offset = -120
 
-                if self.planets_settings[i]["is_active"] == 1:
-                    # start of line
-                    out += f'<g transform="translate({t_offset},{t_li})">'
+                # 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.planets_settings[i]["label"]]}</text>'
-                    # planet symbol
-                    out += f'<g transform="translate(5,-8)"><use transform="scale(0.4)" xlink:href="#{self.planets_settings[i]["name"]}" /></g>'
-                    # planet degree
-                    out += f'<text text-anchor="start" x="19" style="fill:{self.chart_colors_settings["paper_0"]}; font-size: 10px;">{self._dec2deg(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 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>'
+                # 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
+                # end of line
+                out += end_of_line
 
-                    t_li = t_li + offset_between_lines
+                t_li = t_li + offset_between_lines
 
         if end_of_line is None:
             raise KerykeionException("End of line not found")
@@ -1254,7 +1102,13 @@ class KerykeionChartSVG:
         out += end_of_line
         return out
 
-    def _makeHousesGrid(self):
+    def _draw_house_grid(self):
+        """
+        Generate SVG code for a grid of astrological houses.
+
+        Returns:
+            str: The SVG code for the grid of houses.
+        """
         out = '<g transform="translate(600,-20)">'
 
         li = 10
@@ -1266,7 +1120,7 @@ class KerykeionChartSVG:
             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;"> {self._dec2deg(self.user.houses_list[i]["position"])}</text>'
+            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
 
@@ -1283,14 +1137,14 @@ class KerykeionChartSVG:
                 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;"> {self._dec2deg(self.t_user.houses_list[i]["position"])}</text>'
+                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>"
 
         return out
 
-    def _createTemplateDictionary(self):
+    def _createTemplateDictionary(self) -> ChartTemplateDictionary:
         # self.chart_type = "Transit"
         # empty element points
         self.fire = 0.0
@@ -1298,12 +1152,8 @@ class KerykeionChartSVG:
         self.air = 0.0
         self.water = 0.0
 
-        # width and height from screen
-        ratio = float(self.screen_width) / float(self.screen_height)
-        if ratio < 1.3:  # 1280x1024
-            wm_off = 130
-        else:  # 1024x768, 800x600, 1280x800, 1680x1050
-            wm_off = 100
+        # Calculate the elements points
+        self._calculate_elements_points_from_planets()
 
         # Viewbox and sizing
         svgHeight = "100%"
@@ -1318,7 +1168,7 @@ class KerykeionChartSVG:
             viewbox = self.chart_settings["wide_chart_viewBox"]
 
         # template dictionary
-        td: ChartTemplateModel = dict()
+        td: ChartTemplateDictionary = dict() # type: ignore
         r = 240
 
         if self.chart_type == "ExternalNatal":
@@ -1332,14 +1182,12 @@ class KerykeionChartSVG:
 
         # transit
         if self.chart_type == "Transit" or self.chart_type == "Synastry":
-            td["transitRing"] = self._transitRing(r)
-            td["degreeRing"] = self._degreeTransitRing(r)
+            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["c1"] = f'cx="{r}" cy="{r}" r="{r - 36}"'
-            td["c1style"] = f'fill: none; stroke: {self.chart_colors_settings["zodiac_transit_ring_2"]}; stroke-width: 1px; stroke-opacity:.4;'
-            td["c2"] = 'cx="' + str(r) + '" cy="' + str(r) + '" r="' + str(r - 72) + '"'
-            td["c2style"] = f"fill: {self.chart_colors_settings['paper_1']}; fill-opacity:.4; stroke: {self.chart_colors_settings['zodiac_transit_ring_1']}; stroke-opacity:.4; stroke-width: 1px"
+            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["c3"] = 'cx="' + str(r) + '" cy="' + str(r) + '" r="' + str(r - 160) + '"'
             td["c3style"] = f"fill: {self.chart_colors_settings['paper_1']}; fill-opacity:.8; stroke: {self.chart_colors_settings['zodiac_transit_ring_0']}; stroke-width: 1px"
@@ -1347,23 +1195,23 @@ class KerykeionChartSVG:
             td["makeAspects"] = self._makeAspectsTransit(r, (r - 160))
             td["makeAspectGrid"] = self._makeAspectTransitGrid(r)
             td["makePatterns"] = ""
-            td["chart_width"] = self.full_width
         else:
             td["transitRing"] = ""
-            td["degreeRing"] = self._degreeRing(r)
+            td["degreeRing"] = draw_degree_ring(r, self.c1, self.user.seventh_house.abs_pos, self.chart_colors_settings["paper_0"])
 
-            # circles
-            td["c1"] = f'cx="{r}" cy="{r}" r="{r - self.c1}"'
-            td["c1style"] = f'fill: none; stroke: {self.chart_colors_settings["zodiac_radix_ring_2"]}; stroke-width: 1px; '
-            td["c2"] = f'cx="{r}" cy="{r}" r="{r - self.c2}"'
-            td["c2style"] = f'fill: {self.chart_colors_settings["paper_1"]}; fill-opacity:.2; stroke: {self.chart_colors_settings["zodiac_radix_ring_1"]}; stroke-opacity:.4; stroke-width: 1px'
+            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["c3"] = f'cx="{r}" cy="{r}" r="{r - self.c3}"'
             td["c3style"] = f'fill: {self.chart_colors_settings["paper_1"]}; fill-opacity:.8; stroke: {self.chart_colors_settings["zodiac_radix_ring_0"]}; stroke-width: 1px'
+            
             td["makeAspects"] = self._makeAspects(r, (r - self.c3))
             td["makeAspectGrid"] = self._makeAspectGrid(r)
             td["makePatterns"] = self._makePatterns()
-            td["chart_width"] = self.natal_width
-
+        
+        td["chart_height"] = self.height
+        td["chart_width"] = self.width
         td["circleX"] = str(0)
         td["circleY"] = str(0)
         td["svgWidth"] = str(svgWidth)
@@ -1371,17 +1219,17 @@ class KerykeionChartSVG:
         td["viewbox"] = viewbox
 
         if self.chart_type == "Synastry":
-            td["stringTitle"] = f"{self.name} {self.language_settings['and_word']} {self.t_user.name}"
+            td["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}"
 
         else:
-            td["stringTitle"] = self.name
+            td["stringTitle"] = self.user.name
 
         # Tipo di carta
-        if self.chart_type == "Synastry" or self.name == "Transit":
-            td["stringName"] = f"{self.name}:"
+        if self.chart_type == "Synastry" or self.chart_type == "Transit":
+            td["stringName"] = f"{self.user.name}:"
         else:
             td["stringName"] = f'{self.language_settings["info"]}:'
 
@@ -1465,9 +1313,20 @@ class KerykeionChartSVG:
             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}"
 
         else:
-            td["stringLat"] = f"{self.language_settings['latitude']}: {self._lat2str(self.geolat)}"
-            td["stringLon"] = f"{self.language_settings['longitude']}: {self._lon2str(self.geolon)}"
-            td["stringPosition"] = f"{self.language_settings['type']}: {self.charttype}"
+            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"]
@@ -1491,48 +1350,68 @@ class KerykeionChartSVG:
         td["cfgRotate"] = rotate
         td["cfgTranslate"] = translate
 
-        # functions
-        td["makeZodiac"] = self._makeZodiac(r)
+        # ---
+        # Drawing Functions
+        #--- 
+
+        td["makeZodiac"] = self._draw_zodiac_circle_slices(r)
+        td["makeHousesGrid"] = self._draw_house_grid()
+        # TODO: Add the rest of the functions
         td["makeHouses"] = self._makeHouses(r)
         td["makePlanets"] = self._make_planets(r)
-        td["makeElements"] = self._makeElements(r)
+        td["elements_percentages"] = draw_elements_percentages(
+            self.language_settings['fire'],
+            self.fire,
+            self.language_settings['earth'],
+            self.earth,
+            self.language_settings['air'],
+            self.air,
+            self.language_settings['water'],
+            self.water,
+        )
         td["makePlanetGrid"] = self._makePlanetGrid()
-        td["makeHousesGrid"] = self._makeHousesGrid()
 
         return td
 
-    def makeTemplate(self):
+    def makeTemplate(self, minify: bool = False) -> str:
         """Creates the template for the SVG file"""
         td = self._createTemplateDictionary()
 
         # read template
-        with open(self.xml_svg, "r", encoding="utf-8", errors="ignore") as output_file:
-            f = open(self.xml_svg)
+        with open(self.xml_svg, "r", encoding="utf-8", errors="ignore") as f:
             template = Template(f.read()).substitute(td)
 
         # return filename
 
-        logger.debug(f"Template dictionary keys: {td.keys()}")
+        logging.debug(f"Template dictionary keys: {td.keys()}")
 
         self._createTemplateDictionary()
-        return template.replace('"', "'")
 
-    def makeSVG(self):
+        if minify:
+            template = scourString(template).replace('"', "'").replace("\n", "").replace("\t","").replace("    ", "").replace("  ", "")
+
+        else:
+            template = template.replace('"', "'")
+
+        return template
+
+    def makeSVG(self, minify: bool = False):
         """Prints out the SVG file in the specifide folder"""
 
         if not (self.template):
-            self.template = self.makeTemplate()
+            self.template = self.makeTemplate(minify)
 
-        self.chartname = self.output_directory / f"{self.name}{self.chart_type}Chart.svg"
+        self.chartname = self.output_directory / f"{self.user.name}{self.chart_type}Chart.svg"
 
         with open(self.chartname, "w", encoding="utf-8", errors="ignore") as output_file:
             output_file.write(self.template)
 
-        return print(f"SVG Generated Correctly in: {self.chartname}")
+        logging.info(f"SVG Generated Correctly in: {self.chartname}")
 
 
 if __name__ == "__main__":
-    basicConfig(level="DEBUG", force=True)
+    from kerykeion.utilities import setup_logging
+    setup_logging(level="debug")
 
     first = AstrologicalSubject("John Lennon", 1940, 10, 9, 10, 30, "Liverpool", "GB")
     second = AstrologicalSubject("Paul McCartney", 1942, 6, 18, 15, 30, "Liverpool", "GB")
@@ -1547,8 +1426,9 @@ if __name__ == "__main__":
 
     # Synastry Chart
     synastry_chart = KerykeionChartSVG(first, "Synastry", second)
-    synastry_chart.makeSVG()
+    synastry_chart.makeSVG(minify=True)
 
     # Transits Chart
     transits_chart = KerykeionChartSVG(first, "Transit", second)
-    transits_chart.makeSVG()
+    transits_chart.makeSVG(minify=True)
+