Allow using units for location coordinates in jplhorizons

Author: mkelley

astroquery/jplhorizons/core.py

@@ -13,6 +13,7 @@
 from astropy.table import Table, Column
 from astropy.io import ascii
 from astropy.time import Time
+from astropy import units as u
 from astropy.utils.exceptions import AstropyDeprecationWarning
 from astropy.utils.decorators import deprecated_renamed_argument, deprecated_attribute
 
@@ -53,14 +54,14 @@ def __init__(self, id=None, *, location=None, epochs=None,
 
         id : str or dict, required
             Name, number, or designation of target object. Uses the same codes
-            as JPL Horizons. Arbitrary topocentric coordinates can be added
-            in a dict. The dict has to be of the form
-            {``'lon'``: longitude in deg (East positive, West
-            negative), ``'lat'``: latitude in deg (North positive, South
-            negative), ``'elevation'``: elevation in km above the reference
-            ellipsoid, [``'body'``: Horizons body ID of the central body;
-            optional; if this value is not provided it is assumed that this
-            location is on Earth]}.
+            as JPL Horizons. Arbitrary topocentric coordinates can be added in a
+            dict. The dict has to be of the form {``'lon'``: longitude in deg
+            (East positive, West negative), ``'lat'``: latitude in deg (North
+            positive, South negative), ``'elevation'``: elevation in km above
+            the reference ellipsoid, [``'body'``: Horizons body ID of the
+            central body; optional; if this value is not provided it is assumed
+            that this location is on Earth]}.  Float values are assumed to have
+            units of degrees and kilometers.
 
         location : str or dict, optional
             Observer's location for ephemerides queries or center body name for
@@ -69,12 +70,13 @@ def __init__(self, id=None, *, location=None, epochs=None,
             ephemerides queries and the Sun's center for elements and vectors
             queries. Arbitrary topocentric coordinates for ephemerides queries
             can be provided in the format of a dictionary. The dictionary has to
-            be of the form {``'lon'``: longitude in deg (East positive, West
-            negative), ``'lat'``: latitude in deg (North positive, South
-            negative), ``'elevation'``: elevation in km above the reference
-            ellipsoid, [``'body'``: Horizons body ID of the central body;
-            optional; if this value is not provided it is assumed that this
-            location is on Earth]}.
+            be of the form {``'lon'``: longitude (East positive, West negative),
+            ``'lat'``: latitude (North positive, South negative),
+            ``'elevation'``: elevation above the reference ellipsoid,
+            [``'body'``: Horizons body ID of the central body; optional; if this
+            value is not provided it is assumed that this location is on
+            Earth]}.  Float values are assumed to have units of degrees and
+            kilometers.
 
         epochs : scalar, list-like, or dictionary, optional
             Either a list of epochs in JD or MJD format or a dictionary defining
@@ -117,16 +119,10 @@ def __init__(self, id=None, *, location=None, epochs=None,
         """
 
         super().__init__()
-        # check & format coordinate dictionaries for id and location; simply
-        # treat other values as given
-        if isinstance(id, Mapping):
-            self.id = self._prep_loc_dict(dict(id), "id")
-        else:
-            self.id = id
-        if isinstance(location, Mapping):
-            self.location = self._prep_loc_dict(dict(location), "location")
-        else:
-            self.location = location
+
+        self.id = id
+        self.location = location
+
         # check for epochs to be dict or list-like; else: make it a list
         if epochs is not None:
             if isinstance(epochs, (list, tuple, ndarray)):
@@ -185,6 +181,32 @@ def __str__(self):
                     str(self.epochs),
                     str(self.id_type))
 
+    @property
+    def id(self):
+        return self._id
+
+    @id.setter
+    def id(self, _id):
+        # check & format coordinate dictionaries for id; simply treat other
+        # values as given
+        if isinstance(_id, Mapping):
+            self._id = self._prep_loc_dict(dict(_id), "id")
+        else:
+            self._id = _id
+
+    @property
+    def location(self):
+        return self._location
+
+    @location.setter
+    def location(self, _location):
+        # check & format coordinate dictionaries for location; simply treat
+        # other values as given
+        if isinstance(_location, Mapping):
+            self._location = self._prep_loc_dict(dict(_location), "location")
+        else:
+            self._location = _location
+
     # ---------------------------------- query functions
 
     @deprecated_renamed_argument("get_raw_response", None, since="0.4.7",
@@ -593,10 +615,7 @@ def ephemerides_async(self, *, airmass_lessthan=99,
         if self.id is None:
             raise ValueError("'id' parameter not set. Query aborted.")
         elif isinstance(self.id, dict):
-            commandline = (
-                f"g:{self.id['lon']},{self.id['lat']},"
-                f"{self.id['elevation']}@{self.id['body']}"
-            )
+            commandline = "g:" + self._format_site_coords(self.id)
         else:
             commandline = str(self.id)
         if self.location is None:
@@ -1080,7 +1099,7 @@ def vectors_async(self, *, get_query_payload=False,
         if self.id is None:
             raise ValueError("'id' parameter not set. Query aborted.")
         elif isinstance(self.id, dict):
-            commandline = "g:{lon},{lat},{elevation}@{body}".format(**self.id)
+            commandline = "g:" + self._format_site_coords(self.id)
         else:
             commandline = str(self.id)
         if self.location is None:
@@ -1183,6 +1202,10 @@ def _prep_loc_dict(loc_dict, attr_name):
             )
         if 'body' not in loc_dict:
             loc_dict['body'] = 399
+        # assumed units are degrees and km
+        loc_dict["lat"] = u.Quantity(loc_dict["lat"], u.deg)
+        loc_dict["lon"] = u.Quantity(loc_dict["lon"], u.deg)
+        loc_dict["elevation"] = u.Quantity(loc_dict["elevation"], u.km)
         return loc_dict
 
     @staticmethod
@@ -1191,12 +1214,19 @@ def _location_to_params(loc_dict):
         loc_dict = {
             "CENTER": f"coord@{loc_dict['body']}",
             "COORD_TYPE": "GEODETIC",
-            "SITE_COORD": ",".join(
-                str(float(loc_dict[k])) for k in ['lon', 'lat', 'elevation']
-            )
+            "SITE_COORD": HorizonsClass._format_site_coords(loc_dict)
         }
         loc_dict["SITE_COORD"] = f"'{loc_dict['SITE_COORD']}'"
         return loc_dict
+    
+    @staticmethod
+    def _format_site_coords(coords):
+        # formats lon/lat/elevation/body (e.g., id and location dictionaries) for the Horizons API
+        ",".join(
+                str(coords[k].to_value()) for k in ['lon', 'lat', 'elevation']
+            )
+        return (f"{coords['lon'].to_value('deg')},{coords['lat'].to_value('deg')},"
+                f"{coords['elevation'].to_value('km')}@{coords['body']}")
 
     def _parse_result(self, response, verbose=None):
         """

docs/jplhorizons/jplhorizons.rst

@@ -103,7 +103,7 @@ as the observer's location, and Ceres as the target:
     ...                location=statue_of_liberty,
     ...                epochs=2458133.33546)
     >>> print(obj)
-    JPLHorizons instance "Ceres"; location={'lon': -74.0466891, 'lat': 40.6892534, 'elevation': 0.093, 'body': 399}, epochs=[2458133.33546], id_type=None
+    JPLHorizons instance "Ceres"; location={'lon': <Quantity -74.0466891 deg>, 'lat': <Quantity 40.6892534 deg>, 'elevation': <Quantity 0.093 km>, 'body': 399}, epochs=[2458133.33546], id_type=None
 
 2. Specifying topocentric coordinates for both location and observer is often
 useful when performing geometric calculations for artificial satellites without