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

kerykeion/astrological_subject.py

@@ -6,6 +6,7 @@
 import pytz
 import swisseph as swe
 import logging
+import warnings
 
 from datetime import datetime
 from functools import cached_property
@@ -19,11 +20,13 @@ from kerykeion.kr_types import (
     PointType,
     SiderealMode,
     HousesSystemIdentifier,
-    PerspectiveType
+    PerspectiveType,
+    Planet,
+    Houses
 )
 from kerykeion.utilities import (
     get_number_from_name, 
-    calculate_position, 
+    get_kerykeion_point_from_degree, 
     get_planet_house,
     get_moon_emoji_from_phase_int,
     get_moon_phase_name_from_phase_int,
@@ -33,10 +36,10 @@ from pathlib import Path
 from typing import Union, get_args
 
 DEFAULT_GEONAMES_USERNAME = "century.boy"
-DEFAULT_SIDEREAL_MODE = "FAGAN_BRADLEY"
-DEFAULT_HOUSES_SYSTEM_IDENTIFIER = "P"
-DEFAULT_ZODIAC_TYPE = "Tropic"
-DEFAULT_PERSPECTIVE_TYPE = "Apparent Geocentric"
+DEFAULT_SIDEREAL_MODE: SiderealMode = "FAGAN_BRADLEY"
+DEFAULT_HOUSES_SYSTEM_IDENTIFIER: HousesSystemIdentifier = "P"
+DEFAULT_ZODIAC_TYPE: ZodiacType = "Tropic"
+DEFAULT_PERSPECTIVE_TYPE: PerspectiveType = "Apparent Geocentric"
 GEONAMES_DEFAULT_USERNAME_WARNING = (
     "\n********\n"
     "NO GEONAMES USERNAME SET!\n"
@@ -75,8 +78,7 @@ class AstrologicalSubject:
         You can get one for free here: https://www.geonames.org/login
     - online (bool, optional): Sets if you want to use the online mode, which fetches the timezone and coordinates from geonames.
         If you already have the coordinates and timezone, set this to False. Defaults to True.
-    - disable_chiron (bool, optional): Disables the calculation of Chiron. Defaults to False.
-        Chiron calculation can create some issues with the Swiss Ephemeris when the date is too far in the past.
+    - disable_chiron: Deprecated, use disable_chiron_and_lilith instead.
     - sidereal_mode (SiderealMode, optional): Also known as Ayanamsa. 
         The mode to use for the sidereal zodiac, according to the Swiss Ephemeris.
         Defaults to "FAGAN_BRADLEY".
@@ -87,6 +89,11 @@ class AstrologicalSubject:
     - perspective_type (PerspectiveType, optional): The perspective to use for the calculation of the chart.
         Defaults to "Apparent Geocentric".
         Available perspectives are visible in the PerspectiveType Literal.
+    - is_dst (Union[None, bool], optional): Specify if the time is in DST. Defaults to None.
+        By default (None), the library will try to guess if the time is in DST or not and raise an AmbiguousTimeError
+        if it can't guess. If you know the time is in DST, set this to True, if you know it's not, set it to False.
+    - disable_chiron_and_lilith (bool, optional): boolean representing if Chiron and Lilith should be disabled. Default is False.
+        Chiron calculation can create some issues with the Swiss Ephemeris when the date is too far in the past.
     """
 
     # Defined by the user
@@ -104,10 +111,11 @@ class AstrologicalSubject:
     geonames_username: str
     online: bool
     zodiac_type: ZodiacType
-    sidereal_mode: SiderealMode
+    sidereal_mode: Union[SiderealMode, None]
     houses_system_identifier: HousesSystemIdentifier
     houses_system_name: str
     perspective_type: PerspectiveType
+    is_dst: Union[None, bool]
 
     # Generated internally
     city_data: dict[str, str]
@@ -130,6 +138,7 @@ class AstrologicalSubject:
     true_node: KerykeionPointModel
     mean_node: KerykeionPointModel
     chiron: Union[KerykeionPointModel, None]
+    mean_lilith: Union[KerykeionPointModel, None]
 
     # Houses
     first_house: KerykeionPointModel
@@ -146,10 +155,15 @@ class AstrologicalSubject:
     twelfth_house: KerykeionPointModel
 
     # Lists
-    houses_list: list[KerykeionPointModel]
-    planets_list: list[KerykeionPointModel]
-    planets_degrees_ut: list[float]
-    houses_degree_ut: list[float]
+    _houses_list: list[KerykeionPointModel]
+    _houses_degree_ut: list[float]
+
+    # Enable or disable features
+    disable_chiron: Union[None, bool]
+    disable_chiron_and_lilith: bool
+
+    planets_names_list: list[Planet]
+    houses_names_list: list[Houses]
 
     def __init__(
         self,
@@ -167,63 +181,89 @@ class AstrologicalSubject:
         geonames_username: Union[str, None] = None,
         zodiac_type: ZodiacType = DEFAULT_ZODIAC_TYPE,
         online: bool = True,
-        disable_chiron: bool = False,
+        disable_chiron: Union[None, bool] = None, # Deprecated
         sidereal_mode: Union[SiderealMode, None] = None,
         houses_system_identifier: HousesSystemIdentifier = DEFAULT_HOUSES_SYSTEM_IDENTIFIER,
-        perspective_type: PerspectiveType = DEFAULT_PERSPECTIVE_TYPE
+        perspective_type: PerspectiveType = DEFAULT_PERSPECTIVE_TYPE,
+        is_dst: Union[None, bool] = None,
+        disable_chiron_and_lilith: bool = False
     ) -> None:
         logging.debug("Starting Kerykeion")
 
+        # Deprecation warnings --->
+        if disable_chiron is not None:
+            warnings.warn(
+                "The 'disable_chiron' argument is deprecated and will be removed in a future version. "
+                "Please use 'disable_chiron' instead.",
+                DeprecationWarning
+            )
+            
+            if disable_chiron_and_lilith:
+                raise ValueError("Cannot specify both 'disable_chiron' and 'disable_chiron_and_lilith'. Use 'disable_chiron_and_lilith' only.")
+        
+            self.disable_chiron_and_lilith = disable_chiron
+        # <--- Deprecation warnings
+
         self.name = name
         self.year = year
         self.month = month
         self.day = day
         self.hour = hour
         self.minute = minute
-        self.city = city
-        self.nation = nation
-        self.lng = lng
-        self.lat = lat
-        self.tz_str = tz_str
         self.zodiac_type = zodiac_type
         self.online = online
         self.json_dir = Path.home()
-        self.geonames_username = geonames_username
         self.disable_chiron = disable_chiron
         self.sidereal_mode = sidereal_mode
         self.houses_system_identifier = houses_system_identifier
         self.perspective_type = perspective_type
+        self.is_dst = is_dst
+        self.disable_chiron_and_lilith = disable_chiron_and_lilith
 
         #---------------#
         # General setup #
         #---------------#
 
-        # This message is set to encourage the user to set a custom geonames username
+        # Geonames username
         if geonames_username is None and online:
-            logging.warning(
-
-            )
-
+            logging.warning(GEONAMES_DEFAULT_USERNAME_WARNING)
             self.geonames_username = DEFAULT_GEONAMES_USERNAME
+        else:
+            self.geonames_username = geonames_username # type: ignore
 
-        if not self.city:
+        # City
+        if not city:
             self.city = "London"
             logging.info("No city specified, using London as default")
+        else:
+            self.city = city
 
-        if not self.nation:
+        # Nation
+        if not nation:
             self.nation = "GB"
             logging.info("No nation specified, using GB as default")
+        else:
+            self.nation = nation
 
-        if not self.lat:
+        # Latitude
+        if not lat and not self.online:
             self.lat = 51.5074
             logging.info("No latitude specified, using London as default")
-
-        if not self.lng:
+        else:
+            self.lat = lat # type: ignore
+ 
+        # Longitude
+        if not lng and not self.online:
             self.lng = 0
             logging.info("No longitude specified, using London as default")
+        else:
+            self.lng = lng # type: ignore
 
+        # Timezone
         if (not self.online) and (not tz_str):
             raise KerykeionException("You need to set the coordinates and timezone if you want to use the offline mode!")
+        else:
+            self.tz_str = tz_str # type: ignore
 
         #-----------------------#
         # Swiss Ephemeris setup #
@@ -246,6 +286,8 @@ class AstrologicalSubject:
         elif self.perspective_type == "Topocentric":
             self._iflag += swe.FLG_TOPOCTR
             # geopos_is_set, for topocentric
+            if (self.online) and (not self.tz_str) and (not self.lat) and (not self.lng):
+                self._fetch_and_set_tz_and_coordinates_from_geonames()
             swe.set_topo(self.lng, self.lat, 0)
         # <--- Chart Perspective check and setup
 
@@ -269,7 +311,8 @@ class AstrologicalSubject:
 
         if self.zodiac_type == "Sidereal":
             # Check if the sidereal mode is valid
-            if not self.sidereal_mode in get_args(SiderealMode):
+            
+            if not self.sidereal_mode or not self.sidereal_mode in get_args(SiderealMode):
                 raise KerykeionException(f"\n* ERROR: '{self.sidereal_mode}' is NOT a valid sidereal mode! Available modes are: *" + "\n" + str(get_args(SiderealMode)))
 
             self._iflag += swe.FLG_SIDEREAL
@@ -281,17 +324,22 @@ class AstrologicalSubject:
         #------------------------#
         # Start the calculations #
         #------------------------#
-        
-        check_and_adjust_polar_latitude(self.lat, self.lng)
 
         # UTC, julian day and local time setup --->
-        if (self.online) and (not self.tz_str):
-            self._fetch_tz_from_geonames()
+        if (self.online) and (not self.tz_str) and (not self.lat) and (not self.lng):
+            self._fetch_and_set_tz_and_coordinates_from_geonames()
+        
+        self.lat = check_and_adjust_polar_latitude(self.lat)
 
         # Local time to UTC
         local_time = pytz.timezone(self.tz_str)
         naive_datetime = datetime(self.year, self.month, self.day, self.hour, self.minute, 0)
-        local_datetime = local_time.localize(naive_datetime, is_dst=None)
+
+        try:
+            local_datetime = local_time.localize(naive_datetime, is_dst=self.is_dst)
+        except pytz.exceptions.AmbiguousTimeError:
+            raise KerykeionException("Ambiguous time! Please specify if the time is in DST or not with the is_dst argument.")
+
         utc_object = local_datetime.astimezone(pytz.utc)
         self.iso_formatted_utc_datetime = utc_object.isoformat()
 
@@ -303,11 +351,9 @@ class AstrologicalSubject:
         self.julian_day = float(swe.julday(utc_object.year, utc_object.month, utc_object.day, utc_float_hour_with_minutes))
         # <--- UTC, julian day and local time setup
 
-        self._planets_degrees_lister()
-        self._planets()
-        self._houses()
-        self._planets_in_houses()
-        self._lunar_phase_calc()
+        self._initialize_houses()
+        self._initialize_planets()
+        self._initialize_moon_phase()
 
         # Deprecated properties
         self.utc_time
@@ -325,7 +371,7 @@ class AstrologicalSubject:
     def get(self, item, default=None):
         return getattr(self, item, default)
 
-    def _fetch_tz_from_geonames(self) -> None:
+    def _fetch_and_set_tz_and_coordinates_from_geonames(self) -> None:
         """Gets the nearest time zone for the calculation"""
         logging.info("Fetching timezone/coordinates from geonames")
 
@@ -349,9 +395,7 @@ class AstrologicalSubject:
         self.lat = float(self.city_data["lat"])
         self.tz_str = self.city_data["timezonestr"]
 
-        check_and_adjust_polar_latitude(self.lat, self.lng)
-
-    def _houses(self) -> None:
+    def _initialize_houses(self) -> None:
         """
         Calculate positions and store them in dictionaries
 
@@ -386,7 +430,7 @@ class AstrologicalSubject:
         """
 
         if self.zodiac_type == "Sidereal":
-            self.houses_degree_ut = swe.houses_ex(
+            self._houses_degree_ut = swe.houses_ex(
                 tjdut=self.julian_day,
                 lat=self.lat, lon=self.lng,
                 hsys=str.encode(self.houses_system_identifier),
@@ -394,7 +438,7 @@ class AstrologicalSubject:
             )[0]
 
         elif self.zodiac_type == "Tropic":
-            self.houses_degree_ut = swe.houses(
+            self._houses_degree_ut = swe.houses(
                 tjdut=self.julian_day, lat=self.lat,
                 lon=self.lng,
                 hsys=str.encode(self.houses_system_identifier)
@@ -403,20 +447,23 @@ class AstrologicalSubject:
         point_type: PointType = "House"
 
         # stores the house in singular dictionaries.
-        self.first_house = calculate_position(self.houses_degree_ut[0], "First_House", point_type=point_type)
-        self.second_house = calculate_position(self.houses_degree_ut[1], "Second_House", point_type=point_type)
-        self.third_house = calculate_position(self.houses_degree_ut[2], "Third_House", point_type=point_type)
-        self.fourth_house = calculate_position(self.houses_degree_ut[3], "Fourth_House", point_type=point_type)
-        self.fifth_house = calculate_position(self.houses_degree_ut[4], "Fifth_House", point_type=point_type)
-        self.sixth_house = calculate_position(self.houses_degree_ut[5], "Sixth_House", point_type=point_type)
-        self.seventh_house = calculate_position(self.houses_degree_ut[6], "Seventh_House", point_type=point_type)
-        self.eighth_house = calculate_position(self.houses_degree_ut[7], "Eighth_House", point_type=point_type)
-        self.ninth_house = calculate_position(self.houses_degree_ut[8], "Ninth_House", point_type=point_type)
-        self.tenth_house = calculate_position(self.houses_degree_ut[9], "Tenth_House", point_type=point_type)
-        self.eleventh_house = calculate_position(self.houses_degree_ut[10], "Eleventh_House", point_type=point_type)
-        self.twelfth_house = calculate_position(self.houses_degree_ut[11], "Twelfth_House", point_type=point_type)
-
-        self.houses_list = [
+        self.first_house = get_kerykeion_point_from_degree(self._houses_degree_ut[0], "First_House", point_type=point_type)
+        self.second_house = get_kerykeion_point_from_degree(self._houses_degree_ut[1], "Second_House", point_type=point_type)
+        self.third_house = get_kerykeion_point_from_degree(self._houses_degree_ut[2], "Third_House", point_type=point_type)
+        self.fourth_house = get_kerykeion_point_from_degree(self._houses_degree_ut[3], "Fourth_House", point_type=point_type)
+        self.fifth_house = get_kerykeion_point_from_degree(self._houses_degree_ut[4], "Fifth_House", point_type=point_type)
+        self.sixth_house = get_kerykeion_point_from_degree(self._houses_degree_ut[5], "Sixth_House", point_type=point_type)
+        self.seventh_house = get_kerykeion_point_from_degree(self._houses_degree_ut[6], "Seventh_House", point_type=point_type)
+        self.eighth_house = get_kerykeion_point_from_degree(self._houses_degree_ut[7], "Eighth_House", point_type=point_type)
+        self.ninth_house = get_kerykeion_point_from_degree(self._houses_degree_ut[8], "Ninth_House", point_type=point_type)
+        self.tenth_house = get_kerykeion_point_from_degree(self._houses_degree_ut[9], "Tenth_House", point_type=point_type)
+        self.eleventh_house = get_kerykeion_point_from_degree(self._houses_degree_ut[10], "Eleventh_House", point_type=point_type)
+        self.twelfth_house = get_kerykeion_point_from_degree(self._houses_degree_ut[11], "Twelfth_House", point_type=point_type)
+
+        self.houses_names_list = list(get_args(Houses))
+
+        # Deprecated
+        self._houses_list = [
             self.first_house,
             self.second_house,
             self.third_house,
@@ -431,10 +478,12 @@ class AstrologicalSubject:
             self.twelfth_house,
         ]
 
-    def _planets_degrees_lister(self):
-        """Sidereal or tropic mode."""
+    def _initialize_planets(self) -> None:
+        """Defines body positon in signs and information and
+        stores them in dictionaries"""
+
+        point_type: PointType = "Planet"
 
-        # Calculates the position of the planets and stores it in a list.
         sun_deg = swe.calc(self.julian_day, 0, self._iflag)[0][0]
         moon_deg = swe.calc(self.julian_day, 1, self._iflag)[0][0]
         mercury_deg = swe.calc(self.julian_day, 2, self._iflag)[0][0]
@@ -447,77 +496,35 @@ class AstrologicalSubject:
         pluto_deg = swe.calc(self.julian_day, 9, self._iflag)[0][0]
         mean_node_deg = swe.calc(self.julian_day, 10, self._iflag)[0][0]
         true_node_deg = swe.calc(self.julian_day, 11, self._iflag)[0][0]
-        
-        if not self.disable_chiron:
-            chiron_deg = swe.calc(self.julian_day, 15, self._iflag)[0][0]
-        else:
-            chiron_deg = 0
-
-        self.planets_degrees_ut = [
-            sun_deg,
-            moon_deg,
-            mercury_deg,
-            venus_deg,
-            mars_deg,
-            jupiter_deg,
-            saturn_deg,
-            uranus_deg,
-            neptune_deg,
-            pluto_deg,
-            mean_node_deg,
-            true_node_deg,
-        ]
-        
-        if not self.disable_chiron:
-            self.planets_degrees_ut.append(chiron_deg)
 
-    def _planets(self) -> None:
-        """Defines body positon in signs and information and
-        stores them in dictionaries"""
-
-        point_type: PointType = "Planet"
-        # stores the planets in singular dictionaries.
-        self.sun = calculate_position(self.planets_degrees_ut[0], "Sun", point_type=point_type)
-        self.moon = calculate_position(self.planets_degrees_ut[1], "Moon", point_type=point_type)
-        self.mercury = calculate_position(self.planets_degrees_ut[2], "Mercury", point_type=point_type)
-        self.venus = calculate_position(self.planets_degrees_ut[3], "Venus", point_type=point_type)
-        self.mars = calculate_position(self.planets_degrees_ut[4], "Mars", point_type=point_type)
-        self.jupiter = calculate_position(self.planets_degrees_ut[5], "Jupiter", point_type=point_type)
-        self.saturn = calculate_position(self.planets_degrees_ut[6], "Saturn", point_type=point_type)
-        self.uranus = calculate_position(self.planets_degrees_ut[7], "Uranus", point_type=point_type)
-        self.neptune = calculate_position(self.planets_degrees_ut[8], "Neptune", point_type=point_type)
-        self.pluto = calculate_position(self.planets_degrees_ut[9], "Pluto", point_type=point_type)
-        self.mean_node = calculate_position(self.planets_degrees_ut[10], "Mean_Node", point_type=point_type)
-        self.true_node = calculate_position(self.planets_degrees_ut[11], "True_Node", point_type=point_type)
-        
-        if not self.disable_chiron:
-            self.chiron = calculate_position(self.planets_degrees_ut[12], "Chiron", point_type=point_type)
-        else:
-            self.chiron = None
-
-    def _planets_in_houses(self) -> None:
-        """Calculates the house of the planet and updates
-        the planets dictionary."""
-
-        self.sun.house = get_planet_house(self.planets_degrees_ut[0], self.houses_degree_ut)
-        self.moon.house = get_planet_house(self.planets_degrees_ut[1], self.houses_degree_ut)
-        self.mercury.house = get_planet_house(self.planets_degrees_ut[2], self.houses_degree_ut)
-        self.venus.house = get_planet_house(self.planets_degrees_ut[3], self.houses_degree_ut)
-        self.mars.house = get_planet_house(self.planets_degrees_ut[4], self.houses_degree_ut)
-        self.jupiter.house = get_planet_house(self.planets_degrees_ut[5], self.houses_degree_ut)
-        self.saturn.house = get_planet_house(self.planets_degrees_ut[6], self.houses_degree_ut)
-        self.uranus.house = get_planet_house(self.planets_degrees_ut[7], self.houses_degree_ut)
-        self.neptune.house = get_planet_house(self.planets_degrees_ut[8], self.houses_degree_ut)
-        self.pluto.house = get_planet_house(self.planets_degrees_ut[9], self.houses_degree_ut)
-        self.mean_node.house = get_planet_house(self.planets_degrees_ut[10], self.houses_degree_ut)
-        self.true_node.house = get_planet_house(self.planets_degrees_ut[11], self.houses_degree_ut)
-
-        if not self.disable_chiron:
-            self.chiron.house = get_planet_house(self.planets_degrees_ut[12], self.houses_degree_ut)
-        else:
-            self.chiron = None
-
-        self.planets_list = [
+        self.sun = get_kerykeion_point_from_degree(sun_deg, "Sun", point_type=point_type)
+        self.moon = get_kerykeion_point_from_degree(moon_deg, "Moon", point_type=point_type)
+        self.mercury = get_kerykeion_point_from_degree(mercury_deg, "Mercury", point_type=point_type)
+        self.venus = get_kerykeion_point_from_degree(venus_deg, "Venus", point_type=point_type)
+        self.mars = get_kerykeion_point_from_degree(mars_deg, "Mars", point_type=point_type)
+        self.jupiter = get_kerykeion_point_from_degree(jupiter_deg, "Jupiter", point_type=point_type)
+        self.saturn = get_kerykeion_point_from_degree(saturn_deg, "Saturn", point_type=point_type)
+        self.uranus = get_kerykeion_point_from_degree(uranus_deg, "Uranus", point_type=point_type)
+        self.neptune = get_kerykeion_point_from_degree(neptune_deg, "Neptune", point_type=point_type)
+        self.pluto = get_kerykeion_point_from_degree(pluto_deg, "Pluto", point_type=point_type)
+        self.mean_node = get_kerykeion_point_from_degree(mean_node_deg, "Mean_Node", point_type=point_type)
+        self.true_node = get_kerykeion_point_from_degree(true_node_deg, "True_Node", point_type=point_type)
+
+        self.sun.house = get_planet_house(sun_deg, self._houses_degree_ut)
+        self.moon.house = get_planet_house(moon_deg, self._houses_degree_ut)
+        self.mercury.house = get_planet_house(mercury_deg, self._houses_degree_ut)
+        self.venus.house = get_planet_house(venus_deg, self._houses_degree_ut)
+        self.mars.house = get_planet_house(mars_deg, self._houses_degree_ut)
+        self.jupiter.house = get_planet_house(jupiter_deg, self._houses_degree_ut)
+        self.saturn.house = get_planet_house(saturn_deg, self._houses_degree_ut)
+        self.uranus.house = get_planet_house(uranus_deg, self._houses_degree_ut)
+        self.neptune.house = get_planet_house(neptune_deg, self._houses_degree_ut)
+        self.pluto.house = get_planet_house(pluto_deg, self._houses_degree_ut)
+        self.mean_node.house = get_planet_house(mean_node_deg, self._houses_degree_ut)
+        self.true_node.house = get_planet_house(true_node_deg, self._houses_degree_ut)
+
+        # Deprecated
+        planets_list = [
             self.sun,
             self.moon,
             self.mercury,
@@ -531,83 +538,70 @@ class AstrologicalSubject:
             self.mean_node,
             self.true_node,
         ]
-        
-        if not self.disable_chiron:
-            self.planets_list.append(self.chiron)
+
+        if not self.disable_chiron_and_lilith:
+            chiron_deg = swe.calc(self.julian_day, 15, self._iflag)[0][0]
+            mean_lilith_deg = swe.calc(self.julian_day, 12, self._iflag)[0][0]
+
+            self.chiron = get_kerykeion_point_from_degree(chiron_deg, "Chiron", point_type=point_type)
+            self.mean_lilith = get_kerykeion_point_from_degree(mean_lilith_deg, "Mean_Lilith", point_type=point_type)
+
+            self.chiron.house = get_planet_house(chiron_deg, self._houses_degree_ut)
+            self.mean_lilith.house = get_planet_house(mean_lilith_deg, self._houses_degree_ut)
+
+            # Deprecated
+            planets_list.append(self.chiron)
+            planets_list.append(self.mean_lilith)
+
+        else:
+            self.chiron = None
+            self.mean_lilith = None
+
+        # FIXME: Update after removing planets_list
+        self.planets_names_list = [planet["name"] for planet in planets_list]
 
         # Check in retrograde or not:
-        planets_ret = []
-        for planet in self.planets_list:
+        for planet in planets_list:
             planet_number = get_number_from_name(planet["name"])
             if swe.calc(self.julian_day, planet_number, self._iflag)[0][3] < 0:
                 planet["retrograde"] = True
             else:
                 planet["retrograde"] = False
-            planets_ret.append(planet)
 
-    def _lunar_phase_calc(self) -> None:
-        """Function to calculate the lunar phase"""
 
-        # If ther's an error:
-        moon_phase, sun_phase = None, None
+    def _initialize_moon_phase(self) -> None:
+        """
+        Calculate and initialize the lunar phase based on the positions of the moon and sun.
 
-        # anti-clockwise degrees between sun and moon
-        moon, sun = self.planets_degrees_ut[1], self.planets_degrees_ut[0]
-        degrees_between = moon - sun
+        This function calculates the degrees between the moon and the sun, determines the moon phase
+        and sun phase, and initializes the lunar phase model with the calculated values.
+        """
+        # Initialize moon_phase and sun_phase to None in case of an error
+        moon_phase, sun_phase = None, None
 
-        if degrees_between < 0:
-            degrees_between += 360.0
+        # Calculate the anti-clockwise degrees between the sun and moon
+        moon, sun = self.moon.abs_pos, self.sun.abs_pos
+        degrees_between = (moon - sun) % 360
 
+        # Calculate the moon phase (1-28) based on the degrees between the sun and moon
         step = 360.0 / 28.0
+        moon_phase = int(degrees_between // step) + 1
 
-        for x in range(28):
-            low = x * step
-            high = (x + 1) * step
-
-            if degrees_between >= low and degrees_between < high:
-                moon_phase = x + 1
-
+        # Define the sun phase steps
         sunstep = [
-            0,
-            30,
-            40,
-            50,
-            60,
-            70,
-            80,
-            90,
-            120,
-            130,
-            140,
-            150,
-            160,
-            170,
-            180,
-            210,
-            220,
-            230,
-            240,
-            250,
-            260,
-            270,
-            300,
-            310,
-            320,
-            330,
-            340,
-            350,
+            0, 30, 40, 50, 60, 70, 80, 90, 120, 130, 140, 150, 160, 170, 180,
+            210, 220, 230, 240, 250, 260, 270, 300, 310, 320, 330, 340, 350
         ]
 
+        # Calculate the sun phase (1-28) based on the degrees between the sun and moon
         for x in range(len(sunstep)):
             low = sunstep[x]
-
-            if x == 27:
-                high = 360
-            else:
-                high = sunstep[x + 1]
-            if degrees_between >= low and degrees_between < high:
+            high = sunstep[x + 1] if x < len(sunstep) - 1 else 360
+            if low <= degrees_between < high:
                 sun_phase = x + 1
+                break
 
+        # Create a dictionary with the lunar phase information
         lunar_phase_dictionary = {
             "degrees_between_s_m": degrees_between,
             "moon_phase": moon_phase,
@@ -616,6 +610,7 @@ class AstrologicalSubject:
             "moon_phase_name": get_moon_phase_name_from_phase_int(moon_phase)
         }
 
+        # Initialize the lunar phase model with the calculated values
         self.lunar_phase = LunarPhaseModel(**lunar_phase_dictionary)
 
     def json(self, dump=False, destination_folder: Union[str, None] = None, indent: Union[int, None] = None) -> str:
@@ -698,7 +693,7 @@ class AstrologicalSubject:
         lat: Union[int, float] = 51.5074,
         geonames_username: str = DEFAULT_GEONAMES_USERNAME,
         zodiac_type: ZodiacType = DEFAULT_ZODIAC_TYPE,
-        disable_chiron: bool = False,
+        disable_chiron_and_lilith: bool = False,
         sidereal_mode: Union[SiderealMode, None] = None,
         houses_system_identifier: HousesSystemIdentifier = DEFAULT_HOUSES_SYSTEM_IDENTIFIER,
         perspective_type: PerspectiveType = DEFAULT_PERSPECTIVE_TYPE
@@ -721,7 +716,7 @@ class AstrologicalSubject:
         - geonames_username (str, optional): The username for the geonames API. Note: Change this to your own username to avoid rate limits!
             You can get one for free here: https://www.geonames.org/login
         - zodiac_type (ZodiacType, optional): The zodiac type to use. Defaults to "Tropic".
-        - disable_chiron (bool, optional): Disables the calculation of Chiron. Defaults to False.
+        - disable_chiron_and_lilith: boolean representing if Chiron and Lilith should be disabled. Default is False.
             Chiron calculation can create some issues with the Swiss Ephemeris when the date is too far in the past.
         - sidereal_mode (SiderealMode, optional): Also known as Ayanamsa.
             The mode to use for the sidereal zodiac, according to the Swiss Ephemeris.
@@ -767,10 +762,10 @@ class AstrologicalSubject:
             online=False,
             geonames_username=geonames_username,
             zodiac_type=zodiac_type,
-            disable_chiron=disable_chiron,
             sidereal_mode=sidereal_mode,
             houses_system_identifier=houses_system_identifier,
-            perspective_type=perspective_type
+            perspective_type=perspective_type,
+            disable_chiron_and_lilith=disable_chiron_and_lilith
         )
 
         return subject
@@ -812,4 +807,12 @@ if __name__ == "__main__":
     print(johnny.json(dump=True, indent=2))
 
     # With Topocentric Perspective
-    johnny = AstrologicalSubject("Johnny Depp", 1963, 6, 9, 0, 0, "Owensboro", "US", perspective_type="Topocentric")
+    johnny = AstrologicalSubject("Johnny Depp", 1963, 6, 9, 0, 0, "Owensboro", "US", perspective_type="Topocentric")
+
+    # Test Mean Lilith
+    johnny = AstrologicalSubject("Johnny Depp", 1963, 6, 9, 0, 0, "Owensboro", "US", disable_chiron_and_lilith=True)
+    print(johnny.mean_lilith)
+
+    # Offline mode
+    johnny = AstrologicalSubject("Johnny Depp", 1963, 6, 9, 0, 0, "Owensboro", "US", online=False, tz_str="America/New_York", lng=-87.1111, lat=37.7711)
+    print(johnny.json(dump=True, indent=2))