refactor logic into utils, raise error on failed integer parsing, minor style fixes

Author: snbianco

astroquery/mast/missions.py

@@ -22,7 +22,7 @@
 from astroquery.utils import commons, async_to_sync
 from astroquery.utils.class_or_instance import class_or_instance
 from astropy.utils.console import ProgressBarOrSpinner
-from astroquery.exceptions import InvalidQueryError, MaxResultsWarning, InputWarning, NoResultsWarning
+from astroquery.exceptions import InvalidQueryError, MaxResultsWarning, NoResultsWarning
 
 from astroquery.mast import utils
 from astroquery.mast.core import MastQueryWithLogin
@@ -505,26 +505,9 @@ def filter_products(self, products, *, extension=None, **filters):
             )
             filter_mask &= ext_mask
 
-        # Applying column-based filters
-        for colname, vals in filters.items():
-            if colname not in products.colnames:
-                warnings.warn(f"Column '{colname}' not found in product table.", InputWarning)
-                continue
-
-            col_data = products[colname]
-            # If the column is an integer or float, accept numeric filters
-            if col_data.dtype.kind in 'if':
-                try:
-                    col_mask = utils.parse_numeric_product_filter(vals)(col_data)
-                except ValueError:
-                    warnings.warn(f"Could not parse numeric filter '{vals}' for column '{colname}'.", InputWarning)
-                    continue
-            else:  # Assume string or list filter
-                if isinstance(vals, str):
-                    vals = [vals]
-                col_mask = np.isin(col_data, vals)
-
-            filter_mask &= col_mask
+        # Apply column-based filters
+        col_mask = utils.apply_column_filters(products, filters)
+        filter_mask &= col_mask
 
         return products[filter_mask]
 

astroquery/mast/observations.py

@@ -595,26 +595,9 @@ def filter_products(self, products, *, mrp_only=False, extension=None, **filters
             )
             filter_mask &= ext_mask
 
-        # Applying column-based filters
-        for colname, vals in filters.items():
-            if colname not in products.colnames:
-                warnings.warn(f"Column '{colname}' not found in product table.", InputWarning)
-                continue
-
-            col_data = products[colname]
-            # If the column is an integer or float, accept numeric filters
-            if col_data.dtype.kind in 'if':
-                try:
-                    col_mask = utils.parse_numeric_product_filter(vals)(col_data)
-                except ValueError:
-                    warnings.warn(f"Could not parse numeric filter '{vals}' for column '{colname}'.", InputWarning)
-                    continue
-            else:  # Assume string or list filter
-                if isinstance(vals, str):
-                    vals = [vals]
-                col_mask = np.isin(col_data, vals)
-
-            filter_mask &= col_mask
+        # Apply column-based filters
+        col_mask = utils.apply_column_filters(products, filters)
+        filter_mask &= col_mask
 
         return products[filter_mask]
 

astroquery/mast/tests/test_mast.py

@@ -366,63 +366,51 @@ def test_missions_get_unique_product_list(patch_post, caplog):
 def test_missions_filter_products(patch_post):
     # Filter products list by column
     products = mast.MastMissions.get_product_list('Z14Z0104T')
-    filtered = mast.MastMissions.filter_products(products,
-                                                 category='CALIBRATED')
+    filtered = mast.MastMissions.filter_products(products, category='CALIBRATED')
     assert isinstance(filtered, Table)
     assert all(filtered['category'] == 'CALIBRATED')
 
     # Filter by extension
-    filtered = mast.MastMissions.filter_products(products,
-                                                 extension='fits')
+    filtered = mast.MastMissions.filter_products(products, extension='fits')
     assert len(filtered) > 0
 
     # Filter by non-existing column
     with pytest.warns(InputWarning):
-        mast.MastMissions.filter_products(products,
-                                          invalid=True)
+        mast.MastMissions.filter_products(products, invalid=True)
 
     # Numeric filtering
     # Single integer value
-    filtered = mast.MastMissions.filter_products(products,
-                                                 size=11520)
+    filtered = mast.MastMissions.filter_products(products, size=11520)
     assert all(filtered['size'] == 11520)
 
     # Single string value
-    filtered = mast.MastMissions.filter_products(products,
-                                                 size='11520')
+    filtered = mast.MastMissions.filter_products(products, size='11520')
     assert all(filtered['size'] == 11520)
 
     # Comparison operators
-    filtered = mast.MastMissions.filter_products(products,
-                                                 size='<15000')
+    filtered = mast.MastMissions.filter_products(products, size='<15000')
     assert all(filtered['size'] < 15000)
 
-    filtered = mast.MastMissions.filter_products(products,
-                                                 size='>15000')
+    filtered = mast.MastMissions.filter_products(products, size='>15000')
     assert all(filtered['size'] > 15000)
 
-    filtered = mast.MastMissions.filter_products(products,
-                                                 size='>=14400')
+    filtered = mast.MastMissions.filter_products(products, size='>=14400')
     assert all(filtered['size'] >= 14400)
 
-    filtered = mast.MastMissions.filter_products(products,
-                                                 size='<=14400')
+    filtered = mast.MastMissions.filter_products(products, size='<=14400')
     assert all(filtered['size'] <= 14400)
 
     # Range operator
-    filtered = mast.MastMissions.filter_products(products,
-                                                 size='14400..17280')
+    filtered = mast.MastMissions.filter_products(products, size='14400..17280')
     assert all((filtered['size'] >= 14400) & (filtered['size'] <= 17280))
 
     # List of expressions
-    filtered = mast.MastMissions.filter_products(products,
-                                                 size=[14400, '>20000'])
+    filtered = mast.MastMissions.filter_products(products, size=[14400, '>20000'])
     assert all((filtered['size'] == 14400) | (filtered['size'] > 20000))
 
-    with pytest.warns(InputWarning, match="Could not parse numeric filter 'invalid' for column 'size'"):
+    with pytest.raises(InvalidQueryError, match="Could not parse numeric filter 'invalid' for column 'size'"):
         # Invalid filter value
-        mast.MastMissions.filter_products(products,
-                                          size='invalid')
+        mast.MastMissions.filter_products(products, size='invalid')
 
 
 def test_missions_download_products(patch_post, tmp_path):
@@ -725,29 +713,24 @@ def test_observations_filter_products(patch_post):
     assert len(filtered) == 7
 
     # Filter for minimum recommended products
-    filtered = mast.Observations.filter_products(products,
-                                                 mrp_only=True)
+    filtered = mast.Observations.filter_products(products, mrp_only=True)
     assert all(filtered['productGroupDescription'] == 'Minimum Recommended Products')
 
     # Filter by extension
-    filtered = mast.Observations.filter_products(products,
-                                                 extension='fits')
+    filtered = mast.Observations.filter_products(products, extension='fits')
     assert len(filtered) > 0
 
     # Filter by non-existing column
     with pytest.warns(InputWarning):
-        mast.Observations.filter_products(products,
-                                          invalid=True)
+        mast.Observations.filter_products(products, invalid=True)
 
     # Numeric filtering
-    filtered = mast.Observations.filter_products(products,
-                                                 size='<50000')
+    filtered = mast.Observations.filter_products(products, size='<50000')
     assert all(filtered['size'] < 50000)
 
     # Numeric filter that cannot be parsed
-    with pytest.warns(InputWarning, match="Could not parse numeric filter 'invalid' for column 'size'"):
-        filtered = mast.Observations.filter_products(products,
-                                                     size='invalid')
+    with pytest.raises(InvalidQueryError, match="Could not parse numeric filter 'invalid' for column 'size'"):
+        filtered = mast.Observations.filter_products(products, size='invalid')
 
 
 def test_observations_download_products(patch_post, tmpdir):
@@ -775,8 +758,7 @@ def test_observations_download_products(patch_post, tmpdir):
 
     # passing row product
     products = mast.Observations.get_product_list('2003738726')
-    result1 = mast.Observations.download_products(products[0],
-                                                  download_dir=str(tmpdir))
+    result1 = mast.Observations.download_products(products[0], download_dir=str(tmpdir))
     assert isinstance(result1, Table)
 
 

astroquery/mast/utils.py

@@ -393,3 +393,45 @@ def single_condition(cond):
         return lambda col: np.logical_or.reduce([cond(col) for cond in conditions])
     else:
         return single_condition(val)
+
+
+def apply_column_filters(products, filters):
+    """
+    Applies column-based filters to a product table.
+
+    Parameters
+    ----------
+    products : `~astropy.table.Table`
+        The product table to filter.
+    filters : dict
+        A dictionary where keys are column names and values are the filter values.
+
+    Returns
+    -------
+    col_mask : `numpy.ndarray`
+        A boolean mask indicating which rows of the product table satisfy the filter conditions.
+    """
+    col_mask = np.ones(len(products), dtype=bool)  # Start with all True mask
+
+    # Applying column-based filters
+    for colname, vals in filters.items():
+        if colname not in products.colnames:
+            warnings.warn(f"Column '{colname}' not found in product table.", InputWarning)
+            continue
+
+        col_data = products[colname]
+        # If the column is an integer or float, accept numeric filters
+        if col_data.dtype.kind in ['i', 'f']:  # 'i' for integer, 'f' for float
+            try:
+                this_mask = parse_numeric_product_filter(vals)(col_data)
+            except ValueError:
+                raise InvalidQueryError(f"Could not parse numeric filter '{vals}' for column '{colname}'.")
+        else:  # Assume string or list filter
+            if isinstance(vals, str):
+                vals = [vals]
+            this_mask = np.isin(col_data, vals)
+
+        # Combine the current column mask with the overall mask
+        col_mask &= this_mask
+
+    return col_mask