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

kerykeion/astrological_subject.py

@@ -1,14 +1,13 @@
 # -*- coding: utf-8 -*-
 """
-    This is part of Kerykeion (C) 2023 Giacomo Battaglia
+    This is part of Kerykeion (C) 2024 Giacomo Battaglia
 """
 
-import math
 import pytz
 import swisseph as swe
+import logging
 
 from datetime import datetime
-from logging import getLogger, basicConfig
 from kerykeion.fetch_geonames import FetchGeonames
 from kerykeion.kr_types import (
     KerykeionException,
@@ -17,16 +16,17 @@ from kerykeion.kr_types import (
     LunarPhaseModel,
     KerykeionPointModel,
 )
-from kerykeion.utilities import get_number_from_name, calculate_position
+from kerykeion.utilities import (
+    get_number_from_name, 
+    calculate_position, 
+    get_planet_house,
+    get_moon_emoji_from_phase_int,
+    get_moon_phase_name_from_phase_int,
+)
 from pathlib import Path
 from typing import Union, Literal
 
-
-logger = getLogger(__name__)
-basicConfig(
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    level="INFO"
-)
+DEFAULT_GEONAMES_USERNAME = "century.boy"
 
 
 class AstrologicalSubject:
@@ -50,14 +50,19 @@ class AstrologicalSubject:
     - lng (Union[int, float], optional): _ Defaults to False.
     - lat (Union[int, float], optional): _ Defaults to False.
     - tz_str (Union[str, bool], optional): _ Defaults to False.
-    - logger (Union[Logger, None], optional): _ Defaults to None.
     - geonames_username (str, optional): _ Defaults to 'century.boy'.
     - online (bool, optional): Sets if you want to use the online mode (using
         geonames) or not. Defaults to True.
+    - utc_datetime (datetime, optional): An alternative way of constructing the object, 
+        if you know the UTC datetime but do not have easy access to e.g. timezone identifier
+        _ Defaults to None.
+    - 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.
     """
 
     # Defined by the user
     name: str
+    utc_datetime: Union[datetime, None]
     year: int
     month: int
     day: int
@@ -93,7 +98,7 @@ class AstrologicalSubject:
     pluto: KerykeionPointModel
     true_node: KerykeionPointModel
     mean_node: KerykeionPointModel
-    chiron: KerykeionPointModel
+    chiron: Union[KerykeionPointModel, None]
 
     # Houses
     first_house: KerykeionPointModel
@@ -110,14 +115,13 @@ class AstrologicalSubject:
     twelfth_house: KerykeionPointModel
 
     # Lists
-    houses: list[KerykeionPointModel]
-    planets: list[KerykeionPointModel]
+    houses_list: list[KerykeionPointModel]
+    planets_list: list[KerykeionPointModel]
     planets_degrees_ut: list[float]
     houses_degree_ut: list[float]
 
     now = datetime.now()
 
-
     def __init__(
         self,
         name="Now",
@@ -126,16 +130,18 @@ class AstrologicalSubject:
         day: int = now.day,
         hour: int = now.hour,
         minute: int = now.minute,
-        city: str = "",
-        nation: str = "",
-        lng: Union[int, float] = 0,
-        lat: Union[int, float] = 0,
-        tz_str: str = "",
-        geonames_username: str = "century.boy",
+        city: Union[str, None] = None,
+        nation: Union[str, None] = None,
+        lng: Union[int, float, None] = None,
+        lat: Union[int, float, None] = None,
+        tz_str: Union[str, None] = None,
+        geonames_username: Union[str, None] = None,
         zodiac_type: ZodiacType = "Tropic",
         online: bool = True,
+        utc_datetime: Union[datetime, None] = None,
+        disable_chiron: bool = False
     ) -> None:
-        logger.debug("Starting Kerykeion")
+        logging.debug("Starting Kerykeion")
 
         # We set the swisseph path to the current directory
         swe.set_ephe_path(
@@ -144,7 +150,6 @@ class AstrologicalSubject:
             )
         )
 
-
         self.name = name
         self.year = year
         self.month = month
@@ -156,24 +161,57 @@ class AstrologicalSubject:
         self.lng = lng
         self.lat = lat
         self.tz_str = tz_str
-        self._geonames_username = geonames_username
         self.zodiac_type = zodiac_type
         self.online = online
         self.json_dir = Path.home()
+        self.geonames_username = geonames_username
+        self.utc_datetime = utc_datetime
+        self.disable_chiron = disable_chiron
+
+        # This message is set to encourage the user to set a custom geonames username
+        if geonames_username is None and online:
+            logging.warning(
+                "\n"
+                "********" +
+                "\n" +
+                "NO GEONAMES USERNAME SET!" +
+                "\n" +
+                "Using the default geonames username is not recommended, please set a custom one!" +
+                "\n" +
+                "You can get one for free here:" +
+                "\n" +
+                "https://www.geonames.org/login" +
+                "\n" +
+                "Keep in mind that the default username is limited to 2000 requests per hour and is shared with everyone else using this library." +
+                "\n" +
+                "********"
+            )
+
+            self.geonames_username = DEFAULT_GEONAMES_USERNAME
 
         if not self.city:
             self.city = "London"
-            logger.warning("No city specified, using London as default")
+            logging.info("No city specified, using London as default")
 
         if not self.nation:
             self.nation = "GB"
-            logger.warning("No nation specified, using GB as default")
+            logging.info("No nation specified, using GB as default")
+
+        if not self.lat:
+            self.lat = 51.5074
+            logging.info("No latitude specified, using London as default")
 
-        if (not self.online) and (not lng or not lat or not tz_str):
+        if not self.lng:
+            self.lng = 0
+            logging.info("No longitude specified, using London as default")
+
+        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!"
             )
 
+        self._check_if_poles()
+
         # Initialize everything
         self._get_utc()
         self._get_jd()
@@ -190,14 +228,20 @@ class AstrologicalSubject:
     def __repr__(self) -> str:
         return f"Astrological data for: {self.name}, {self.utc} UTC\nBirth location: {self.city}, Lat {self.lat}, Lon {self.lng}"
 
+    def __getitem__(self, item):
+        return getattr(self, item)
+
+    def get(self, item, default=None):
+        return getattr(self, item, default)
+
     def _fetch_tz_from_geonames(self) -> None:
         """Gets the nearest time zone for the calculation"""
-        logger.debug("Conneting to Geonames...")
+        logging.info("Fetching timezone/coordinates from geonames")
 
         geonames = FetchGeonames(
             self.city,
             self.nation,
-            username=self._geonames_username,
+            username=self.geonames_username,
         )
         self.city_data: dict[str, str] = geonames.get_serialized_data()
 
@@ -214,21 +258,20 @@ class AstrologicalSubject:
         self.lat = float(self.city_data["lat"])
         self.tz_str = self.city_data["timezonestr"]
 
-        if self.lat > 66.0:
-            self.lat = 66.0
-            logger.info("Polar circle override for houses, using 66 degrees")
-
-        elif self.lat < -66.0:
-            self.lat = -66.0
-            logger.info("Polar circle override for houses, using -66 degrees")
+        self._check_if_poles()
 
     def _get_utc(self) -> None:
         """Converts local time to utc time."""
 
         # If the coordinates are not set, get them from geonames.
-        if (self.online) and (not self.tz_str or not self.lng or not self.lat):
+        if (self.online) and (not self.tz_str):
             self._fetch_tz_from_geonames()
 
+        # If UTC datetime is provided, then use it directly
+        if (self.utc_datetime):
+            self.utc = self.utc_datetime
+            return
+
         local_time = pytz.timezone(self.tz_str)
 
         naive_datetime = datetime(self.year, self.month, self.day, self.hour, self.minute, 0)
@@ -243,7 +286,50 @@ class AstrologicalSubject:
         self.julian_day = float(swe.julday(self.utc.year, self.utc.month, self.utc.day, self.utc_time))
 
     def _houses(self) -> None:
-        """Calculate positions and store them in dictionaries"""
+        """
+        Calculate positions and store them in dictionaries
+
+        https://www.astro.com/faq/fq_fh_owhouse_e.htm
+        https://github.com/jwmatthys/pd-swisseph/blob/master/swehouse.c#L685
+        hsys = letter code for house system;
+            A  equal
+            E  equal
+            B  Alcabitius
+            C  Campanus
+            D  equal (MC)
+            F  Carter "Poli-Equatorial"
+            G  36 Gauquelin sectors
+            H  horizon / azimut
+            I  Sunshine solution Treindl
+            i  Sunshine solution Makransky
+            K  Koch
+            L  Pullen SD "sinusoidal delta", ex Neo-Porphyry
+            M  Morinus
+            N  equal/1=Aries
+            O  Porphyry
+            P  Placidus
+            Q  Pullen SR "sinusoidal ratio"
+            R  Regiomontanus
+            S  Sripati
+            T  Polich/Page ("topocentric")
+            U  Krusinski-Pisa-Goelzer
+            V  equal Vehlow
+            W  equal, whole sign
+            X  axial rotation system/ Meridian houses
+            Y  APC houses
+        """
+
+        if self.zodiac_type == "Sidereal":
+            self.houses_degree_ut = swe.houses_ex(
+                tjdut=self.julian_day, lat=self.lat, lon=self.lng, hsys=str.encode('P'), flags=swe.FLG_SIDEREAL
+            )[0]
+        elif self.zodiac_type == "Tropic":
+            self.houses_degree_ut = swe.houses(
+                tjdut=self.julian_day, lat=self.lat, lon=self.lng, hsys=str.encode('P')
+            )[0]
+        else:
+            raise KerykeionException("Zodiac type not recognized! Please use 'Tropic' or 'Sidereal'")
+
         point_type: Literal["Planet", "House"] = "House"
         # creates the list of the house in 360°
         self.houses_degree_ut = swe.houses(self.julian_day, self.lat, self.lng)[0]
@@ -298,7 +384,11 @@ 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]
-        chiron_deg = swe.calc(self.julian_day, 15, 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,
@@ -313,8 +403,10 @@ class AstrologicalSubject:
             pluto_deg,
             mean_node_deg,
             true_node_deg,
-            chiron_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
@@ -334,68 +426,33 @@ class AstrologicalSubject:
         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)
-        self.chiron = calculate_position(self.planets_degrees_ut[12], "Chiron", 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."""
 
-        def for_every_planet(planet, planet_deg):
-            """Function to do the calculation.
-            Args: planet dictionary, planet degree"""
-
-            def point_between(p1, p2, p3):
-                """Finds if a point is between two other in a circle
-                args: first point, second point, point in the middle"""
-                p1_p2 = math.fmod(p2 - p1 + 360, 360)
-                p1_p3 = math.fmod(p3 - p1 + 360, 360)
-                if (p1_p2 <= 180) != (p1_p3 > p1_p2):
-                    return True
-                else:
-                    return False
-
-            if point_between(self.houses_degree_ut[0], self.houses_degree_ut[1], planet_deg) == True:
-                planet["house"] = "First_House"
-            elif point_between(self.houses_degree_ut[1], self.houses_degree_ut[2], planet_deg) == True:
-                planet["house"] = "Second_House"
-            elif point_between(self.houses_degree_ut[2], self.houses_degree_ut[3], planet_deg) == True:
-                planet["house"] = "Third_House"
-            elif point_between(self.houses_degree_ut[3], self.houses_degree_ut[4], planet_deg) == True:
-                planet["house"] = "Fourth_House"
-            elif point_between(self.houses_degree_ut[4], self.houses_degree_ut[5], planet_deg) == True:
-                planet["house"] = "Fifth_House"
-            elif point_between(self.houses_degree_ut[5], self.houses_degree_ut[6], planet_deg) == True:
-                planet["house"] = "Sixth_House"
-            elif point_between(self.houses_degree_ut[6], self.houses_degree_ut[7], planet_deg) == True:
-                planet["house"] = "Seventh_House"
-            elif point_between(self.houses_degree_ut[7], self.houses_degree_ut[8], planet_deg) == True:
-                planet["house"] = "Eighth_House"
-            elif point_between(self.houses_degree_ut[8], self.houses_degree_ut[9], planet_deg) == True:
-                planet["house"] = "Ninth_House"
-            elif point_between(self.houses_degree_ut[9], self.houses_degree_ut[10], planet_deg) == True:
-                planet["house"] = "Tenth_House"
-            elif point_between(self.houses_degree_ut[10], self.houses_degree_ut[11], planet_deg) == True:
-                planet["house"] = "Eleventh_House"
-            elif point_between(self.houses_degree_ut[11], self.houses_degree_ut[0], planet_deg) == True:
-                planet["house"] = "Twelfth_House"
-            else:
-                planet["house"] = "error!"
-
-            return planet
-
-        self.sun = for_every_planet(self.sun, self.planets_degrees_ut[0])
-        self.moon = for_every_planet(self.moon, self.planets_degrees_ut[1])
-        self.mercury = for_every_planet(self.mercury, self.planets_degrees_ut[2])
-        self.venus = for_every_planet(self.venus, self.planets_degrees_ut[3])
-        self.mars = for_every_planet(self.mars, self.planets_degrees_ut[4])
-        self.jupiter = for_every_planet(self.jupiter, self.planets_degrees_ut[5])
-        self.saturn = for_every_planet(self.saturn, self.planets_degrees_ut[6])
-        self.uranus = for_every_planet(self.uranus, self.planets_degrees_ut[7])
-        self.neptune = for_every_planet(self.neptune, self.planets_degrees_ut[8])
-        self.pluto = for_every_planet(self.pluto, self.planets_degrees_ut[9])
-        self.mean_node = for_every_planet(self.mean_node, self.planets_degrees_ut[10])
-        self.true_node = for_every_planet(self.true_node, self.planets_degrees_ut[11])
-        self.chiron = for_every_planet(self.chiron, self.planets_degrees_ut[12])
+        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,
@@ -410,8 +467,10 @@ class AstrologicalSubject:
             self.pluto,
             self.mean_node,
             self.true_node,
-            self.chiron
         ]
+        
+        if not self.disable_chiron:
+            self.planets_list.append(self.chiron)
 
         # Check in retrograde or not:
         planets_ret = []
@@ -486,37 +545,29 @@ class AstrologicalSubject:
             if degrees_between >= low and degrees_between < high:
                 sun_phase = x + 1
 
-        def moon_emoji(phase):
-            if phase == 1:
-                result = "🌑"
-            elif phase < 7:
-                result = "🌒"
-            elif 7 <= phase <= 9:
-                result = "🌓"
-            elif phase < 14:
-                result = "🌔"
-            elif phase == 14:
-                result = "🌕"
-            elif phase < 20:
-                result = "🌖"
-            elif 20 <= phase <= 22:
-                result = "🌗"
-            elif phase <= 28:
-                result = "🌘"
-            else:
-                result = phase
-
-            return result
-
         lunar_phase_dictionary = {
             "degrees_between_s_m": degrees_between,
             "moon_phase": moon_phase,
             "sun_phase": sun_phase,
-            "moon_emoji": moon_emoji(moon_phase),
+            "moon_emoji": get_moon_emoji_from_phase_int(moon_phase),
+            "moon_phase_name": get_moon_phase_name_from_phase_int(moon_phase)
         }
 
         self.lunar_phase = LunarPhaseModel(**lunar_phase_dictionary)
 
+    def _check_if_poles(self):
+        """
+            Utility function to check if the location is in the polar circle.
+            If it is, it sets the latitude to 66 or -66 degrees.
+        """
+        if self.lat > 66.0:
+            self.lat = 66.0
+            logging.info("Polar circle override for houses, using 66 degrees")
+
+        elif self.lat < -66.0:
+            self.lat = -66.0
+            logging.info("Polar circle override for houses, using -66 degrees")
+
     def json(self, dump=False, destination_folder: Union[str, None] = None) -> str:
         """
         Dumps the Kerykeion object to a json string foramt,
@@ -525,7 +576,7 @@ class AstrologicalSubject:
         """
 
         KrData = AstrologicalSubjectModel(**self.__dict__)
-        json_string = KrData.json(exclude_none=True)
+        json_string = KrData.model_dump_json(exclude_none=True)
         print(json_string)
 
         if dump:
@@ -538,7 +589,7 @@ class AstrologicalSubject:
 
             with open(json_path, "w", encoding="utf-8") as file:
                 file.write(json_string)
-                logger.info(f"JSON file dumped in {json_path}.")
+                logging.info(f"JSON file dumped in {json_path}.")
 
         return json_string
 
@@ -552,10 +603,20 @@ class AstrologicalSubject:
 
 if __name__ == "__main__":
     import json
-    basicConfig(level="DEBUG", force=True)
+    from kerykeion.utilities import setup_logging
 
+    setup_logging(level="debug")
+    
+    # With Chiron enabled
     johnny = AstrologicalSubject("Johnny Depp", 1963, 6, 9, 0, 0, "Owensboro", "US")
     print(json.loads(johnny.json(dump=True)))
 
     print('\n')
     print(johnny.chiron)
+
+    # With Chiron disabled
+    johnny = AstrologicalSubject("Johnny Depp", 1963, 6, 9, 0, 0, "Owensboro", "US", disable_chiron=True)
+    print(json.loads(johnny.json(dump=True)))
+
+    print('\n')
+    print(johnny.chiron)

kerykeion/charts/__init__.py

@@ -1,5 +1,5 @@
 """
-This is part of Kerykeion (C) 2023 Giacomo Battaglia
+This is part of Kerykeion (C) 2024 Giacomo Battaglia
 
 This modules contains the charts logic for the Kerykeion project.
 """