libaditya 0.3.4__py2.py3-none-any.whl

libaditya/stars/fixed_star.py

@@ -0,0 +1,216 @@
+#    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/>.
+
+import swisseph as swe
+
+from libaditya import constants as const
+from libaditya import utils
+
+from libaditya.objects import Longitude, CelestialObject, EphContext
+
+from libaditya.stars.stellarium import Stellarium
+
+def correct_nomen_name(swe_id):
+    # take care of cases like ,And14
+    # the proper nomen name is ,14And
+    # these is only for names that have numbers in them
+    if "," in swe_id:
+        # remove initial comma if there
+        swe_id = swe_id[1:]
+    # the next lines transform a Flamsteed designation of Namennn to nnnName, where there are 1-3 n's in [0,9]
+#    if swe_id[-3:].isnumeric():
+#        return ","+swe_id[-3:]+swe_id[:-3]
+#    if swe_id[-2:].isnumeric():
+#        if swe_id[-2:] == "00":
+#            # for GCRS00
+#            return ","+swe_id
+#        return ","+swe_id[-2:]+swe_id[:-2]
+#    if swe_id[-1:].isnumeric():
+#        return ","+swe_id[-1:]+swe_id[:-1]
+    # make sure there is a comma for swe
+    return ","+swe_id
+
+
+# if you want a Stellarium star
+# include "st:" at the beginning of swe_id
+# and pass "rc", a stars.stellarium.stellarium.Stellarium instance, which is the connection to Stellarium
+
+class FixedStar(CelestialObject,Longitude):
+    """
+    initialize a FixedStar through the Swiss Ephemeris
+    all available stars are listed in libaditya/ephe/sefstars.txt
+    swe_id must be the "nomenclature" name
+    each star has a one-line entry in sefstars.txt
+    the nomenclature name is the second entry, e.g.,:
+    Alpha Canis Majoris,alfCMa,ICRS,06,45,08.91728,-16,42,58.0171,-546.01,-1223.07,-5.50,379.21,-1.46
+    
+    alfCMa is the "nomenclature" name that you should use to initialize FixedStar
+
+    in the original sefstars.txt, the first field is a "traditional" name, in this case Sirius
+    the swe fixed star function can "search" this field. So if it doesn't find a star based on the nomenclature name, then it
+    will find the first star the matches what was input
+
+    you can call FixedStar this way
+    right now, all the "traditional" names have been change to long form forms of the nomenclature names
+
+    most of the nomenclature names are the Bayer designation, which consists of a greek letter and a Latin gentitive for the constellation
+    some other designations are used as the swe_id/nomenclature name, and these expand to long form names as well, e.g., "HIP" into "Hipparcos Catalogue"
+
+    in sefstars.txt, there is now a line above each star entry that contains other names of this star
+    so a complete entry looks like this:
+
+    #0# alfCMa,  Alpha Canis Major,  Sirius,  HIP 32349
+    Alpha Canis Majoris,alfCMa,ICRS,06,45,08.91728,-16,42,58.0171,-546.01,-1223.07,-5.50,379.21,-1.46
+
+    soon, FixedStar will parse the names of the info line that begins with #0# and add those names to itself,
+    which will be retrievable through FixedStar().other_names()
+    and maybe there will be a way to initialize FixedStar through the use of those names, but not right now
+
+    stars can be added by using the script libaditya/ephe/make_swe_star.py
+    """
+
+    def __init__(self, swe_id: str, context: EphContext = EphContext(), rc: Stellarium = None, swe_string=""):
+        self.context = context
+        self.system = self.context.sysflg
+        self.sysflg = self.system | swe.FLG_SPEED
+        self._other_names = ""
+        self._swe_string = swe_string
+        # swe_id is the nomenclature name of the star
+        # can pass it with or without comma
+        self._stellarium = False
+        if "st:" in swe_id:
+            # swe_id = "st:Omi Tau"
+            # or "st: HIP 19500"
+            # indicates this is a stellarium star
+            self._swe_id = swe_id.split(":")[1].strip()
+            self._stellarium = True
+            # called "rc", but is not a stellarium.remote_control.RemoteControl object
+            # it is a Stellarium object initialized by someone else to get this information
+            # initialized by the TheStars()
+            self.rc = rc
+            # now initialize all of the information
+            self.init_Stellarium()
+            super().__init__(self.long,1,context)
+            # done with this __init__
+            return
+        self._swe_id = correct_nomen_name(swe_id)
+        try:
+            # if it works, the swe_id is valid
+            swe.fixstar2_ut(self._swe_id,self.context.timeJD.jd_number())
+        except:
+            # if not, assume it is a search
+            # so remove "," from beginning, add "%" to end for wildcard
+            self._swe_id = self._swe_id[1:]+"%"
+        # self._coords is a 6-tuple
+        # will be unpacked into FixedStar.longitude(), etc., for each value in the tuple
+        (self.long, self.lat, self.dist, self.long_speed, self.lat_speed, self.dist_speed), self._name, self._retflags = self.init_coords()
+        self.dist_ly = 0 # convert self.dist in AUs to LYs
+        self._name, self.returned_swe_id = self._name.split(",")
+        (self._right_ascension, self._declination, self._equatorial_distance,_,_,_) = swe.fixstar2_ut(self.swe_id(),self.context.timeJD.jd_number(),swe.FLG_EQUATORIAL)[0]
+        if "%" in self._swe_id:
+            self._swe_id = self.returned_swe_id
+        self.attributes = {"constellation": "n/a"}
+        # now that we know which star this is, make sure it has the right swe_id()
+        # super() means Longitude. CelestialObject is a Mixin and has no __init__ method of its own
+        # it is basically just a holder for shared code between Planet and FixedStar
+        # ...things that apply to both of them as CelestialObjects
+        super().__init__(self.long,1,context)
+
+
+    def init_coords(self):
+        loc = self.context.location.swe_location()
+        # the if statements are returnless statements that initialize swe
+        # sysflg is definited in __init__; it is self.system + swe.FLG_SPEED
+        # so that we always get the speed
+        if self.system == const.SID:
+            # will need to add custom ayanamsas here
+            if self.ayanamsa() == 98:
+                self._ayanamsa = 36
+            if self.ayanamsa() == 97:
+                utils.set_swe_true_sidereal_ayanamsa()
+        if self.system == const.TOPO:
+            swe.set_topo(loc[0], loc[1], loc[2])
+        if self.system == (const.SID | const.TOPO):
+            swe.set_sid_mode(self.ayanamsa())
+            swe.set_topo(loc[0], loc[1], loc[2])
+        return swe.fixstar2_ut(self.swe_id(), self.context.timeJD.jd_number(), self.sysflg if self.sysflg >= 0 else 0)
+
+    def __eq__(self, fs2):
+        """
+        are these the same kind of object?
+        they could both be Aldebaran but 4000 years apart; they would still be == with this function
+        """
+        return self.swe_id() == fs2.swe_id()
+
+    def other_names(self):
+        return self._other_names
+
+    def retflags(self):
+        self._retflags
+
+    # longitude is taken care of by inheritor, Longitude
+
+    def name(self):
+        return self._name
+
+    def stellarium(self):
+        return self._stellarium
+
+    def swe_id(self):
+        return self._swe_id
+
+    def identity(self):
+        return self.swe_id()
+        
+    def magnitude(self):
+        return swe.fixstar2_mag(self.swe_id())[0]
+
+    def init_Stellarium(self):
+        """
+        self.swe_id() should be a valid stellarium object, probably HIP
+
+        need to deal with sidereal in here, so we only get the ecliptic longitude
+        """
+        try:
+            self.rc.change_context(self.context)
+            info = self.rc.info(self.swe_id())        
+        except:
+            print("Stellarium not available...")
+            return
+        self.long = info["elong"]
+        self.lat = info["elat"]
+        try:
+            self.dist = info["distance-ly"]
+        except:
+            self.dist = 0
+        self.dist_ly = self.dist
+        self.long_speed = self.lat_speed = self.dist_speed = 0
+        self._name = info["name"]
+        self._right_ascension = info["ra"] 
+        self._declination = info["dec"]
+        self._equatorial_distance = self.dist
+        self._altitude = info["altitude"]
+        self._azimuth = info["azimuth"]
+        # these will be in local time, so think about time switching?
+        # make FixedStar.rise() which will catch Stellarium stars, if not, send them to CelestialObject.rise()
+        self._rise = info["rise"]
+        self._set = info["set"]
+        self._info = info
+        return
+
+    def info(self):
+        return self._info

libaditya/stars/make_swe_stars.py

@@ -0,0 +1,407 @@
+#    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/>.
+
+import argparse
+
+# constants that need to be defined first
+
+# if swe_id is lllUll then it is a Bayer designation
+# where lll is a greek letter and Ull is a constellation abbreviation (for the Latin genitive)
+# U(ll) is for other things, e.g., VC for Virgo Cluster, HIP for Hipparcos Catalogue number, etc.
+# nnUll is a Flamsteed designation and will end up as ConstNN in Python
+# e.g., ,48Lib becomes Librae48()
+star_names_short_to_long = {
+    "greek": {
+        # note: simbad returns two-letter names with an additional "."
+        # e.g., "mu.Sgr"
+        # not all the letters of the greek alphabet
+        # just those used in Bayer designations
+        "alf": "Alpha",
+        "bet": "Beta",
+        "gam": "Gamma",
+        # for one star that had some weird stuff happen to it
+        "g": "Gamma",
+        "del": "Delta",
+        # for dOph -> d Ophiuci? just because?
+        "d": "Delta",
+        "eps": "Epsilon",
+        "zet": "Zeta",
+        "eta": "Eta", # but no stars with that letter
+        "tet": "Theta",
+        "iot": "Iota",
+        "kap": "Kappa",
+        "lam": "Lambda",
+        "mu.": "Mu",
+        "nu.": "Nu",
+        "ksi": "Xi",
+        "omi": "Omicron",
+        # it seems simbad may use "pi." to have three letters?
+        "pi.": "Pi",
+        "rho": "Rho",
+        "sig": "Sigma",
+        "tau": "Tau",
+        "ups": "Upsilon",
+        "phi": "Phi",
+        "chi": "Chi",
+        "psi": "Psi",
+        "ome": "Omega",
+    },
+    "constellations": {
+        "Ari": "Arietis",
+        "Tau": "Tauri",
+        "Gem": "Geminorum",
+        "Cnc": "Cancri",
+        "Leo": "Leonis",
+        "Vir": "Virginis",
+        "Lib": "Librae",
+        "Sco": "Scorpii",
+        "Oph": "Ophiuci",
+        "Sgr": "Sagittarii",
+        "Cap": "Capricorni",
+        "Aqr": "Aquarii",
+        "And": "Andromedae",
+        "Ant": "Antilae",
+        "Aps": "Apodis", # Apus constellation
+        "Ara": "Arae",
+        "Psc": "Piscium",
+        "Eri": "Eridani",
+        "Cae": "Caeli",
+        "Cam": "Camelopardalis",
+        "Cas": "Cassiopeiae",
+        "Cen": "Centauri",
+        "Cep": "Cephei",
+        "UMa": "Ursae Majoris",
+        "UMi": "Ursae Minoris",
+        "Aql": "Aquilae",
+        "Hyd": "Hydrae",
+        "Sct": "Scuti",
+        "Sex": "Sextantis",
+        "Sge": "Sagittae",
+        "Boo": "Bootis",
+        "Dra": "Draconis",
+        "Del": "Delphini",
+        "Dor": "Doradus",
+        "Equ": "Equulei",
+        "For": "Fornacis", # Fornax constellation
+        "Cyg": "Cygni",
+        "Gru": "Gruis",
+        "Ori": "Orionis",
+        "Cet": "Ceti",
+        "Cha": "Chamaeleontis", # Chamaeleon constellation
+        "Cir": "Circini", # Circinus constellation
+        "Col": "Columbae",
+        "Com": "Comae Berenices",
+        "CrB": "Coronae Borealis",
+        "CrA": "Coronae Australis",
+        "TCrB": "TCoronae Borealis",
+        "Crt": "Crateris",
+        "Cru": "Crucis",
+        "Crv": "Corvi",
+        "CVn": "Canum Venaticorum",
+        "CMa": "Canis Majoris",
+        "CMi": "Canis Minors",
+        "Aur": "Aurigae",
+        "Car": "Carinae",
+        "Lyr": "Lyrae",
+        "Lep": "Leporis",
+        "Men": "Mensae",
+        "Mic": "Microscopii",
+        "Mon": "Monocerotis",
+        "Mus": "Muscae",
+        "Nor": "Normae",
+        "Oct": "Octantis",
+        "Ind": "Indi",
+        "Pav": "Pavonis",
+        "Peg": "Pegasi",
+        "Phe": "Phoenicis",
+        "LMi": "Leonis Minoris",
+        "Lup": "Lupi",
+        "Lyn": "Lyncis",
+        "Ser": "Serpentis",
+        "Tel": "Telescopium",
+        "TrA": "Trianguli Australis",
+        "Tri": "Trianguli",
+        "Tuc": "Tucanae",
+        "Her": "Herculis",
+        "Hor": "Horologii",
+        "Hya": "Hydrae",
+        "Hyi": "Hydri",
+        "Lac": "Lacertae",
+        "Per": "Persei",
+        "Pic": "Pictoris",
+        "PsA": "Piscis Austrini",
+        "Pup": "Puppis",
+        "Pyx": "Pyxis",
+        "Ret": "Reticulum",
+        "Scl": "Sculptoris",
+        "Vel": "Velorum", # Vela, contains Vela supercluster
+        "Vol": "Volantis",
+        "Vul": "Vulpeculae",
+        "VC": "Virgo Cluster",
+        "M": "Messier Object",
+        "NGC": "New General Catalogue",
+        "HIP": "Hipparcos Catalogue",
+        "HR": "Bright Star Catalogue",
+        "HD": "Henry Draper Catalogue",
+    }
+}
+
+def main():
+    args, argparser = get_args()
+
+    # if they dont pass any stars, print help message
+    if not args.stars:
+        argparser.print_help()
+        exit()
+
+    stars = []
+
+    for star in args.stars:
+        # only want the star lines; swe_make_star also returns the simbad ascii response
+        swe_star = swe_make_star(star)[0]
+        info_line = swe_star[0]
+        star_line_long_form_nomen = swe_star[1]
+        long_form_nomen = star_line_long_form_nomen.split(",")[0]
+        # now append the correct lines into outlines
+        star_line_split = star_line_long_form_nomen.split(",")[1:]
+        nomen = star_line_split[0]
+        # append nomen line first, then long_form, the eac name on the info line in order
+        info_line = info_line.split(",")
+        info_line.insert(2, " "+long_form_nomen)
+        info_line = ",".join(info_line)
+        stars.append(info_line)
+        stars.append(",".join([nomen]+star_line_split))
+        stars.append(star_line_long_form_nomen)
+        info_line = info_line.split(",")[1:]
+        for name in info_line:
+            # sometimes there are no more names, which appears as either empty string or a string of spaces, which .strip() converts to empty string, essentially
+            if name.strip() == "":
+                continue
+            if name.strip() == "no hip id":
+                continue
+            stars.append(",".join([name.strip()]+star_line_split))
+
+    if args.output_file:
+        with open(args.output_file,"a") as outfd:
+            outfd.writelines(stars)
+        exit()
+
+    print("".join(stars))
+
+
+def swe_make_star(names=[""]) -> [str]:
+    """
+    make an entry for ephe/sefstars.txt to add star "name" to that file, and thus to swe
+    returns a list [sefstars.txt_entry,simbad_response_str]
+    """
+    import urllib.request
+    from string import Template
+    simbad_query = Template("https://simbad.cds.unistra.fr/simbad/sim-id?Ident=$swe_id&NbIdent=1&Radius=2&Radius.unit=arcmin&submit=submit%20id&output.format=ASCII")
+    swe_star_entry = Template("$trad_name,$nomen_name,ICRS,$ra_hour,$ra_minute,$ra_sec,$dec_degree,$dec_minute,$dec_sec,$pmra,$pmde,$rad_vel,$parallax,$magnitude_V")
+    if not isinstance(names,list):
+        names=[names]
+    ret = []
+    for name in names:
+        name = name.replace(" ","+")
+        the_bytes = urllib.request.urlopen(simbad_query.substitute(swe_id=name))
+        ascii = the_bytes.read().decode()
+#            lines=the_bytes.read().decode().split("\n")
+#            for n,line in enumerate(lines):
+#                print(n,line)
+        # now parse bytes into all the variables needs for swe_star_entry
+        response = parse_simbad_ascii_response(ascii)
+        try:
+            ids,trad_name,nomen_name,ra_hour,ra_minute,ra_sec,dec_degree,dec_minute,dec_sec,pmra,pmde,rad_vel,parallax,magV = response
+        except:
+            print("Error: \n")
+            print(response)
+            return
+        id_line = f"#0# {nomen_name.replace(",","")}, "
+        id_line += str(ids[1]+", "+ids[0]+"\n")
+        ret.append(id_line)
+        ret.append(f"{nomen_to_long_form(nomen_name)}{nomen_name},ICRS,{ra_hour},{ra_minute},{ra_sec},{dec_degree},{dec_minute},{dec_sec},{pmra},{pmde},{rad_vel},{parallax},{magV}\n")
+    return ret, ascii
+
+
+def swe_write_stars(names=[""],outfile=""):
+    """
+    take a list of objects ids, names
+    write out to a file their entries for ephe/sefstars.txt
+    """
+    lines=[]
+    for name in names:
+        returns, ascii=swe_make_star(name)
+#        print(f"sws: {returns[0]=} {returns[1]=}")
+        lines.append(returns[0])
+        lines.append(returns[1])
+#    print(f"{lines=}")
+    with open(outfile,"a") as fd:
+        fd.writelines(lines)
+    return
+
+def parse_simbad_ascii_response(response: str):
+    """
+    response is the http_response itself
+    """
+    lines = response.split("\n")
+    #import pdb; pdb.set_trace()
+    magV = None
+    parallax = None
+    hipid = "no hip id"
+    name = ""
+    nomen_name = ",noMen"
+    for n,line in enumerate(lines):
+        if n > 28:
+            # find HIP id so we can return it first as well
+            for n in range(28,50):
+                if n >= len(lines):
+                    break
+                if "HIP" in lines[n]:
+                    line = lines[n].split()
+                    for i,element in enumerate(line):
+                        if element == "HIP":
+                            hipid = element+" "+line[i+1]
+                if "NAME" in lines[n]:
+                    line = lines[n].split()
+                    for i,element in enumerate(line):
+                        if element == "NAME":
+                            name = line[i+1]
+            break
+        match n:
+            case 2:
+                trad_name = str(line)
+            case 5:
+                names = line.split(" ")
+                # try to guess the ,noMen name
+                nomen_name = ","+names[2]+names[3]
+            case 7:
+                # icrs coordinates
+                icrs = line.split(" ")
+                ra_hour = icrs[1]
+                ra_minute = icrs[2]
+                ra_sec = icrs[3]
+                dec_degree = icrs[5]
+                dec_minute = icrs[6]
+                dec_sec = icrs[7]
+            case 11:
+                pm = line.split(" ")
+                pmra = pm[2]
+                pmde = pm[3]
+            case 13:
+                rad_vel = line.split(" ")
+                rad_vel = rad_vel[2]
+            case 12:
+                para = line.split(" ")
+                parallax = para[1]
+        if "Flux V" in line:
+            flux = line.split(" ")
+            magV = flux[3]
+    if not magV:
+        magV = 0
+    try:
+        return [hipid,name],trad_name,nomen_name,ra_hour,ra_minute,ra_sec,dec_degree,dec_minute,dec_sec,pmra,pmde,rad_vel,parallax,magV
+    except:
+        return response
+
+def nomen_to_long_form(nomen: str):
+    """
+    turn a nomenclature name into a long form version of itself
+    nomenclature names, any of these designations:
+    Bayer, Falmsteed, HIP, NGC, HD, HR, M (Messer Object)
+    greek is lowercase greek letter, will use upper case in English
+    Latin is genitive of Latin constellation name
+    e.g., alfTau, Alpha Tauri, α Tauri
+    """
+    if nomen[0] == ",":
+        nomen = nomen[1:]
+    if nomen[0].isnumeric():
+        # this means it is Flamsteed 
+        # easiest to do this first
+        number=""
+        n=0
+        while nomen[n].isnumeric():
+            number+=nomen[n]
+            n+=1
+        constellation=""
+        while n < len(nomen):
+            constellation+=nomen[n]
+            n+=1
+        return star_names_short_to_long["constellations"][constellation]+number
+    # check if this is a "special constellation"
+    # not really constellations, but fill the same place in the nomen name, so are treated the same for this purpose
+    special_constellations = ["VC","HD","HR","HIP","NGC"]
+    # doesnt include "M" because that throws off other checks
+    special = None
+    for constellation in special_constellations:
+        number=""
+        if constellation in nomen.upper() or (nomen.upper().startswith("M") and "mu." not in nomen):
+            # if one of these special tags is here, special will show us that it is
+            if nomen.upper().startswith("M"):
+                special = "M"
+                number = nomen[1:]
+            else:
+                special = constellation
+                # the rest of the string except the "constellation" names
+                number = nomen[(len(special)):]
+            break
+    if number != "":
+        return star_names_short_to_long["constellations"][special]+f" {number.strip()}"
+    if number == "":
+        if special == "VC":
+            return star_names_short_to_long["constellations"][special]
+    # now assume it is a Bayer designation
+    # some in the original sefstars.txt have a hyphen "-" in the name
+    # replace that with 0
+    # first three letters are the greek
+    greek = nomen[:3]
+    # last three are the Latin constellation
+    latin = nomen[3:]
+    # sometimes there are two stars with the same name basically, one is, e.g., gam01Sgr, the other, gam02Sgr
+    # this will be Gamma Sagittarii 1 and Gamma Sagittarii 2
+    number = ""
+    if latin[:2].isnumeric():
+        number = latin[:2]
+        latin = latin[2:]
+    if not greek.islower():
+        return nomen
+    if number:
+        return star_names_short_to_long["greek"][greek]+" "+star_names_short_to_long["constellations"][latin]+f" {number}"
+    return star_names_short_to_long["greek"][greek]+" "+star_names_short_to_long["constellations"][latin]
+
+def get_args():
+    parser = argparse.ArgumentParser(
+        prog="make_swe_stars.py",
+        usage="%(prog)s [stars]: [stars] is a space-separated list. For star names with spaces, use quotation marks: \"Alpha Ursae Minoris\"",
+        description="make sefstars.txt entry for specified stars",
+    )
+    parser.add_argument(
+        "-o",
+        "--output-file",
+        help="write entries to output-file. otherwise, writes to stdout",
+    )
+#    parser.add_argument(
+#        "-Z",
+#        "--zodiac",
+#        action="store_true",
+#        help="toggle use of zodiac signs; can set default variable 'signs' in defaults.py",
+#    )
+    parser.add_argument("stars", nargs='*', help="stars to make entries for. you can enter multiple as a space separated list. if the name itself has a space in it, surround whole name with double-quotes: e.g., $ python make_swe_stars.py Sirius \"HIP 34567\" M87 \"Zeta Ursae Minoris\"") 
+    args = parser.parse_args()
+    return args, parser
+
+if __name__ == "__main__":
+    main()

libaditya/stars/star-sign-boundaries

@@ -0,0 +1,44 @@
+https://masteringthezodiac.com/midpoint-method
+all longitudes J2000
+when using swe, set sid mode to 18, J2000
+and call swe.fixstar with swe.FLG_SIDEREAL
+
+Aries
+	Mesarthim ,gaAri
+	Botein	,deAri
+Taurus
+	Omicron Tauri ,omiTau 51.1675 HIP 15900
+	Tianguan	,zeTau
+Gemini
+	1 Geminorum 90.9519 HIP 28734
+	Kappa Geminorum 113.6714
+Cancer
+	Chi Cancri 120.9783
+	Acubens	,alCnc
+Leo
+	Al Minlear - Kappa Leonis 135.3008
+	Denebola ,beLeo
+Virgo
+	Nu Virginis 174.1608
+	Rijl al Awwa ,muVir
+Libra
+	Zubenelgenubi ,al-2Lib
+	48 Librae 240.3950
+Scorpio
+	Dschubba ,deSco
+	Paikauhale 240.3950
+Ophiucus
+	Sabik ,etOph
+	45 Ophiuci 262.8753
+Sagittarius
+	Alnasl ,ga-2Sgr
+	Terebellium ,omeSgr
+Capricorn
+	Dabih ,beCap
+	Deneb Algedi ,deCap
+Aquarius
+	Iota Aquarii 328.7161	
+	Phi Aquarii 347.1364
+Pisces
+	Gamma Piscium 351.4514	
+	Alrescha ,alPsc

libaditya/stars/stellarium/__init__.py

@@ -0,0 +1,6 @@
+from .stellarium import Stellarium
+# RemoteControl is the package StellariumRC
+# i changed the class Stellarium to RemoteControl, that is the only difference
+# i copied and pasted the one directory of code into remote_control
+# the license is mit, even though known of the file have the license in them
+from .remote_control import RemoteControl