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

kerykeion/astrological_subject.py

@@ -1,14 +1,14 @@
 # -*- 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 functools import cached_property
 from kerykeion.fetch_geonames import FetchGeonames
 from kerykeion.kr_types import (
     KerykeionException,
@@ -16,18 +16,39 @@ from kerykeion.kr_types import (
     AstrologicalSubjectModel,
     LunarPhaseModel,
     KerykeionPointModel,
+    PointType,
+    SiderealMode,
+    HousesSystemIdentifier,
+    PerspectiveType
+)
+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,
+    check_and_adjust_polar_latitude
 )
-from kerykeion.utilities import get_number_from_name, calculate_position
 from pathlib import Path
-from typing import Union, Literal
-
-
-logger = getLogger(__name__)
-basicConfig(
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    level="INFO"
+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"
+GEONAMES_DEFAULT_USERNAME_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"
+    "********"
 )
 
+NOW = datetime.now()
+
 
 class AstrologicalSubject:
     """
@@ -35,25 +56,37 @@ class AstrologicalSubject:
     it's utc and julian day and returns an object with all that data.
 
     Args:
-    - name (str, optional): _ Defaults to "Now".
-    - year (int, optional): _ Defaults to now.year.
-    - month (int, optional): _ Defaults to now.month.
-    - day (int, optional): _ Defaults to now.day.
-    - hour (int, optional): _ Defaults to now.hour.
-    - minute (int, optional): _ Defaults to now.minute.
+    - name (str, optional): The name of the subject. Defaults to "Now".
+    - year (int, optional): The year of birth. Defaults to the current year.
+    - month (int, optional): The month of birth. Defaults to the current month.
+    - day (int, optional): The day of birth. Defaults to the current day.
+    - hour (int, optional): The hour of birth. Defaults to the current hour.
+    - minute (int, optional): Defaults to the current minute.
     - city (str, optional): City or location of birth. Defaults to "London", which is GMT time.
         The city argument is used to get the coordinates and timezone from geonames just in case
         you don't insert them manually (see _get_tz).
         If you insert the coordinates and timezone manually, the city argument is not used for calculations
         but it's still used as a value for the city attribute.
     - nat (str, optional): _ Defaults to "".
-    - 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.
+    - lng (Union[int, float], optional): Longitude of the birth location. Defaults to 0 (Greenwich, London).
+    - lat (Union[int, float], optional): Latitude of the birth location. Defaults to 51.5074 (Greenwich, London).
+    - tz_str (Union[str, bool], optional): Timezone of the birth location. Defaults to "GMT".
+    - 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
+    - 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.
+    - 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".
+        Available modes are visible in the SiderealMode Literal.
+    - houses_system_identifier (HousesSystemIdentifier, optional): The system to use for the calculation of the houses.
+        Defaults to "P" (Placidus).
+        Available systems are visible in the HousesSystemIdentifier Literal.
+    - 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.
     """
 
     # Defined by the user
@@ -71,14 +104,17 @@ class AstrologicalSubject:
     geonames_username: str
     online: bool
     zodiac_type: ZodiacType
+    sidereal_mode: SiderealMode
+    houses_system_identifier: HousesSystemIdentifier
+    houses_system_name: str
+    perspective_type: PerspectiveType
 
     # Generated internally
     city_data: dict[str, str]
     julian_day: Union[int, float]
-    utc_time: float
-    local_time: float
-    utc: datetime
     json_dir: Path
+    iso_formatted_local_datetime: str
+    iso_formatted_utc_datetime: str
 
     # Planets
     sun: KerykeionPointModel
@@ -93,7 +129,7 @@ class AstrologicalSubject:
     pluto: KerykeionPointModel
     true_node: KerykeionPointModel
     mean_node: KerykeionPointModel
-    chiron: KerykeionPointModel
+    chiron: Union[KerykeionPointModel, None]
 
     # Houses
     first_house: KerykeionPointModel
@@ -110,40 +146,33 @@ 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",
-        year: int = now.year,
-        month: int = now.month,
-        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",
-        zodiac_type: ZodiacType = "Tropic",
+        year: int = NOW.year,
+        month: int = NOW.month,
+        day: int = NOW.day,
+        hour: int = NOW.hour,
+        minute: int = NOW.minute,
+        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 = DEFAULT_ZODIAC_TYPE,
         online: bool = True,
+        disable_chiron: bool = False,
+        sidereal_mode: Union[SiderealMode, None] = None,
+        houses_system_identifier: HousesSystemIdentifier = DEFAULT_HOUSES_SYSTEM_IDENTIFIER,
+        perspective_type: PerspectiveType = DEFAULT_PERSPECTIVE_TYPE
     ) -> None:
-        logger.debug("Starting Kerykeion")
-
-        # We set the swisseph path to the current directory
-        swe.set_ephe_path(
-            str(
-                Path(__file__).parent.absolute() / "sweph"
-            )
-        )
-
+        logging.debug("Starting Kerykeion")
 
         self.name = name
         self.year = year
@@ -156,48 +185,154 @@ 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.disable_chiron = disable_chiron
+        self.sidereal_mode = sidereal_mode
+        self.houses_system_identifier = houses_system_identifier
+        self.perspective_type = perspective_type
+
+        #---------------#
+        # General setup #
+        #---------------#
+
+        # This message is set to encourage the user to set a custom geonames username
+        if geonames_username is None and online:
+            logging.warning(
+
+            )
+
+            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.online) and (not lng or not lat or not tz_str):
-            raise KerykeionException(
-                "You need to set the coordinates and timezone if you want to use the offline mode!"
-            )
+        if not self.lat:
+            self.lat = 51.5074
+            logging.info("No latitude specified, using London as default")
+
+        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!")
+
+        #-----------------------#
+        # Swiss Ephemeris setup #
+        #-----------------------#
+
+        # We set the swisseph path to the current directory
+        swe.set_ephe_path(str(Path(__file__).parent.absolute() / "sweph"))
+
+        # Flags for the Swiss Ephemeris
+        self._iflag = swe.FLG_SWIEPH + swe.FLG_SPEED
+
+        # Chart Perspective check and setup --->
+        if self.perspective_type not in get_args(PerspectiveType):
+            raise KerykeionException(f"\n* ERROR: '{self.perspective_type}' is NOT a valid chart perspective! Available perspectives are: *" + "\n" + str(get_args(PerspectiveType)))
+        
+        if self.perspective_type == "True Geocentric":
+            self._iflag += swe.FLG_TRUEPOS
+        elif self.perspective_type == "Heliocentric":
+            self._iflag += swe.FLG_HELCTR
+        elif self.perspective_type == "Topocentric":
+            self._iflag += swe.FLG_TOPOCTR
+            # geopos_is_set, for topocentric
+            swe.set_topo(self.lng, self.lat, 0)
+        # <--- Chart Perspective check and setup
+
+        # House System check and setup --->
+        if self.houses_system_identifier not in get_args(HousesSystemIdentifier):
+            raise KerykeionException(f"\n* ERROR: '{self.houses_system_identifier}' is NOT a valid house system! Available systems are: *" + "\n" + str(get_args(HousesSystemIdentifier)))
+
+        self.houses_system_name = swe.house_name(self.houses_system_identifier.encode('ascii'))
+        # <--- House System check and setup
+
+        # Zodiac Type and Sidereal mode checks and setup --->
+        if zodiac_type and not zodiac_type in get_args(ZodiacType):
+            raise KerykeionException(f"\n* ERROR: '{zodiac_type}' is NOT a valid zodiac type! Available types are: *" + "\n" + str(get_args(ZodiacType)))
+
+        if self.sidereal_mode and self.zodiac_type == "Tropic":
+            raise KerykeionException("You can't set a sidereal mode with a Tropic zodiac type!")
+        
+        if self.zodiac_type == "Sidereal" and not self.sidereal_mode:
+            self.sidereal_mode = DEFAULT_SIDEREAL_MODE
+            logging.info("No sidereal mode set, using default FAGAN_BRADLEY")
+
+        if self.zodiac_type == "Sidereal":
+            # Check if the sidereal mode is valid
+            if 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
+            mode = "SIDM_" + self.sidereal_mode
+            swe.set_sid_mode(getattr(swe, mode))
+            logging.debug(f"Using sidereal mode: {mode}")
+        # <--- Zodiac Type and Sidereal mode checks and setup
+
+        #------------------------#
+        # 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()
+
+        # 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)
+        utc_object = local_datetime.astimezone(pytz.utc)
+        self.iso_formatted_utc_datetime = utc_object.isoformat()
+
+        # ISO formatted local datetime
+        self.iso_formatted_local_datetime = local_datetime.isoformat()
+
+        # Julian day calculation
+        utc_float_hour_with_minutes = utc_object.hour + (utc_object.minute / 60)
+        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
 
-        # Initialize everything
-        self._get_utc()
-        self._get_jd()
         self._planets_degrees_lister()
         self._planets()
         self._houses()
-
         self._planets_in_houses()
         self._lunar_phase_calc()
 
+        # Deprecated properties
+        self.utc_time
+        self.local_time
+
     def __str__(self) -> str:
-        return f"Astrological data for: {self.name}, {self.utc} UTC\nBirth location: {self.city}, Lat {self.lat}, Lon {self.lng}"
+        return f"Astrological data for: {self.name}, {self.iso_formatted_utc_datetime} UTC\nBirth location: {self.city}, Lat {self.lat}, Lon {self.lng}"
 
     def __repr__(self) -> str:
-        return f"Astrological data for: {self.name}, {self.utc} UTC\nBirth location: {self.city}, Lat {self.lat}, Lon {self.lng}"
+        return f"Astrological data for: {self.name}, {self.iso_formatted_utc_datetime} 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,39 +349,59 @@ 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")
+        check_and_adjust_polar_latitude(self.lat, self.lng)
 
-    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):
-            self._fetch_tz_from_geonames()
-
-        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)
-        self.utc = local_datetime.astimezone(pytz.utc)
+    def _houses(self) -> None:
+        """
+        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
+        """
 
-    def _get_jd(self) -> None:
-        """Calculates julian day from the utc time."""
-        self.utc_time = self.utc.hour + self.utc.minute / 60
-        self.local_time = self.hour + self.minute / 60
-        self.julian_day = float(swe.julday(self.utc.year, self.utc.month, self.utc.day, self.utc_time))
+        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(self.houses_system_identifier),
+                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(self.houses_system_identifier)
+            )[0]
+
+        point_type: PointType = "House"
 
-    def _houses(self) -> None:
-        """Calculate positions and store them in dictionaries"""
-        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]
         # 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)
@@ -278,12 +433,6 @@ class AstrologicalSubject:
 
     def _planets_degrees_lister(self):
         """Sidereal or tropic mode."""
-        self._iflag = swe.FLG_SWIEPH + swe.FLG_SPEED
-
-        if self.zodiac_type == "Sidereal":
-            self._iflag += swe.FLG_SIDEREAL
-            mode = "SIDM_FAGAN_BRADLEY"
-            swe.set_sid_mode(getattr(swe, mode))
 
         # Calculates the position of the planets and stores it in a list.
         sun_deg = swe.calc(self.julian_day, 0, self._iflag)[0][0]
@@ -298,7 +447,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,14 +466,16 @@ 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
         stores them in dictionaries"""
 
-        point_type: Literal["Planet", "House"] = "Planet"
+        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)
@@ -334,68 +489,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,18 +530,20 @@ 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 = []
-        for p in self.planets_list:
-            planet_number = get_number_from_name(p["name"])
+        for planet in self.planets_list:
+            planet_number = get_number_from_name(planet["name"])
             if swe.calc(self.julian_day, planet_number, self._iflag)[0][3] < 0:
-                p["retrograde"] = True
+                planet["retrograde"] = True
             else:
-                p["retrograde"] = False
-            planets_ret.append(p)
+                planet["retrograde"] = False
+            planets_ret.append(planet)
 
     def _lunar_phase_calc(self) -> None:
         """Function to calculate the lunar phase"""
@@ -486,38 +608,17 @@ 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 json(self, dump=False, destination_folder: Union[str, None] = None) -> str:
+    def json(self, dump=False, destination_folder: Union[str, None] = None, indent: Union[int, None] = None) -> str:
         """
         Dumps the Kerykeion object to a json string foramt,
         if dump=True also dumps to file located in destination
@@ -525,8 +626,7 @@ class AstrologicalSubject:
         """
 
         KrData = AstrologicalSubjectModel(**self.__dict__)
-        json_string = KrData.json(exclude_none=True)
-        print(json_string)
+        json_string = KrData.model_dump_json(exclude_none=True, indent=indent)
 
         if dump:
             if destination_folder:
@@ -538,7 +638,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
 
@@ -549,13 +649,167 @@ class AstrologicalSubject:
 
         return AstrologicalSubjectModel(**self.__dict__)
 
+    @cached_property
+    def utc_time(self) -> float:
+        """
+        Deprecated property, use iso_formatted_utc_datetime instead, will be removed in the future.
+        Returns the UTC time as a float.
+        """
+        dt = datetime.fromisoformat(self.iso_formatted_utc_datetime)
+        
+        # Extract the hours, minutes, and seconds
+        hours = dt.hour
+        minutes = dt.minute
+        seconds = dt.second + dt.microsecond / 1_000_000
+
+        # Convert time to float hours
+        float_time = hours + minutes / 60 + seconds / 3600
+
+        return float_time
+
+    @cached_property
+    def local_time(self) -> float:
+        """
+        Deprecated property, use iso_formatted_local_datetime instead, will be removed in the future.
+        Returns the local time as a float.
+        """
+        dt = datetime.fromisoformat(self.iso_formatted_local_datetime)
+        
+        # Extract the hours, minutes, and seconds
+        hours = dt.hour
+        minutes = dt.minute
+        seconds = dt.second + dt.microsecond / 1_000_000
+
+        # Convert time to float hours
+        float_time = hours + minutes / 60 + seconds / 3600
+
+        return float_time
+
+
+    @staticmethod
+    def get_from_iso_utc_time(
+        name: str,
+        iso_utc_time: str, 
+        city: str = "Greenwich", 
+        nation: str = "GB",
+        tz_str: str = "Etc/GMT",
+        online: bool = False,
+        lng: Union[int, float] = 0,
+        lat: Union[int, float] = 51.5074,
+        geonames_username: str = DEFAULT_GEONAMES_USERNAME,
+        zodiac_type: ZodiacType = DEFAULT_ZODIAC_TYPE,
+        disable_chiron: bool = False,
+        sidereal_mode: Union[SiderealMode, None] = None,
+        houses_system_identifier: HousesSystemIdentifier = DEFAULT_HOUSES_SYSTEM_IDENTIFIER,
+        perspective_type: PerspectiveType = DEFAULT_PERSPECTIVE_TYPE
+        
+    ) -> "AstrologicalSubject":
+        """
+        Creates an AstrologicalSubject object from an iso formatted UTC time.
+        This method is offline by default, set online=True to fetch the timezone and coordinates from geonames.
+
+        Args:
+        - name (str): The name of the subject.
+        - iso_utc_time (str): The iso formatted UTC time.
+        - city (str, optional): City or location of birth. Defaults to "Greenwich".
+        - nation (str, optional): Nation of birth. Defaults to "GB".
+        - tz_str (str, optional): Timezone of the birth location. Defaults to "Etc/GMT".
+        - 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 False.
+        - lng (Union[int, float], optional): Longitude of the birth location. Defaults to 0 (Greenwich, London).
+        - lat (Union[int, float], optional): Latitude of the birth location. Defaults to 51.5074 (Greenwich, London).
+        - 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.
+            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.
+            Defaults to None.
+            Available modes are visible in the SiderealMode Literal.
+        - houses_system_identifier (HousesSystemIdentifier, optional): The system to use for the calculation of the houses.
+            Defaults to "P" (Placidus).
+            Available systems are visible in the HousesSystemIdentifier Literal.
+        - perspective_type (PerspectiveType, optional): The perspective to use for the calculation of the chart.
+            Defaults to "Apparent Geocentric".
+
+        Returns:
+        - AstrologicalSubject: The AstrologicalSubject object.
+        """
+        dt = datetime.fromisoformat(iso_utc_time)
+
+        if online == True:
+            if geonames_username == DEFAULT_GEONAMES_USERNAME:
+                logging.warning(GEONAMES_DEFAULT_USERNAME_WARNING)
+
+            geonames = FetchGeonames(
+                city,
+                nation,
+                username=geonames_username,
+            )
+
+            city_data: dict[str, str] = geonames.get_serialized_data()
+            lng = float(city_data["lng"])
+            lat = float(city_data["lat"])
+
+        subject = AstrologicalSubject(
+            name=name,
+            year=dt.year,
+            month=dt.month,
+            day=dt.day,
+            hour=dt.hour,
+            minute=dt.minute,
+            city=city,
+            nation=city,
+            lng=lng,
+            lat=lat,
+            tz_str=tz_str,
+            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
+        )
+
+        return subject
 
 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)
+
+    # With Sidereal Zodiac
+    johnny = AstrologicalSubject("Johnny Depp", 1963, 6, 9, 0, 0, "Owensboro", "US", zodiac_type="Sidereal", sidereal_mode="LAHIRI")
+    print(johnny.json(dump=True, indent=2))
+
+    # With Morinus Houses
+    johnny = AstrologicalSubject("Johnny Depp", 1963, 6, 9, 0, 0, "Owensboro", "US", houses_system_identifier="M")
+    print(johnny.json(dump=True, indent=2))
+
+    # With True Geocentric Perspective
+    johnny = AstrologicalSubject("Johnny Depp", 1963, 6, 9, 0, 0, "Owensboro", "US", perspective_type="True Geocentric")
+    print(johnny.json(dump=True, indent=2))
+
+    # With Heliocentric Perspective
+    johnny = AstrologicalSubject("Johnny Depp", 1963, 6, 9, 0, 0, "Owensboro", "US", perspective_type="Heliocentric")
+    print(johnny.json(dump=True, indent=2))
+
+    # With Topocentric Perspective
+    johnny = AstrologicalSubject("Johnny Depp", 1963, 6, 9, 0, 0, "Owensboro", "US", perspective_type="Topocentric")