libaditya 0.3.4__py2.py3-none-any.whl

libaditya/stars/stellarium/remote_control/__init__.py

@@ -0,0 +1,22 @@
+# 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 . import main,objects,scripts,simbad,stelaction,stelproperty,location,locationsearch,view
+
+class RemoteControl:
+    def __init__(self, ip="127.0.0.1", port=8090, password="") -> None:
+        self.password = password
+        self.ip = ip
+        self.port = port
+        self.main = main.Main(self.ip, self.port, self.password)
+        self.objects = objects.Objects(self.ip, self.port, self.password)
+        self.scripts = scripts.Scripts(self.ip, self.port, self.password)
+        self.simbad = simbad.Simbad(self.ip, self.port, self.password)
+        self.stelaction = stelaction.StelAction(self.ip, self.port, self.password)
+        self.stelproperty = stelproperty.StelProperty(self.ip, self.port, self.password)
+        self.location = location.Location(self.ip, self.port, self.password)
+        self.locationsearch = locationsearch.LocationSearch(self.ip, self.port, self.password)
+        self.view = view.View(self.ip, self.port, self.password)
+        

libaditya/stars/stellarium/remote_control/location.py

@@ -0,0 +1,82 @@
+import requests
+
+class Location:
+    def __init__(self, ip="127.0.0.1", port=8090, password=""):
+        self.ip = ip
+        self.port = port
+        self.password = password
+    
+    def listLocations(self):
+        """
+        Returns the list of all stored location IDs (keys of StelLocationMgr::getAllMap) 
+        as JSON string array.
+        """
+        r = requests.get(f"http://{self.ip}:{self.port}/api/location/list",
+                         auth=("",self.password))
+        try:
+            return r.json()
+        except requests.exceptions.JSONDecodeError:
+            raise Exception(r.text)
+        
+    def listCountries(self):
+        """
+        Returns the list of all known countries (StelLocaleMgr::getAllCountryNames), as a 
+        JSON array of objects of format.
+        """
+        r = requests.get(f"http://{self.ip}:{self.port}/api/location/countrylist",
+                         auth=("",self.password))
+        try:
+            return r.json()
+        except requests.exceptions.JSONDecodeError:
+            raise Exception(r.text)
+        
+    def listPlanets(self):
+        """
+        Returns the list of all solar system planet names (SolarSystem::getAllPlanetEnglishNames), 
+        as a JSON array of objects of format
+        """
+        r = requests.get(f"http://{self.ip}:{self.port}/api/location/planetlist",
+                         auth=("",self.password))
+        try:
+            return r.json()
+        except requests.exceptions.JSONDecodeError:
+            raise Exception(r.text)
+        
+    def planetImage(self,planet):
+        """
+        Returns the planet texture image for the planet (english name)
+        """
+        r = requests.get(f"http://{self.ip}:{self.port}/api/location/planetimage",
+                         params={"planet":planet},auth=("",self.password))
+        if r.status_code == 200:
+            return r.content
+        else:
+            raise Exception(r.text)
+        
+    def setLocation(self, id=None,latitude=None,longitude=None,
+                    altitude=None,name=None,country=None,planet=None):
+        """
+        Changes and moves to a new location. If id is given, all other parameters are ignored,
+        and a location is searched from the named locations using StelLocationMgr::locationForString 
+        with the id. Else, the other parameters change the specific field of the current StelLocation.
+        """
+        params={}
+        # below we can pass "no id", effectively
+        # used so we can pass something for id saying there is no id
+        if id == 0:
+            id = None
+        if not id == None:
+            params["id"] = id
+        else:
+            if not latitude == None: params["latitude"] = latitude
+            if not longitude == None: params["longitude"] = longitude
+            if not altitude == None: params["altitude"] = altitude
+            if not name == None: params["name"] = name
+            if not country == None: params["country"] = country
+            if not planet == None: params["planet"] = planet
+        r = requests.post(f"http://{self.ip}:{self.port}/api/location/setlocationfields",
+                         params=params,auth=("",self.password))
+        if not r.text == "ok":
+            raise Exception(r.text)
+        else:
+            return r

libaditya/stars/stellarium/remote_control/locationsearch.py

@@ -0,0 +1,35 @@
+import requests
+
+class LocationSearch:
+    def __init__(self, ip="127.0.0.1", port=8090, password=""):
+        self.ip = ip
+        self.port = port
+        self.password = password
+    
+    def search(self,term):
+        """
+        Searches the term in the list of predefined locations of the StelLocationMgr, and 
+        returns a JSON string array of the results.
+        """
+        r = requests.get(f"http://{self.ip}:{self.port}/api/locationsearch/search",
+                         params={"term":term},auth=("",self.password))
+        try:
+            return r.json()
+        except requests.exceptions.JSONDecodeError:
+            raise Exception(r.text)
+        
+    def nearby(self,planet,latitude,longitude,radius):
+        """
+        Searches near the location defined by planet, latitude and longitude for predefined 
+        locations (inside the given radius) using StelLocationMgr::pickLocationsNearby, 
+        returns a JSON string array.
+        """
+        r = requests.get(f"http://{self.ip}:{self.port}/api/locationsearch/nearby",
+                         params={"planet":planet,"latitude":latitude,
+                                 "longitude":longitude,"radius":radius},
+                         auth=("",self.password))
+        try:
+            return r.json()
+        except requests.exceptions.JSONDecodeError:
+            raise Exception(r.text)
+        

libaditya/stars/stellarium/remote_control/main.py

@@ -0,0 +1,165 @@
+import requests
+
+class Main:
+    def __init__(self, ip="127.0.0.1", port=8090, password=""):
+        self.ip = ip
+        self.port = port
+        self.password = password
+
+    def getStatus(self, format="json"):
+        params = {"format": format}
+        r = requests.get(f"http://{self.ip}:{self.port}/api/main/status",params=params,auth=("",self.password))
+        try:
+            return r.json()
+        except requests.exceptions.JSONDecodeError:
+            raise Exception(r.text)
+
+    def getPlugins(self):
+        r = requests.get(f"http://{self.ip}:{self.port}/api/main/plugins",auth=("",self.password))
+        try:
+            return r.json()
+        except requests.exceptions.JSONDecodeError:
+            raise Exception(r.text)
+
+    def getView(self,coord=None,ref=None):
+        """
+        Returns the current view direction as JSON.
+        Without the optional coord, all versions are returned, including j2000, jNow and altAz. The returned 
+        values are 3D vectors.
+        For the vector in altAz system, the actually returned values are based on an azimuth Az' counted 
+        from South (x=1) towards East (y=1), Az'=180-Az.
+        If the optional parameter ref is given, it governs refraction setting and it applies to the jNow 
+        output only. "On" applies refraction, "off" does not apply, and "auto" (or any other value) applies 
+        it when atmosphere setting is active.
+        """
+        params = {}
+        if coord is not None:
+            params["coord"] = coord
+        if ref is not None:
+            params["ref"] = ref
+        r = requests.get(f"http://{self.ip}:{self.port}/api/main/view", 
+                         params=params,auth=("",self.password))
+        try:
+            return r.json()
+        except requests.exceptions.JSONDecodeError:
+            raise Exception(r.text)
+
+    def setTimeJD(self,time):
+        """
+        Sets the current Stellarium simulation time. The time parameter defines the current time (Julian day) 
+        as passed to StelCore::setJD.
+        """
+        r = requests.post(f"http://{self.ip}:{self.port}/api/main/time", 
+                          data={"time":time},auth=("",self.password))
+        if not r.text == 'ok':
+            raise Exception(r.text)
+        return r
+
+    def setTimeRateJD(self,timeRate):
+        """
+        Sets the current Stellarium simulation timerate.The timerate parameter allows to change the speed at 
+        which the simulation time moves (in JDay/sec) as passed to StelCore::setTimeRate.
+        """
+        r = requests.post(f"http://{self.ip}:{self.port}/api/main/time", 
+                          data={"timerate":timeRate},auth=("",self.password))
+        if not r.text == 'ok':
+            raise Exception(r.text)
+        return r
+    
+    def setTime(self,dt):
+        """
+        Sets the current Stellarium simulation time. The dt parameter defines the current time as a datetime
+        object in Python standard library.
+        """
+        jd = dt.timestamp() / 86400.0 + 2440587.5
+        r = requests.post(f"http://{self.ip}:{self.port}/api/main/time", 
+                          data={"time":jd},auth=("",self.password))
+        if not r.text == 'ok':
+            raise Exception(r.text)
+        return r
+
+    def setTimeRate(self,timeRate):
+        """
+        Sets the current Stellarium simulation timerate.The timerate parameter allows to change the speed at
+        which the simulation time moves (in seconds per second). Negative timerates are also allowed, which 
+        means that time moves backwards.
+        """
+        r = requests.post(f"http://{self.ip}:{self.port}/api/main/time", 
+                          data={"timerate":timeRate/86400.0},auth=("",self.password))
+        if not r.text == 'ok':
+            raise Exception(r.text)
+        return r
+    
+    def setFocus(self,target=None,position=None,mode=None):
+        """
+        Sets the current app focus/selection. 
+        If no parameters are given, the current selection is cleared. 
+        If the target parameter was given, the object to be selected is looked up by name (first the localized 
+        name is tried, then the english name). 
+        If the optional mode parameter is given, it determines how to change the view. The default is 'center' 
+        which selects the object and moves it into the view's center. If it is set to 'zoom', it automatically 
+        zooms in on the object (StelMovementMgr::autoZoomIn) on selection and automatically zooms out when the 
+        selection is cleared. If it is set to 'mark', the selection is just marked, but no view adjustment is done. 
+        If the position parameter is used, it is interpreted as a coordinate in the J2000 frame, and focused 
+        using StelMovementMgr::moveToJ2000. The mode parameter has no effect here. The target parameter takes 
+        precendence over the position parameter, if both are given.
+        """
+        params = {}
+        if target is not None:
+            params["target"] = target
+        if position is not None:
+            params["position"] = position
+        if mode is not None:
+            params["mode"] = mode
+        r = requests.post(f"http://{self.ip}:{self.port}/api/main/focus", 
+                          data=params,auth=("",self.password))
+        if not r.text == 'true':
+            raise Exception(r.text)
+        return r
+    
+    def setMove(self,x,y):
+        """
+        Allows viewport movement, like using the arrow keys in the main program.This operation defines the intended 
+        move direction. x and y define the intended move speed in azimuth and altitude (i.e. a negative x means 
+        left).
+        """
+        r = requests.post(f"http://{self.ip}:{self.port}/api/main/move", 
+                          data={"x":x,"y":y},auth=("",self.password))
+        if not r.text == 'ok':
+            raise Exception(r.text)
+        return r
+        
+    def setView(self,coord=None,vec=None,az=None,alt=None,ref="auto"):
+        """
+        Sets the view direction.When the coord parameter is given, it defines the coordinate system to use for 
+        vec parameter. The possible values are j2000, jNow and altAz. 
+        An optional parameter ref governs refraction mode, default auto.
+        If the coord and vec parameters are not given, the az and alt parameters are used to define the view 
+        in altitude/azimuth spherical coordinates/angles.
+        """
+        params = {}
+        if coord is not None and vec is not None:
+            if not coord in ["j2000","jNow","altAz"]:
+                raise ValueError("coord must be j2000, jNow or altAz.")
+            params[coord] = str(vec)
+            params["ref"] = ref
+        elif az is not None and alt is not None:
+            params["az"] = az
+            params["alt"] = alt
+        else:
+            raise ValueError("Either coord and vec or az and alt must be given.")
+        r = requests.post(f"http://{self.ip}:{self.port}/api/main/view", 
+                          data=params,auth=("",self.password))
+        if not r.text == 'ok':
+            raise Exception(r.text)
+        return r
+    
+    def setFov(self,fov):
+        """
+        Sets the current field of view using StelCore::setFov.
+        """
+        r = requests.post(f"http://{self.ip}:{self.port}/api/main/fov", 
+                          data={"fov":fov},auth=("",self.password))
+        if not r.text == 'ok':
+            raise Exception(r.text)
+        return r

libaditya/stars/stellarium/remote_control/objects.py

@@ -0,0 +1,63 @@
+import requests
+
+class Objects:
+    def __init__(self, ip="127.0.0.1", port=8090, password=""):
+        self.ip = ip
+        self.port = port
+        self.password = password
+    
+    def findObject(self, name):
+        """
+        Finds objects which match the search string str, which may contain greek/unicode 
+        characters like in the SearchDialog. Returns a JSON String array of search matches.
+        """
+        r = requests.get(f"http://{self.ip}:{self.port}/api/objects/find",
+                         params={"str":name},auth=("",self.password))
+        try:
+            return r.json()
+        except requests.exceptions.JSONDecodeError:
+            raise Exception(r.text)
+    
+    def getInfo(self, name=None, format="json"):
+        """
+        Returns an info string about the object identified by name in HTML or JSON format. 
+        If no parameter name is given, the currently selected object is used.
+        """
+        params = {"format":format}
+        if name is not None:
+            params["name"] = name
+        r = requests.get(f"http://{self.ip}:{self.port}/api/objects/info",
+                         params=params,auth=("",self.password))
+        if format == "json":
+            try:
+                return r.json()
+            except requests.exceptions.JSONDecodeError:
+                raise Exception(r.text)
+        else:
+            return r.text
+        
+    def listObjectTypes(self):
+        """
+        Returns all object types available in the internal catalogs as a JSON array of 
+        objects of format.
+        """
+        r = requests.get(f"http://{self.ip}:{self.port}/api/objects/listobjecttypes"
+                         ,auth=("",self.password))
+        try:
+            return r.json()
+        except requests.exceptions.JSONDecodeError:
+            raise Exception(r.text)
+    
+    def listObjectsByType(self, type, english=False):
+        """
+        Returns all objects of the specified type. If english is true, the english names 
+        will be returned, otherwise the localized names will be returned. Returns a JSON 
+        string array.
+        """
+        r = requests.get(f"http://{self.ip}:{self.port}/api/objects/listobjectsbytype",
+                         params={"type":type,"english":1 if english else 0},
+                         auth=("",self.password))
+        try:
+            return r.json()
+        except requests.exceptions.JSONDecodeError:
+            raise Exception(r.text)

libaditya/stars/stellarium/remote_control/scripts.py

@@ -0,0 +1,81 @@
+import requests
+
+class Scripts:
+    def __init__(self, ip="127.0.0.1", port=8090, password=""):
+        self.ip = ip
+        self.port = port
+        self.password = password
+        
+    def listScripts(self):
+        """
+        Lists all known script files, as a JSON string array.
+        """
+        r = requests.get(f"http://{self.ip}:{self.port}/api/scripts/list",
+                         auth=("",self.password))
+        try:
+            return r.json()
+        except requests.exceptions.JSONDecodeError:
+            raise Exception(r.text)
+        
+    def getInfo(self, id, html=False):
+        """
+        Returns information about the script identified by id. If the parameter html is true, 
+        the info is formatted using StelScriptMgr::getHtmlDescription and suitable for inclusion 
+        into an iframe element, otherwise this operation returns a JSON object.
+        """
+        params = {"id":id}
+        if html:
+            params["html"] = 1
+        r = requests.get(f"http://{self.ip}:{self.port}/api/scripts/info",
+                         params=params,auth=("",self.password))
+        try:
+            if not html:
+                return r.json()
+            else:
+                return r.text
+        except requests.exceptions.JSONDecodeError:
+            raise Exception(r.text)
+        
+    def getStatus(self):
+        """
+        Returns the current script status as a JSON object.
+        """
+        r = requests.get(f"http://{self.ip}:{self.port}/api/scripts/status"
+                         ,auth=("",self.password))
+        try:
+            return r.json()
+        except requests.exceptions.JSONDecodeError:
+            raise Exception(r.text)
+        
+    def runScript(self, id):
+        """
+        Runs the script with the given id. Will fail if a script is currently running.
+        """
+        r = requests.post(f"http://{self.ip}:{self.port}/api/scripts/run",
+                         data={"id":id},auth=("",self.password))
+        if not r.text == 'ok':
+            raise Exception(r.text)
+        return r
+    
+    def executeCode(self, code, useIncludes=False):
+        """
+        Directly executes the given script code. If useIncludes is given and evaluates to true, 
+        the standard include folder will be used. Script execution will fail if a script is 
+        already running.
+        """
+        r = requests.post(f"http://{self.ip}:{self.port}/api/scripts/direct",
+                         data={"code":code,"useIncludes":useIncludes},
+                         auth=("",self.password))
+        if not r.text == 'ok':
+            raise Exception(r.text)
+        return r
+    
+    def stopScript(self):
+        """
+        Stops the execution of a running script.
+        """
+        r = requests.post(f"http://{self.ip}:{self.port}/api/scripts/stop",
+                          auth=("",self.password))
+        if not r.text == 'ok':
+            raise Exception(r.text)
+        return r

libaditya/stars/stellarium/remote_control/simbad.py

@@ -0,0 +1,20 @@
+import requests
+
+class Simbad:
+    def __init__(self, ip="127.0.0.1", port=8090, password=""):
+        self.ip = ip
+        self.port = port
+        self.password = password
+        
+    def lookup(self, keyword):
+        """
+        Performs a SIMBAD lookup for the string keyword using the Stellarium-configured server 
+        and returns the results as a JSON object of format.
+        """
+        r = requests.get(f"http://{self.ip}:{self.port}/api/simbad/lookup",
+                         params={"str":keyword},auth=("",self.password))
+        try:
+            return r.json()
+        except requests.exceptions.JSONDecodeError:
+            raise Exception(r.text)
+        

libaditya/stars/stellarium/remote_control/stelaction.py

@@ -0,0 +1,31 @@
+import requests
+
+class StelAction:
+    def __init__(self, ip="127.0.0.1", port=8090, password=""):
+        self.ip = ip
+        self.port = port
+        self.password = password
+        
+    def listActions(self):
+        """
+        Lists all registered StelActions in JSON.
+        """
+        r = requests.get(f"http://{self.ip}:{self.port}/api/stelaction/list",
+                        auth=("",self.password))
+        try:
+            return r.json()
+        except requests.exceptions.JSONDecodeError:
+            raise Exception(r.text)
+        
+    def doAction(self, id):
+        """
+        Triggers or toggles the StelAction specified by id. If it was a boolean 
+        action, returns the new state of the action.
+        """
+        r = requests.post(f"http://{self.ip}:{self.port}/api/stelaction/do",
+                        data={"id":id},auth=("",self.password))
+        if r.text in ['true','false']:
+            return r.text == 'true'
+        else:
+            raise Exception(r.text)
+        

libaditya/stars/stellarium/remote_control/stelproperty.py

@@ -0,0 +1,30 @@
+import requests
+
+class StelProperty:
+    def __init__(self, ip="127.0.0.1", port=8090, password=""):
+        self.ip = ip
+        self.port = port
+        self.password = password
+        
+    def listProperties(self):
+        """
+        Lists all registered StelProperties in JSON.
+        """
+        r = requests.get(f"http://{self.ip}:{self.port}/api/stelproperty/list",
+                        auth=("",self.password))
+        try:
+           return r.json()
+        except requests.exceptions.JSONDecodeError:
+            raise Exception(r.text)
+        
+    def setProperty(self, id, value):
+        """
+        Sets the StelProperty identified by id to the value value. The value is converted 
+        to the StelProperty type using QVariant logic, an error is returned if this is 
+        somehow not possible.
+        """
+        r = requests.post(f"http://{self.ip}:{self.port}/api/stelproperty/set",
+                         data={"id":id,"value":value},auth=("",self.password))
+        if not r.text == 'ok':
+            raise Exception(r.text)
+        return r

libaditya/stars/stellarium/remote_control/view.py

@@ -0,0 +1,85 @@
+import requests
+
+class View:
+    def __init__(self, ip="127.0.0.1", port=8090, password=""):
+        self.ip = ip
+        self.port = port
+        self.password = password
+    
+    def listLandscape(self):
+        """
+        Lists the installed landscapes as JSON.
+        """
+        r = requests.get(f"http://{self.ip}:{self.port}/api/view/listlandscape",
+                         auth=("",self.password))
+        try:
+            return r.json()
+        except requests.exceptions.JSONDecodeError:
+            raise Exception(r.text)
+        
+    def landscapeDesciption(self,path):
+        """
+        Provides virtual filesystem access to the current landscape directory. The operation 
+        can take a longer path in the URL. The remainder is used to access files in the landscape 
+        directory. If no longer path is given, the current HTML landscape description (as per 
+        LandscapeMgr::getCurrentLandscapeHtmlDescription) is returned. An example: 
+        landscapeDesciption("image.png") returns image.png from the current landscape directory.
+        This operation allows to set up an HTML iframe or similar for the landscape description, 
+        including all images, etc. embedded in the HTML description.
+        """
+        r = requests.get(f"http://{self.ip}:{self.port}/api/view/landscapedescription/{path}",
+                         auth=("",self.password))
+        if r.status_code == 200:
+            return r.content
+        else:
+            raise Exception(r.text)
+        
+    def listSkyculture(self):
+        """
+        Lists the installed sky cultures as JSON.
+        """
+        r = requests.get(f"http://{self.ip}:{self.port}/api/view/listskyculture",
+                         auth=("",self.password))
+        try:
+            return r.json()
+        except requests.exceptions.JSONDecodeError:
+            raise Exception(r.text)
+        
+    def skycultureDescription(self,path):
+        """
+        Provides virtual filesystem access to the current skyculture directory. The operation 
+        can take a longer path in the URL. The remainder is used to access files in the skyculture 
+        directory. If no longer path is given, the current HTML skyculture description (as per 
+        StelSkyCultureMgr::getCurrentSkyCultureHtmlDescription) is returned. An example: 
+        skycultureDescription("image.png") returns image.png from the current skyculture directory.
+        This operation allows to set up an HTML iframe or similar for the skycultures description, 
+        including all images, etc. embedded in the HTML description.
+        """
+        r = requests.get(f"http://{self.ip}:{self.port}/api/view/skyculturedescription/{path}",
+                         auth=("",self.password))
+        if r.status_code == 200:
+            return r.content
+        else:
+            raise Exception(r.text)
+        
+    def listProjection(self):
+        """
+        Lists the available projection types as JSON.
+        """
+        r = requests.get(f"http://{self.ip}:{self.port}/api/view/listprojection",
+                         auth=("",self.password))
+        try:
+            return r.json()
+        except requests.exceptions.JSONDecodeError:
+            raise Exception(r.text)
+        
+    def projectionDescription(self):
+        """
+        Returns the HTML description of the current projection (StelProjector::getHtmlSummary)
+        """
+        r = requests.get(f"http://{self.ip}:{self.port}/api/view/projectiondescription",
+                         auth=("",self.password))
+        if r.status_code == 200:
+            return r.content
+        else:
+            raise Exception(r.text)