Merge branch 'dev' into 1125-add-target-and-dataproduct-filters-to-the-reduceddatums-drf-api

Author: jchate6

.gitignore

@@ -84,6 +84,7 @@ docs/_build/
 
 # VS Code
 .vscode/
+.vs/
 *.code-workspace
 
 # PyBuilder

tom_catalogs/harvesters/mpc.py

@@ -1,3 +1,5 @@
+import re
+import logging
 import requests
 from math import sqrt, degrees
 
@@ -6,6 +8,9 @@
 
 from astroquery.mpc import MPC
 
+logger = logging.getLogger(__name__)
+# logger.setLevel(logging.DEBUG)
+
 
 class MPCHarvester(AbstractHarvester):
     """
@@ -17,22 +22,79 @@ class MPCHarvester(AbstractHarvester):
     name = 'MPC'
 
     def query(self, term):
-        self.catalog_data = MPC.query_object('asteroid', name=term)
+        self._object_type = 'asteroid'
+        self._query_type = 'name'
+        numbered_object = re.compile(r'(\d+)(P?)\s*$')
+        provisional_desig = re.compile(r'^\s*(\d{4}\s*[A-Z]{2}\d*)')
+        provisional_comets = re.compile(r'([C,P,A,D]/\d{4} [A-H,J-Y]{1,2}\d+)')
+
+        match = re.search(provisional_desig, term)
+        if match:
+            logger.debug("Desig match")
+            self._query_type = 'desig'
+            self._object_term = match.groups()[0]
+            logger.debug(self._object_term, self._object_type)
+            self.catalog_data = MPC.query_object(self._object_type, designation=self._object_term)
+        else:
+            match = re.search(provisional_comets, term)
+            if match:
+                logger.debug("Comet match")
+                self._object_type = 'comet'
+                self._query_type = 'desig'
+                self._object_term = match.groups()[0]
+                self.catalog_data = MPC.query_object(self._object_type, designation=self._object_term)
+            else:
+                match = re.search(numbered_object, term)
+                if match:
+                    # Numbered object (asteroid or comet)
+                    logger.debug("Num Match")
+                    self._object_term = match.groups()[0]
+                    self._query_type = 'number'
+                    if match.groups()[1] == 'P':
+                        # Periodic comet
+                        self._object_type = 'comet'
+                        self._object_term = ''.join(match.groups())
+                    self.catalog_data = MPC.query_object(self._object_type, number=self._object_term)
+                else:
+                    logger.debug("No match")
+                    self._object_term = term
+                    self.catalog_data = MPC.query_object(self._object_type, name=self._object_term)
 
     def to_target(self):
         target = super().to_target()
         result = self.catalog_data[0]
         target.type = 'NON_SIDEREAL'
-        target.name = result['name']
-        target.extra_names = [result['designation']] if result['designation'] else []
+        if result.get('number', None) is not None:
+            if result.get('name', None) is not None:
+                target.name = str(result['number'])
+                target.extra_names = [str(result['name']),]
+                target.extra_names += [result['designation']] if result['designation'] else []
+            else:
+                target.name = str(result['number'])
+                if result.get('object_type'):
+                    # Add comet object type if it exists
+                    target.name += result['object_type']
+        else:
+            target.name = result['designation']
         target.epoch_of_elements = self.jd_to_mjd(result['epoch_jd'])
-        target.mean_anomaly = result['mean_anomaly']
-        target.arg_of_perihelion = result['argument_of_perihelion']
-        target.eccentricity = result['eccentricity']
-        target.lng_asc_node = result['ascending_node']
-        target.inclination = result['inclination']
-        target.mean_daily_motion = result['mean_daily_motion']
-        target.semimajor_axis = result['semimajor_axis']
+        target.arg_of_perihelion = float(result['argument_of_perihelion'])
+        target.eccentricity = float(result['eccentricity'])
+        target.lng_asc_node = float(result['ascending_node'])
+        target.inclination = float(result['inclination'])
+        target.mean_daily_motion = float(result['mean_daily_motion'])
+        object_type = result.get('object_type', '')
+        target.scheme = 'MPC_MINOR_PLANET'
+        if object_type == 'C' or object_type == 'P':
+            target.scheme = 'MPC_COMET'
+            target.perihdist = float(result['perihelion_distance'])
+            try:
+                # Convert JD to MJD as string (avoid losing precision)
+                target.epoch_of_perihelion = float(result['perihelion_date_jd'][2:]) - 0.5
+            except ValueError:
+                raise
+        else:
+            target.mean_anomaly = float(result['mean_anomaly'])
+            target.semimajor_axis = float(result['semimajor_axis'])
         return target
 
 

tom_catalogs/tests/harvesters/test_mpc.py

@@ -4,7 +4,227 @@
 from django.test import tag, TestCase
 from unittest.mock import MagicMock, patch
 
-from tom_catalogs.harvesters.mpc import MPCExplorerHarvester
+from tom_catalogs.harvesters.mpc import MPCHarvester, MPCExplorerHarvester
+
+
+class TestMPCHarvester(TestCase):
+    def setUp(self):
+        self.broker = MPCHarvester()
+        self.test_response = [{'foo': 42}]
+
+    @patch('astroquery.mpc.MPC.query_object')
+    def test_query_name(self, mock_query):
+        mock_query.return_value = self.test_response
+
+        self.broker.query('didymos')
+        self.assertEqual(self.broker._object_type, 'asteroid')
+        self.assertEqual(self.broker._object_term, 'didymos')
+        self.assertEqual(self.broker._query_type, 'name')
+        self.assertEqual(self.broker.catalog_data, self.test_response)
+
+    @patch('astroquery.mpc.MPC.query_object')
+    def test_query_asteroid_number(self, mock_query):
+        mock_query.return_value = self.test_response
+
+        self.broker.query('1627')
+        self.assertEqual(self.broker._object_type, 'asteroid')
+        self.assertEqual(self.broker._query_type, 'number')
+        self.assertEqual(self.broker._object_term, '1627')
+        self.assertEqual(self.broker.catalog_data, self.test_response)
+
+    @patch('astroquery.mpc.MPC.query_object')
+    def test_query_asteroid_number_ws(self, mock_query):
+        mock_query.return_value = self.test_response
+
+        self.broker.query('  1627    ')
+        self.assertEqual(self.broker._object_type, 'asteroid')
+        self.assertEqual(self.broker._query_type, 'number')
+        self.assertEqual(self.broker._object_term, '1627')
+        self.assertEqual(self.broker.catalog_data, self.test_response)
+
+    @patch('astroquery.mpc.MPC.query_object')
+    def test_query_comet_number(self, mock_query):
+        mock_query.return_value = self.test_response
+
+        self.broker.query('67P')
+        self.assertEqual(self.broker._object_type, 'comet')
+        self.assertEqual(self.broker._query_type, 'number')
+        self.assertEqual(self.broker._object_term, '67P')
+        self.assertEqual(self.broker.catalog_data, self.test_response)
+
+    @patch('astroquery.mpc.MPC.query_object')
+    def test_query_comet_number_ws(self, mock_query):
+        mock_query.return_value = self.test_response
+
+        self.broker.query('  67P    ')
+        self.assertEqual(self.broker._object_type, 'comet')
+        self.assertEqual(self.broker._query_type, 'number')
+        self.assertEqual(self.broker._object_term, '67P')
+        self.assertEqual(self.broker.catalog_data, self.test_response)
+
+    @patch('astroquery.mpc.MPC.query_object')
+    def test_query_provisional_cometlike(self, mock_query):
+        # This tests if we have a provisional id such as '1999PA123' or '2025PM' which shouldn't
+        # match with periodic comets despite being "number" followed by "P"
+        mock_query.return_value = self.test_response
+
+        self.broker.query('2025PM')
+        self.assertNotEqual(self.broker._object_type, 'comet')
+        self.assertNotEqual(self.broker._query_type, 'number')
+        self.assertEqual(self.broker._object_term, '2025PM')
+        self.assertEqual(self.broker.catalog_data, self.test_response)
+
+    @patch('astroquery.mpc.MPC.query_object')
+    def test_query_provisional_cometlike_ws(self, mock_query):
+        # This tests if we have a provisional id such as '1999 PA123' or '2025 PM' which shouldn't
+        # match with periodic comets despite being "number" followed by " P"
+        mock_query.return_value = self.test_response
+
+        self.broker.query('2025 PM')
+        self.assertNotEqual(self.broker._object_type, 'comet')
+        self.assertNotEqual(self.broker._query_type, 'number')
+        self.assertEqual(self.broker._object_term, '2025 PM')
+        self.assertEqual(self.broker.catalog_data, self.test_response)
+
+    @patch('astroquery.mpc.MPC.query_object')
+    def test_designation(self, mock_query):
+        mock_query.return_value = self.test_response
+
+        self.broker.query('2025 MB18')
+        self.assertEqual(self.broker._object_type, 'asteroid')
+        self.assertEqual(self.broker._query_type, 'desig')
+        self.assertEqual(self.broker._object_term, '2025 MB18')
+        self.assertEqual(self.broker.catalog_data, self.test_response)
+
+    @patch('astroquery.mpc.MPC.query_object')
+    def test_designation_cometish(self, mock_query):
+        mock_query.return_value = self.test_response
+
+        self.broker.query('2022PA')
+        self.assertEqual(self.broker._object_type, 'asteroid')
+        self.assertEqual(self.broker._query_type, 'desig')
+        self.assertEqual(self.broker._object_term, '2022PA')
+        self.assertEqual(self.broker.catalog_data, self.test_response)
+
+    @patch('astroquery.mpc.MPC.query_object')
+    def test_designation_cometish_with_ws(self, mock_query):
+        mock_query.return_value = self.test_response
+
+        self.broker.query('2022 PA')
+        self.assertEqual(self.broker._object_type, 'asteroid')
+        self.assertEqual(self.broker._query_type, 'desig')
+        self.assertEqual(self.broker._object_term, '2022 PA')
+        self.assertEqual(self.broker.catalog_data, self.test_response)
+
+    @patch('astroquery.mpc.MPC.query_object')
+    def test_designation_ws(self, mock_query):
+        mock_query.return_value = self.test_response
+
+        self.broker.query('  2025 MB18   ')
+        self.assertEqual(self.broker._object_type, 'asteroid')
+        self.assertEqual(self.broker._query_type, 'desig')
+        self.assertEqual(self.broker._object_term, '2025 MB18')
+        self.assertEqual(self.broker.catalog_data, self.test_response)
+
+    @patch('astroquery.mpc.MPC.query_object')
+    def test_designation_nospace(self, mock_query):
+        mock_query.return_value = self.test_response
+
+        self.broker.query('2025MB18')
+        self.assertEqual(self.broker._object_type, 'asteroid')
+        self.assertEqual(self.broker._query_type, 'desig')
+        self.assertEqual(self.broker._object_term, '2025MB18')
+        self.assertEqual(self.broker.catalog_data, self.test_response)
+
+    @patch('astroquery.mpc.MPC.query_object')
+    def test_provisional_comets(self, mock_query):
+        mock_query.return_value = self.test_response
+
+        comets = ['C/2024 S4', 'P/2017 A1', 'D/1853 X1', 'C/2001 OG108', 'P/2002 EJ57']
+        for comet in comets:
+            self.broker.query(comet)
+            self.assertEqual(self.broker._object_type, 'comet', msg=f'Failure on _object_type for {comet}')
+            self.assertEqual(self.broker._query_type, 'desig', msg=f'Failure on _query_type for {comet}')
+            self.assertEqual(self.broker._object_term, comet, msg=f'Failure on _object_term for {comet}')
+            self.assertEqual(self.broker.catalog_data, self.test_response)
+
+
+@tag('canary')
+class TestMPCHarvesterCanary(TestCase):
+    def setUp(self):
+        self.broker = MPCHarvester()
+
+    def test_query_number_only(self):
+        self.broker.query('700000')
+        target = self.broker.to_target()
+        target.save(names=getattr(target, 'extra_names', []))
+        # Only test things that are not likely to change (much) with time
+        self.assertEqual(target.name, '700000')
+        self.assertEqual(target.names, ['700000'])
+        self.assertEqual(target.type, 'NON_SIDEREAL')
+        self.assertEqual(target.scheme, 'MPC_MINOR_PLANET')
+        self.assertEqual(target.ra, None)
+        self.assertEqual(target.dec, None)
+        self.assertAlmostEqual(target.eccentricity, 0.092, places=3)
+        self.assertAlmostEqual(target.inclination, 4.1688, places=4)
+        self.assertAlmostEqual(target.mean_anomaly, 315.8420, places=4)
+        self.assertAlmostEqual(target.semimajor_axis, 2.6555, places=4)
+
+    def test_query_designation_only(self):
+        self.broker.query('2025 MB18')
+        target = self.broker.to_target()
+        target.save(names=getattr(target, 'extra_names', []))
+        # Only test things that are not likely to change (much) with time
+        self.assertEqual(target.name, '2025 MB18')
+        self.assertEqual(target.names, ['2025 MB18'])
+        self.assertEqual(target.type, 'NON_SIDEREAL')
+        self.assertEqual(target.scheme, 'MPC_MINOR_PLANET')
+        self.assertEqual(target.ra, None)
+        self.assertEqual(target.dec, None)
+        self.assertAlmostEqual(target.eccentricity, 0.1398, places=4)
+        self.assertAlmostEqual(target.inclination, 19.3561, places=4)
+
+    def test_query_name(self):
+        self.broker.query('1627')
+        target = self.broker.to_target()
+        target.save(names=getattr(target, 'extra_names', []))
+        # Only test things that are not likely to change (much) with time
+        self.assertEqual(target.name, '1627')
+        self.assertEqual(target.names, ['1627', 'Ivar'])
+        self.assertEqual(target.type, 'NON_SIDEREAL')
+        self.assertEqual(target.scheme, 'MPC_MINOR_PLANET')
+        self.assertEqual(target.ra, None)
+        self.assertEqual(target.dec, None)
+        self.assertAlmostEqual(target.eccentricity, 0.3972, places=4)
+        self.assertAlmostEqual(target.inclination, 8.4561, places=4)
+
+    def test_query_comet_name(self):
+        self.broker.query('29P')
+        target = self.broker.to_target()
+        target.save(names=getattr(target, 'extra_names', []))
+        # Only test things that are not likely to change (much) with time
+        self.assertEqual(target.name, '29P')
+        self.assertEqual(target.names, ['29P'])
+        self.assertEqual(target.type, 'NON_SIDEREAL')
+        self.assertEqual(target.scheme, 'MPC_COMET')
+        self.assertEqual(target.ra, None)
+        self.assertEqual(target.dec, None)
+        self.assertAlmostEqual(target.eccentricity, 0.0433, places=4)
+        self.assertAlmostEqual(target.lng_asc_node, 312.4041, places=4)
+
+    def test_query_comet_designation(self):
+        self.broker.query('C/2017 K2')
+        target = self.broker.to_target()
+        target.save(names=getattr(target, 'extra_names', []))
+        # Only test things that are not likely to change (much) with time
+        self.assertEqual(target.name, 'C/2017 K2')
+        self.assertEqual(target.names, ['C/2017 K2'])
+        self.assertEqual(target.type, 'NON_SIDEREAL')
+        self.assertEqual(target.scheme, 'MPC_COMET')
+        self.assertEqual(target.ra, None)
+        self.assertEqual(target.dec, None)
+        self.assertAlmostEqual(target.perihdist, 1.7998, places=4)
+        self.assertAlmostEqual(target.arg_of_perihelion, 236.17910, places=4)
 
 
 class TestMPCExplorerHarvester(TestCase):