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

kerykeion/astrological_subject.py

@@ -20,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,
@@ -34,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"
@@ -101,12 +103,12 @@ class AstrologicalSubject:
     day: int
     hour: int
     minute: int
-    city: Union[str, None]
-    nation: Union[str, None]
-    lng: Union[int, float, None]
-    lat: Union[int, float, None]
-    tz_str: Union[str, None]
-    geonames_username: Union[str, None]
+    city: str
+    nation: str
+    lng: Union[int, float]
+    lat: Union[int, float]
+    tz_str: str
+    geonames_username: str
     online: bool
     zodiac_type: ZodiacType
     sidereal_mode: Union[SiderealMode, None]
@@ -136,7 +138,7 @@ class AstrologicalSubject:
     true_node: KerykeionPointModel
     mean_node: KerykeionPointModel
     chiron: Union[KerykeionPointModel, None]
-    mean_lilit: Union[KerykeionPointModel, None]
+    mean_lilith: Union[KerykeionPointModel, None]
 
     # Houses
     first_house: KerykeionPointModel
@@ -153,15 +155,16 @@ 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: bool # Deprecated
+    disable_chiron: Union[None, bool]
     disable_chiron_and_lilith: bool
 
+    planets_names_list: list[Planet]
+    houses_names_list: list[Houses]
+
     def __init__(
         self,
         name="Now",
@@ -178,7 +181,7 @@ class AstrologicalSubject:
         geonames_username: Union[str, None] = None,
         zodiac_type: ZodiacType = DEFAULT_ZODIAC_TYPE,
         online: bool = True,
-        disable_chiron: Union[None, bool] = None,
+        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,
@@ -207,15 +210,9 @@ class AstrologicalSubject:
         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
@@ -227,30 +224,46 @@ class AstrologicalSubject:
         # 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(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 and not self.online:
+        # 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 and not self.online:
+        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 #
@@ -298,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
@@ -337,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
@@ -383,7 +395,7 @@ class AstrologicalSubject:
         self.lat = float(self.city_data["lat"])
         self.tz_str = self.city_data["timezonestr"]
 
-    def _houses(self) -> None:
+    def _initialize_houses(self) -> None:
         """
         Calculate positions and store them in dictionaries
 
@@ -418,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),
@@ -426,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)
@@ -435,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,
@@ -463,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]
@@ -480,79 +497,34 @@ class AstrologicalSubject:
         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]
 
-        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_and_lilith:
-            chiron_deg = swe.calc(self.julian_day, 15, self._iflag)[0][0]
-            self.planets_degrees_ut.append(chiron_deg)
-
-            mean_lilith_deg = swe.calc(self.julian_day, 12, self._iflag)[0][0]
-            self.planets_degrees_ut.append(mean_lilith_deg)
-
-        else:
-            self.chiron = None
-            self.mean_lilith = None
-
-
-    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_and_lilith:
-            self.chiron = calculate_position(self.planets_degrees_ut[12], "Chiron", point_type=point_type)
-            self.mean_lilith = calculate_position(self.planets_degrees_ut[13], "Mean_Lilith", point_type=point_type)
-
-        else:
-            self.chiron = None
-            self.mean_lilith = 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)
-
-        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,
@@ -566,91 +538,70 @@ class AstrologicalSubject:
             self.mean_node,
             self.true_node,
         ]
-        
+
         if not self.disable_chiron_and_lilith:
-            self.chiron.house = get_planet_house(self.planets_degrees_ut[12], self.houses_degree_ut)
-            self.planets_list.append(self.chiron)
+            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.mean_lilith.house = get_planet_house(self.planets_degrees_ut[13], self.houses_degree_ut)
-            self.planets_list.append(self.mean_lilith)
+            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,
@@ -659,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:
@@ -860,3 +812,7 @@ if __name__ == "__main__":
     # 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))