libaditya 0.3.4__py2.py3-none-any.whl

libaditya/cards/cards_of_truth.py

@@ -0,0 +1,323 @@
+#
+#    Copyright (c) 2025 Josh Harper <humanhaven@substack.com>
+#
+#    libaditya is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Affero General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    libaditya is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Affero General Public License for more details.
+#
+#    You should have received a copy of the GNU Affero General Public License
+#    along with libaditya.  If not, see <https://www.gnu.org/licenses/>.
+
+from rich import box
+from rich.table import Table
+from rich.console import Console
+
+from libaditya import utils
+from libaditya.objects import EphContext, Sun, JulianDay
+
+from libaditya.cards import cards_constants as cardsc
+from libaditya.cards.deck import Deck
+from .cot import CoT
+
+
+class CardsOfTruth(CoT):
+    """
+     underneath this class, CoT represents the cards as a list of two-letter strings,
+     AH through KS. 
+
+     the index in this list represents its associated card always in the underlying representation
+
+     we dont really have to know how that works to use this, which is the point of libaditya
+
+    CardsOfTruth().birth_spread() returns a Spread() instance that represents the birth spread. see that class
+    for information on its use
+
+    its docstring explains about the planet order
+
+    it will also explain how to go into the Spread and get information you might need
+    """
+
+    # master is a calc.Rashi() object
+    def __init__(self, context=EphContext(), master=None):
+        self.context = context
+        self.master = master
+        self._birth_card: str = self._get_birth_card()
+        self._birth_spread = self.BirthSpread(self._get_birth_spread(), self)
+
+    def birth_card(self):
+        return self._birth_card
+
+    def birth_spread(self):
+        """
+        self._birth_spread is the list of card integers of that spread
+        """
+        return self._birth_spread
+
+    def _get_birth_card(self):
+        """
+        find the birth card
+        first, find the time the sunrises at longitude of the persons place of birth, but on the equator
+        """
+        sunrise_location = self.context.location.nearest_equatorial_crossing()
+        sunrise_time = Sun(EphContext(timeJD=self.context.timeJD.midnightJD(),location=sunrise_location)).rise()
+        if self.context.timeJD.jd_number() >= sunrise_time.jd_number():
+            # after sunrise on this day
+            # so use card associated with this calendar day 
+            card_day = [self.context.timeJD.usrmonth(),self.context.timeJD.usrday()]
+        else:
+            # before sunrise on this day
+            # so use card associated with previous calendar day
+            # so we go back, but need to make everything switches back properly, i.e., the month or year
+            month = self.context.timeJD.usrmonth()
+            day = self.context.timeJD.usrday()-1
+            if day != 0:
+                card_day = [month,day]
+            else:
+                # we need to go back to the last day of the previous month
+                # i.e., the last card, but not necessarily in the normal sequence 
+                # in python, list()[-1] is the last element of the list
+                # so if month is jaunary=element0, then month-1=december,element11
+                # then we need to know how many days are in that month
+                card_day = [month-1,cardsc.days_in_the_month(month-1)]
+        # minus 1 since months are 1-12 but python is 0-indexed
+        start_card = cardsc.first_card_of_the_month[(card_day[0]-1)]
+        # go forward the number of days from that card to find the birth card
+        birth_card = cardsc.birth_card_order[start_card+(card_day[1]-1)]
+        return birth_card
+
+    def _get_birth_spread(self):
+        birth_card = self.birth_card()
+        return self.get_birthspread_from_quadration(birth_card)
+
+    def deck(self):
+        return self._deck
+
+    def year_spread(self, year=None):
+        """
+        get a year spread for age year
+
+        add way of doing default argument where it uses current age
+
+        if None, use current age, or try
+        not sure how well it actually works
+        """
+        if year == None:
+            # find the persons current age
+            year = int(self.context.timeJD.current_age())
+        year_spread_list = self.get_birthspread_from_quadration(self.birth_card(),self.quadraten(cardsc.jackquad,year+1))
+        # change planets to self.master.solar_return(year)...i.e., write solar_return
+        return self.YearSpread(year_spread_list, self, which=year)
+
+    def day_quadration(self, day=None):
+        """
+        get a day quadration spread for day "day"
+        if day=None, will get for the current day
+
+        if day is an integer, it will get the spread the "day"th day after birth
+        0 is the first day one is born, 1 is the next day, 2 the day after that, etc.
+        """
+        if day == None:
+            # find current age in days
+            day = int(self.context.timeJD.current_age_days())
+        day_spread_list = self.get_birthspread_from_quadration(self.birth_card(),self.quadraten(CoT.queen_quadration(),day))
+        return self.DayQuadration(day_spread_list, self, which=day)
+    
+    class Spread:
+        """
+        initialize a Spread object
+        the most important argument is spread_list, which is the list of numbers presenting the cards of the spread
+
+        this object will be responsible for intializing the planets
+        im not entirely sure what the calculations for the different spreads are called
+        i think they are some sort of progression
+        probably, those calculations will end up going somewhere else depending on what exactly they are
+
+        spread_list needs to have 14 numbers in it between 0 and 51.
+
+        these integers represent the cards. the integer representing a certain card is the index of that card 
+        in the list cards_constants.cards
+
+        but Spread does not check to make sure that the spread is a valid one
+        it simply puts the cards in the spread in order: base, sun, moon, etc.
+        the precise order is given by CardsOfTruth.context.cot_planet_order
+        the default is "vedic"; the other option is "solar_system"
+
+        it finds the proper planets given the spread type
+        i.e., for a birth spread, the birth planets, for a year spread, the planets at that solar return, etc.
+        and puts them into the "Sun" card, the "Moon" card, etc.
+
+        To test this out by itself, you can do this:
+        >>> CardsOfTruth().Spread(spread_list=[0,4,3,45,...])
+        where "spread_list" is a list of 14 integers between 0 and 51
+        you can also test out the planet order:
+        >>> CardsOfTruth().Spread(spread_list=[0,4,3,45,...],order="solar_system")
+
+        TODO: currently, Planet-s being put into cards is not implemented
+        """
+
+        def __init__(self, spread_list, master, which=0):
+            self._list = spread_list
+            self.master = master
+            self.context = self.master.context
+            # for all spreads besides natal, there is an option of which one you want
+            # e.g., for the year spread, "which" is which year
+            self.which = which
+            self._deck = Deck()
+            self._order = self.master.context.cot_planet_order
+            self._spread = self._init_Spread()
+
+        def __iter__(self):
+            return iter(self._spread)
+
+        def __getitem__(self, key):
+            if isinstance(key,str):
+                return self._spread[key]
+            else:
+                # get the planet key as a string from the correct planet order
+                # key here is an int, corresponding to the desired card
+                # 0 for the base card, 1 for sun, 2 for moon, etc.
+                return self._spread[cardsc.planet_order[self._order][key]]
+
+        def deck(self):
+            return self._deck
+
+        def spread(self):
+            return self._spread
+
+        def _init_Spread(self):
+            """
+            initialize the Spread, self._spread
+            a dictionary, "Planet": Card
+            also through __getitem__, Spread()[int] where int is the planet number appropriate to the system
+            """
+            spread = {}
+            for spread_position,planet_key in enumerate(cardsc.planet_order[self._order]):
+                # self._list = spread_list is a list of 14 cards in the proper positions starting from 0, the base card
+                # base card is list[0], sun is list[1], moon is list[2]
+                # for vedic mars is list[3], for solar_system mercury is list[3], etc.
+                # self._list[spread_position] as the int representation of the card at that position
+                # put this int into cardsc.cards to get the string version, e.g., "KD"
+                spread[planet_key] = self.deck()[cardsc.cards[self._list[spread_position]]]
+                # tell the Card which planet it is
+                # it uses this, for instance, to print the glyph of the planet in the header
+                spread[planet_key]._planet = planet_key
+                # with this above, we should be able to iterate over Spread regardless of the system
+            return spread
+
+
+        def _place_Objects(self):
+            """
+            it initializes those Planet-s into Spread
+            it adds these Planet-s to their proper Card in the Spread
+            so then we will have Spread().planets() and Spread()["Sun"] to see which Planet-s are in the Sun card
+            """
+            # here is where we will need to know the type of spread
+            # for instance, the year spread is based on the solar return
+            # so we will need to get the plaents for the proper solar return
+            for planet in self._planets:
+                # put this planet in the card of its lord
+                self.spread()[planet.lord()].set_attribute(("planets",planet))
+            for cusp in self._cusps:
+                # put this cusp in the card of its lord
+                self.spread()[cusp.lord()].set_attribute(("cusps",cusp))
+
+        def richDrawing(self):
+            spread = Table(box=box.SIMPLE)
+
+            spread.add_column(" ",justify="center",style="white")
+            spread.add_column(" ",justify="center",style="white")
+            spread.add_column(" ",justify="center",style="white")
+            spread.add_column(" ",justify="center",style="white")
+            spread.add_column(" ",justify="center",style="white")
+            spread.add_column(" ",justify="center",style="white")
+            spread.add_column(" ",justify="center",style="white")
+
+            spread.add_row(" "," "," ",self[0].richDrawing()," "," "," ")
+            spread.add_row(self[7].richDrawing(),self[6].richDrawing(),self[5].richDrawing(),self[4].richDrawing(),self[3].richDrawing(),self[2].richDrawing(),self[1].richDrawing())
+            spread.add_row(" "," ",self[9].richDrawing()," ",self[8].richDrawing()," "," ")
+            spread.add_row(" "," "," ",self[10].richDrawing()," "," "," ")
+            spread.add_row(" "," ",self[13].richDrawing(),self[12].richDrawing(),self[11].richDrawing()," "," ")
+
+            return spread
+
+        def rich(self):
+            from rich.console import Console
+            Console().print(self.richDrawing())
+
+    # the following are classes for specific kinds of spread
+    # the only difference is really how self._get_Planets() and self._get_Cusps() work
+    # this is where they get the appropriate planets and cusps and put them into the spread
+
+    class BirthSpread(Spread):
+
+        def __init__(self, spread_list, master, which=0):
+            super().__init__(spread_list, master)
+            self._planets = self._get_Planets()
+            self._cusps = self._get_Cusps()
+            self._place_Objects()
+
+        def _get_Planets(self):
+            """
+            get the correct Planets for this spread
+            right now, natal or solar return
+            """
+            return self.master.master.planets()
+
+        def _get_Cusps(self):
+            """
+            get the correct Cusps for this spread
+            right now, natal or solar return
+            """
+            return self.master.master.cusps()
+
+    class YearSpread(Spread):
+
+        def __init__(self, spread_list, master, which):
+            super().__init__(spread_list, master, which)
+            self._planets = self._get_Planets()
+            self._cusps = self._get_Cusps()
+            self._place_Objects()
+
+        def _get_Planets(self):
+            """
+            get the correct Planets for this spread
+            right now, natal or solar return
+            """
+            return self.master.master.solar_return(self.which).rashi().planets()
+
+        def _get_Cusps(self):
+            """
+            get the correct Cusps for this spread
+            right now, natal or solar return
+            """
+            return self.master.master.solar_return(self.which).rashi().cusps()
+
+    class DayQuadration(Spread):
+
+        def __init__(self, spread_list, master, which=0):
+            super().__init__(spread_list, master)
+            self._planets = self._get_Planets()
+            self._cusps = self._get_Cusps()
+            self._place_Objects()
+
+        def _get_Planets(self):
+            """
+            get the correct Planets for this spread
+            right now, natal or solar return
+            """
+            chart = self.master.master.master.timejd(self.context.timeJD.jd_number()+self.which)
+            return chart.rashi().planets()
+
+        def _get_Cusps(self):
+            """
+            get the correct Cusps for this spread
+            right now, natal or solar return
+            """
+            chart = self.master.master.master.timejd(self.context.timeJD.jd_number()+self.which)
+            return chart.rashi().cusps()

libaditya/cards/cot.py

@@ -0,0 +1,142 @@
+#
+#    Copyright (c) 2025 Josh Harper <humanhaven@substack.com>
+#
+#    libaditya is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Affero General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    libaditya is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Affero General Public License for more details.
+#
+#    You should have received a copy of the GNU Affero General Public License
+#    along with libaditya.  If not, see <https://www.gnu.org/licenses/>.
+
+from libaditya.cards import cards_constants as cardsc
+
+def getindex(card):
+    """Get the index number of the birth card from the Jack Quadration"""
+    return cardsc.cards.index(card)
+
+class CoT:
+    """
+    CoT is a class of static methods that provide most of the basic cot calculation functionality
+
+    this is a Mixin, having no __init__() method
+
+    you can use these methods through CardsOfTruth, the class this inherits unto, e.g.,:
+    >>> CardsOfTruth().queen_quadration()
+    """
+
+    @staticmethod
+    def jack_quadration():
+        return cardsc.jackquad
+
+    @staticmethod
+    def queen_quadration():
+        return CoT.quadrate(cardsc.jackquad)
+
+    @staticmethod
+    def king_quadration():
+        return CoT.quadrate(CoT.queen_quadration())
+
+    @staticmethod
+    def quadrate(tquad):
+        """
+        tquad is the deck that you want to quadrate
+        """
+        # say we are starting with the jack quadration
+        # we pick up the AH, put 2H on top of that, 3H on top, etc. until KS is on the top
+        # then we turn the deck over and start from the top, which is now AH
+        # this is why I have made AH=1(0) and KS=52(51)
+        quad=tquad.copy() # so that i dont have to pass a copy of the quadration to this function
+        # first we need to take the top four cards together and put them in one pile
+        pile1 = []
+        pile2 = []
+        pile3 = []
+        pile4 = []
+        # the new pile needs to go on, i.e., the last element of the new next to the first element of the bottom one
+        while len(quad) > 4: 
+            pile1 = cardsc.topthree(quad)+pile1
+            pile2 = cardsc.topthree(quad)+pile2
+            pile3 = cardsc.topthree(quad)+pile3
+            pile4 = cardsc.topthree(quad)+pile4
+            
+        pile1=[quad.pop(0)]+pile1
+        pile2=[quad.pop(0)]+pile2
+        pile3=[quad.pop(0)]+pile3
+        pile4=[quad.pop(0)]+pile4
+
+        # now we have four piles. now we need to put the second on top of the first
+        # we can use quad since we popped all of its item off
+        quad = (pile4+(pile3+(pile2+pile1)))
+
+        # now we put the first card into the first pile, the second into the second, etc.
+        # until there are no more cards
+
+        # make sure our piles are empty
+        pile1 = []
+        pile2 = []
+        pile3 = []
+        pile4 = []
+        
+        while len(quad):
+            pile1=[quad.pop(0)]+pile1
+            pile2=[quad.pop(0)]+pile2
+            pile3=[quad.pop(0)]+pile3
+            pile4=[quad.pop(0)]+pile4
+
+        quad = (pile4+(pile3+(pile2+pile1)))
+
+        # this should be the next quadration. we dont have to deal with turning the deck over here
+        # as long as everything was done correctly
+        
+        return quad
+
+    @staticmethod
+    def quadraten(nquad,n):
+        while n:
+            nquad=CoT.quadrate(nquad.copy())
+            n=n-1
+        return nquad
+
+
+    @staticmethod
+    def getbspreadwxcfromquad(card,pos,quad):
+        """get the birth spread from quad where card is in pos"""
+        """0 is the birth card position, 1 is the sun card, 9 is rahu card, 13 is pluto card, etc."""
+        cindex=quad.index(getindex(card)) # this is where the card is in the quadration
+        # we want to get the birth spread for which card is in pos
+        # so if pos is 0, we can simply call getbirthspreadfromquad(card,quad)
+        # if pos is not 0, we want to find the card that would be in the 0 pos in quad
+        # say pos is 4, then 4-4=0 is the birth card
+        # cindex is the index of the desired card in the quad
+        # so cindex-pos is the index of the birth card
+        # if cindex-pos>=0 this is fine, we can call getbirthspreadfromquad(cindex-pos,quad)
+        # otherwise, if cindex-pos=-1, then the index is actually 51, i.e, 52-1
+        if cindex-pos>=0:
+            return CoT.get_birthspread_from_quadration(cardsc.cards[quad[cindex-pos]],quad)
+        else:
+            return CoT.get_birthspread_from_quadration(cardsc.cards[quad[52-(cindex-pos)]],quad)
+
+    @staticmethod
+    def get_birth_spread_with_card_in_position(card,pos):
+        """
+        get a birth spread where card is in pos#
+        0 is the birth card, 2 is the moon card, 7 is the saturn card, etc.
+        """
+        return CoT.getbspreadwxcfromquad(card,pos,CoT.queen_quadration())
+
+    @staticmethod
+    def get_birthspread_from_quadration(birthcard,quad=None):
+        """birthcard is two characters that indicate the birth card, eg., 'AS', ace of spades"""
+        """so we need to get that card and the next 13 cards from the Queen Quadration"""
+        if quad is None:
+            quad = CoT.queen_quadration()
+        bc=quad.index(getindex(birthcard))
+        bspread=[]
+        for x in range(bc,bc+14):
+            bspread.append(quad[x%52])
+        return bspread

libaditya/cards/deck.py

@@ -0,0 +1,52 @@
+#
+#    Copyright (c) 2025 Josh Harper <humanhaven@substack.com>
+#
+#    libaditya is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Affero General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    libaditya is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Affero General Public License for more details.
+#
+#    You should have received a copy of the GNU Affero General Public License
+#    along with libaditya.  If not, see <https://www.gnu.org/licenses/>.
+
+from libaditya.cards import cards_constants as cardsc
+from libaditya.cards.card import Card
+
+class Deck:
+    """
+    could this also be a tarot deck, or would that be different?
+    but tarot doesnt use planets, so it doesnt really have any astrology in it
+    """
+
+    def __init__(self, deck_type="52 playing cards"):
+        self._deck_type = deck_type
+        self._deck = self._init_Deck()
+
+    def __iter__(self):
+        return iter(self._deck)
+
+    def __getitem__(self, card: str):
+        return self._deck[card]
+
+    def deck(self):
+        return self._deck
+
+    def index(self, card):
+        return self._deck.index(card)
+
+    def _init_Deck(self):
+        """
+        a dictionary of 52 k-v pairs: "Card": Card
+        i.e., key-constructor
+        """
+        deck = {}
+
+        for index,card in enumerate(cardsc.cards):
+            deck[card] = Card(card,index)
+
+        return deck

libaditya/charts/__init__.py

@@ -0,0 +1,6 @@
+from libaditya.objects import *
+from .api import API
+from .chart import Chart
+from .jaimini import Jaimini
+from .tajika import Tajika
+

libaditya/charts/api.py

@@ -0,0 +1,36 @@
+#    This file is part of libaditya.
+#
+#    Copyright (c) 2025 Josh Harper <humanhaven@substack.com>
+#
+#    libaditya is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Affero General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    libaditya is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Affero General Public License for more details.
+#
+#    You should have received a copy of the GNU Affero General Public License
+#    along with libaditya.  If not, see <https://www.gnu.org/licenses/>.
+
+from dataclasses import replace
+from typing import Self
+
+class API:
+    """
+    Mixin class for Chart api
+    """
+
+    def ayanamsa(self):
+        return self.context.ayanamsa
+
+    def ascendant(self):
+        return self.rashi().lagna()
+
+    def nakshatra(self):
+        """
+        this returns a Nakshatra object
+        """
+        return self.rashi().planets().moon().nakshatra()

libaditya/charts/bodygraph.py

@@ -0,0 +1,80 @@
+#    This file is part of libaditya.
+#
+#    Copyright (c) 2025 Josh Harper <humanhaven@substack.com>
+#
+#    libaditya is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Affero General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    libaditya is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Affero General Public License for more details.
+#
+#    You should have received a copy of the GNU Affero General Public License
+#    along with libaditya.  If not, see <https://www.gnu.org/licenses/>.
+
+from dataclasses import replace
+from typing import Self
+
+from libaditya.objects import Planets
+import libaditya.constants as const
+from libaditya.hd import calc as hdcalc
+from libaditya.hd import constants as hdc
+
+from libaditya.draw.draw_bodygraph import DrawBodyGraph
+
+
+class Bodygraph(DrawBodyGraph):
+    """
+    by calculation, a bodygraph is simply a set of planets
+    the conscious planets are the birth planets, in this order:
+    Sun, Earth, Moon, Rahu, Ketu, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto, Chiron (doesn't activate gate)
+    the unconscious planets are the planets at the time when the Sun was 88 degrees before the birth placement
+    the dream planets are the planets at the time the Moon was 88 degrees before the birth placement
+
+    this can draw a bodygraph
+
+    use Bodygraph().draw_svg(outfile="(optional; default is {Bodygraph().context.name}.svg)")
+    """
+
+    def __init__(self, context):
+        self.context = context
+        self._conscious_planets = Planets(self.context)
+        self._unconscious_context = hdcalc.unconscious_context(self.context)
+        self._unconscious_planets = Planets(self._unconscious_context)
+        self._dream_context = hdcalc.dream_context(self.context)
+        self._dream_planets = Planets(self._dream_context)
+
+    def conscious_planets(self):
+        return self._conscious_planets
+
+    def unconscious_planets(self):
+        return self._unconscious_planets
+    
+    def planets(self):
+        return self.conscious_planets().hd_planets() + self.unconscious_planets().hd_planets()
+
+    def conscious_gates(self,chiron=True):
+        return self.conscious_planets().gates(chiron)
+
+    def unconscious_gates(self,chiron=True):
+        return self.unconscious_planets().gates()
+
+    def all_gates(self,chiron=False):
+        """
+        get all_gates that should be activated in the bodygraph
+        """
+        return self.conscious_gates(chiron) + self.unconscious_gates(chiron)
+
+    def dream_planets(self):
+        """
+        these are the unconscious dream planets, since the conscious ones for the dreamgraph
+        are the same as the conscious ones for the bodygraph
+        """
+        return self._dream_planets
+
+    def _new_bodygraph(self, **kwargs):
+        return Bodygraph(context=replace(self.context,**kwargs))
+