Initial sect calculations.

Author: theriftlab

immanuel/charts.py

@@ -21,8 +21,8 @@
 
 from immanuel.classes import wrap
 from immanuel.classes.localize import _
-from immanuel.const import chart, names
-from immanuel.reports import aspect, pattern
+from immanuel.const import calc, chart, names
+from immanuel.reports import aspect, dignity, pattern, weighting
 from immanuel.setup import settings
 from immanuel.tools import calculate, convert, date, ephemeris, forecast, midpoint, position
 
@@ -50,6 +50,19 @@ def __init__(self, type: int, aspects_to: 'Chart' = None) -> None:
         self.type = _(names.CHART_TYPES[type])
         self._type = type
         self._aspects_to = aspects_to
+
+        self._native: Subject
+        self._obliquity: float
+        self._diurnal: bool
+        self._moon_phase: int
+        self._triad: dict = {
+            chart.SUN: None,
+            chart.MOON: None,
+            chart.ASC: None,
+        }
+        self._objects: dict
+        self._houses: dict
+
         self.generate()
         self.wrap()
 
@@ -60,14 +73,9 @@ def house_for(self, object: wrap.Object) -> int:
         return position.house(object.longitude.raw, self._houses)['index']
 
     def generate(self) -> None:
-        """ Generating the raw data is each descendant class's responsibility,
-        but placeholders for properties common to all charts are set here. """
-        self._native: Subject = None
-        self._obliquity: float = None
-        self._diurnal: bool = None
-        self._moon_phase: int = None
-        self._objects: dict = {}
-        self._houses: dict = {}
+        """ Generating the raw data is each descendant class's
+        responsibility. """
+        pass
 
     def wrap(self) -> None:
         """ Loop through the required data and wrap each one with a custom
@@ -95,30 +103,54 @@ def set_wrapped_moon_phase(self) -> None:
 
     def set_wrapped_objects(self) -> None:
         self.objects = {}
+
         for index, object in self._objects.items():
-            if 'jd' in object:
-                object['date_time'] = date.to_datetime(
-                        dt=object['jd'],
-                        lat=self._native.latitude,
-                        lon=self._native.longitude,
-                    )
-            self.objects[index] = wrap.Object(
+            house = position.house(
                     object=object,
-                    objects=self._objects,
                     houses=self._houses,
-                    is_daytime=self._diurnal,
+                )
+            out_of_bounds = calculate.is_out_of_bounds(
+                    object=object,
                     obliquity=self._obliquity,
                 )
+            in_sect = calculate.is_in_sect(
+                    object=object,
+                    is_daytime=self._diurnal,
+                    sun=self._triad[chart.SUN],
+                ) if object['index'] in (chart.SUN, chart.MOON, chart.MERCURY, chart.VENUS, chart.MARS, chart.JUPITER, chart.SATURN) else None
+            dignity_state = dignity.all(
+                    object=object,
+                    objects=self._objects,
+                    is_daytime=self._diurnal,
+                ) if object['type'] == chart.PLANET and self._diurnal and calc.PLANETS.issubset(self._objects) else None
+            date_time = date.to_datetime(
+                    dt=object['jd'],
+                    lat=self._native.latitude,
+                    lon=self._native.longitude,
+                ) if 'jd' in object else None
+
+            self.objects[index] = wrap.Object(
+                    object=object,
+                    date_time=date_time,
+                    house=house,
+                    out_of_bounds=out_of_bounds,
+                    in_sect=in_sect,
+                    dignity_state=dignity_state,
+                )
 
     def set_wrapped_houses(self) -> None:
         self.houses = {index: wrap.Object(object=house) for index, house in self._houses.items()}
 
     def set_wrapped_aspects(self) -> None:
         aspects = aspect.all(self._objects) if self._aspects_to is None else aspect.synastry(self._objects, self._aspects_to._objects)
-        self.aspects = {index: {object_index: wrap.Aspect(aspect=object_aspect, objects=self._objects) for object_index, object_aspect in aspect_list.items()} for index, aspect_list in aspects.items()}
+        self.aspects = {index: {object_index: wrap.Aspect(aspect=object_aspect, active_name=self._objects[object_aspect['active']]['name'], passive_name=self._objects[object_aspect['passive']]['name']) for object_index, object_aspect in aspect_list.items()} for index, aspect_list in aspects.items()}
 
     def set_wrapped_weightings(self) -> None:
-        self.weightings = wrap.Weightings(self._objects, self._houses)
+        self.weightings = wrap.Weightings(
+                elements=weighting.elements(self._objects),
+                modalities=weighting.modalities(self._objects),
+                quadrants=weighting.quadrants(self._objects, self._houses),
+            )
 
 
 class Natal(Chart):
@@ -131,18 +163,18 @@ def __init__(self, native: Subject, aspects_to: Chart = None) -> None:
     def generate(self) -> None:
         self._obliquity = ephemeris.obliquity(self._native.julian_date)
 
-        sun = ephemeris.planet(chart.SUN, self._native.julian_date)
-        moon = ephemeris.planet(chart.MOON, self._native.julian_date)
-        asc = ephemeris.angle(
+        self._triad[chart.SUN] = ephemeris.planet(chart.SUN, self._native.julian_date)
+        self._triad[chart.MOON] = ephemeris.planet(chart.MOON, self._native.julian_date)
+        self._triad[chart.ASC] = ephemeris.angle(
                 index=chart.ASC,
                 jd=self._native.julian_date,
                 lat=self._native.latitude,
                 lon=self._native.longitude,
                 house_system=settings.house_system,
             )
 
-        self._diurnal = calculate.is_daytime(sun, asc)
-        self._moon_phase = calculate.moon_phase(sun, moon)
+        self._diurnal = calculate.is_daytime(self._triad[chart.SUN], self._triad[chart.ASC])
+        self._moon_phase = calculate.moon_phase(self._triad[chart.SUN], self._triad[chart.MOON])
         self._objects = ephemeris.objects(
                 object_list=settings.objects,
                 jd=self._native.julian_date,
@@ -177,18 +209,18 @@ def generate(self) -> None:
                 house_system=settings.house_system,
             )
 
-        sun = ephemeris.planet(chart.SUN, self._solar_return_jd)
-        moon = ephemeris.planet(chart.MOON, self._solar_return_jd)
-        asc = ephemeris.angle(
+        self._triad[chart.SUN] = ephemeris.planet(chart.SUN, self._solar_return_jd)
+        self._triad[chart.MOON] = ephemeris.planet(chart.MOON, self._solar_return_jd)
+        self._triad[chart.ASC] = ephemeris.angle(
                 index=chart.ASC,
                 jd=self._solar_return_jd,
                 lat=self._native.latitude,
                 lon=self._native.longitude,
                 house_system=settings.house_system,
             )
 
-        self._diurnal = calculate.is_daytime(sun, asc)
-        self._moon_phase = calculate.moon_phase(sun, moon)
+        self._diurnal = calculate.is_daytime(self._triad[chart.SUN], self._triad[chart.ASC])
+        self._moon_phase = calculate.moon_phase(self._triad[chart.SUN], self._triad[chart.MOON])
         self._objects = ephemeris.objects(
                 object_list=settings.objects,
                 jd=self._solar_return_jd,
@@ -250,18 +282,18 @@ def generate(self) -> None:
             )
         self._obliquity = ephemeris.obliquity(self._progressed_jd)
 
-        sun = ephemeris.planet(chart.SUN, self._progressed_jd)
-        moon = ephemeris.planet(chart.MOON, self._progressed_jd)
-        asc = ephemeris.armc_angle(
+        self._triad[chart.SUN] = ephemeris.planet(chart.SUN, self._progressed_jd)
+        self._triad[chart.MOON] = ephemeris.planet(chart.MOON, self._progressed_jd)
+        self._triad[chart.ASC] = ephemeris.armc_angle(
             index=chart.ASC,
                 armc=self._progressed_armc_longitude,
                 lat=self._native.latitude,
                 obliquity=self._obliquity,
                 house_system=settings.house_system,
             )
 
-        self._diurnal = calculate.is_daytime(sun, asc)
-        self._moon_phase = calculate.moon_phase(sun, moon)
+        self._diurnal = calculate.is_daytime(self._triad[chart.SUN], self._triad[chart.ASC])
+        self._moon_phase = calculate.moon_phase(self._triad[chart.SUN], self._triad[chart.MOON])
         self._objects = ephemeris.armc_objects(
                 object_list=settings.objects,
                 jd=self._progressed_jd,
@@ -373,7 +405,7 @@ def generate(self) -> None:
                 )
 
         if chart.ASC in self._objects:
-            asc = self._objects[chart.ASC]
+            self._triad[chart.ASC] = self._objects[chart.ASC]
         else:
             native_asc = ephemeris.angle(
                     index=chart.ASC,
@@ -389,24 +421,24 @@ def generate(self) -> None:
                     lon=self._partner.longitude,
                     house_system=settings.house_system,
                 )
-            asc = midpoint.composite(native_asc, partner_asc, self._obliquity)
+            self._triad[chart.ASC] = midpoint.composite(native_asc, partner_asc, self._obliquity)
 
         if chart.SUN in self._objects:
-            sun = self._objects[chart.SUN]
+            self._triad[chart.SUN] = self._objects[chart.SUN]
         else:
             native_sun = ephemeris.planet(chart.SUN, self._native.julian_date)
             partner_sun = ephemeris.planet(chart.SUN, self._partner.julian_date)
-            sun = midpoint.composite(native_sun, partner_sun, self._obliquity)
+            self._triad[chart.SUN] = midpoint.composite(native_sun, partner_sun, self._obliquity)
 
         if chart.MOON in self._objects:
-            moon = self._objects[chart.MOON]
+            self._triad[chart.MOON] = self._objects[chart.MOON]
         else:
             native_moon = ephemeris.planet(chart.MOON, self._native.julian_date)
             partner_moon = ephemeris.planet(chart.MOON, self._partner.julian_date)
-            moon = midpoint.composite(native_moon, partner_moon, self._obliquity)
+            self._triad[chart.MOON] = midpoint.composite(native_moon, partner_moon, self._obliquity)
 
-        self._diurnal = calculate.is_daytime(sun, asc)
-        self._moon_phase = calculate.moon_phase(sun, moon)
+        self._diurnal = calculate.is_daytime(self._triad[chart.SUN], self._triad[chart.ASC])
+        self._moon_phase = calculate.moon_phase(self._triad[chart.SUN], self._triad[chart.MOON])
 
     def set_wrapped_partner(self):
         self.partner = wrap.Subject(self._partner)
@@ -425,18 +457,18 @@ def __init__(self, latitude: float | list | tuple | str = settings.default_latit
     def generate(self) -> None:
         self._obliquity = ephemeris.obliquity(self._native.julian_date)
 
-        sun = ephemeris.planet(chart.SUN, self._native.julian_date)
-        moon = ephemeris.planet(chart.MOON, self._native.julian_date)
-        asc = ephemeris.angle(
+        self._triad[chart.SUN] = ephemeris.planet(chart.SUN, self._native.julian_date)
+        self._triad[chart.MOON] = ephemeris.planet(chart.MOON, self._native.julian_date)
+        self._triad[chart.ASC] = ephemeris.angle(
                 index=chart.ASC,
                 jd=self._native.julian_date,
                 lat=self._native.latitude,
                 lon=self._native.longitude,
                 house_system=settings.house_system,
             )
 
-        self._diurnal = calculate.is_daytime(sun, asc)
-        self._moon_phase = calculate.moon_phase(sun, moon)
+        self._diurnal = calculate.is_daytime(self._triad[chart.SUN], self._triad[chart.ASC])
+        self._moon_phase = calculate.moon_phase(self._triad[chart.SUN], self._triad[chart.MOON])
         self._objects = ephemeris.objects(
                 object_list=settings.objects,
                 jd=self._native.julian_date,

immanuel/classes/wrap.py

@@ -12,7 +12,7 @@
 from datetime import datetime
 
 from immanuel.const import calc, chart, dignities, names
-from immanuel.reports import dignity, weighting
+from immanuel.reports import dignity
 from immanuel.setup import settings
 from immanuel.tools import calculate, convert, date, ephemeris, position
 from immanuel.classes.localize import gender, _
@@ -39,9 +39,9 @@ def __str__(self) -> str:
 
 
 class Aspect:
-    def __init__(self, aspect: dict, objects: dict) -> None:
-        self._active_name = objects[aspect['active']]['name']
-        self._passive_name = objects[aspect['passive']]['name']
+    def __init__(self, aspect: dict, active_name: str, passive_name: str) -> None:
+        self._active_name = active_name
+        self._passive_name = passive_name
         self.active = aspect['active']
         self.passive = aspect['passive']
         self.type = _(names.ASPECTS[aspect['aspect']])
@@ -183,7 +183,16 @@ def __str__(self) -> str:
 
 
 class Object:
-    def __init__(self, object: dict, objects: dict = None, houses: dict = None, is_daytime: bool = None, obliquity: float = None) -> None:
+    # def __init__(self, object: dict, objects: dict = None, houses: dict = None, is_daytime: bool = None, obliquity: float = None) -> None:
+    def __init__(
+        self,
+        object: dict,
+        date_time: datetime = None,
+        house: int = None,
+        out_of_bounds: bool = None,
+        in_sect: bool = None,
+        dignity_state: dict = None,
+    ) -> None:
         self.index = object['index']
 
         if object['type'] == chart.HOUSE:
@@ -195,8 +204,8 @@ def __init__(self, object: dict, objects: dict = None, houses: dict = None, is_d
         if 'eclipse_type' in object:
             self.eclipse_type = EclipseType(object['eclipse_type'])
 
-        if 'date_time' in object:
-            self.date_time = DateTime(object['date_time'])
+        if date_time is not None:
+            self.date_time = DateTime(date_time)
 
         if 'lat' in object:
             self.latitude = Angle(object['lat'], round_to=settings.angle_precision)
@@ -206,8 +215,8 @@ def __init__(self, object: dict, objects: dict = None, houses: dict = None, is_d
         self.sign = Sign(position.sign(object))
         self.decan = Decan(position.decan(object))
 
-        if houses is not None:
-            self.house = House(position.house(object, houses))
+        if house is not None:
+            self.house = House(house)
 
         if 'dist' in object:
             self.distance = object['dist']
@@ -220,17 +229,20 @@ def __init__(self, object: dict, objects: dict = None, houses: dict = None, is_d
         if 'dec' in object:
             self.declination = Angle(object['dec'], round_to=settings.angle_precision)
 
-            if object['type'] not in (chart.HOUSE, chart.ANGLE, chart.FIXED_STAR):
-                self.out_of_bounds = calculate.is_out_of_bounds(object=object, obliquity=obliquity)
+        if object['type'] not in (chart.HOUSE, chart.ANGLE, chart.FIXED_STAR):
+            self.out_of_bounds = out_of_bounds
 
         if 'size' in object:
             self.size = object['size']
 
-        if objects is not None and object['type'] == chart.PLANET and is_daytime is not None and calc.PLANETS.issubset(objects):
-            dignity_state = dignity.all(object=object, objects=objects, is_daytime=is_daytime)
+        if in_sect is not None:
+            self.in_sect = in_sect
+
+        if dignity_state is not None:
             self.dignities = DignityState(object=object, dignity_state=dignity_state)
             self.score = dignity.score(dignity_state)
 
+
     def __str__(self) -> str:
         formatted = _('{name} {longitude} in {sign}').format(
                 name=self.name,
@@ -310,10 +322,10 @@ def __str__(self) -> str:
 
 
 class Weightings:
-    def __init__(self, objects: dict, houses: dict) -> None:
-        self.elements = Elements(weighting.elements(objects))
-        self.modalities = Modalities(weighting.modalities(objects))
-        self.quadrants = Quadrants(weighting.quadrants(objects, houses))
+    def __init__(self, elements: dict, modalities: dict, quadrants: dict) -> None:
+        self.elements = Elements(elements)
+        self.modalities = Modalities(modalities)
+        self.quadrants = Quadrants(quadrants)
 
     def __str__(self) -> str:
         return f'{self.elements}\n{self.modalities}\n{self.quadrants}'

immanuel/tools/calculate.py

@@ -113,6 +113,21 @@ def relative_position(object1: dict | float, object2: dict | float) -> int:
     return calc.OCCIDENTAL if swe.difdegn(lon1, lon2) > 180 else calc.ORIENTAL
 
 
+def is_in_sect(object: dict, is_daytime: bool, sun: dict | float = None) -> bool:
+    """ Returns whether the passed planet is in sect. """
+    if object['index'] in (chart.SUN, chart.JUPITER, chart.SATURN):
+        return is_daytime
+
+    if object['index'] in (chart.MOON, chart.VENUS, chart.MARS):
+        return not is_daytime
+
+    if object['index'] == chart.MERCURY:
+        sun_mercury_position = relative_position(sun, object)
+        return sun_mercury_position == calc.ORIENTAL if is_daytime else sun_mercury_position == calc.OCCIDENTAL
+
+    return False
+
+
 def is_out_of_bounds(object: dict | float, jd: float = None, obliquity: float = None) -> bool:
     """ Returns whether the passed object is out of bounds either on the passed
     Julian date or relative to the passed obliquity. """