Add shared_key option to DataQuery equality checks

Author: djhoese

satpy/dataset/dataid.py

@@ -14,11 +14,13 @@
 # You should have received a copy of the GNU General Public License along with
 # satpy.  If not, see <http://www.gnu.org/licenses/>.
 """Dataset identifying objects."""
+from __future__ import annotations
 
 import logging
 import numbers
 from copy import copy, deepcopy
 from enum import Enum
+from functools import partial
 from typing import Any, NoReturn
 
 import numpy as np
@@ -261,7 +263,7 @@ def __getitem__(self, key):
         """Get an item."""
         return self._dict[key]
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         """Compare the DataQuerys.
 
         A DataQuery is considered equal to another DataQuery if all keys
@@ -271,6 +273,20 @@ def __eq__(self, other):
         contains additional elements. Any DataQuery elements with the value
         ``"*"`` are ignored.
 
+        """
+        return self.equal(other, shared_keys=False)
+
+    def equal(self, other: Any, shared_keys: bool = False) -> bool:
+        """Compare this DataQuery to another DataQuery or a DataID.
+
+        Args:
+            other: Other DataQuery or DataID to compare against.
+            shared_keys: Limit keys being compared to those shared
+                by both objects. If False (default), then all of the
+                current query's keys are used when compared against
+                a DataID. If compared against another DataQuery then
+                all keys are compared between the two queries.
+
         """
         sdict = self._asdict()
         try:
@@ -287,6 +303,9 @@ def __eq__(self, other):
         if not o_is_id:
             # if another DataQuery, then compare both sets of keys
             keys_to_match |= set(odict.keys())
+        if shared_keys:
+            # only compare with the keys that both objects share
+            keys_to_match &= set(odict.keys())
         if not keys_to_match:
             return False
 
@@ -374,9 +393,10 @@ def __repr__(self):
         items = ("{}={}".format(key, repr(val)) for key, val in zip(self._fields, self._values))
         return self.__class__.__name__ + "(" + ", ".join(items) + ")"
 
-    def filter_dataids(self, dataid_container):
+    def filter_dataids(self, dataid_container, shared_keys: bool = False):
         """Filter DataIDs based on this query."""
-        keys = list(filter(self.__eq__, dataid_container))
+        func = partial(self.equal, shared_keys=shared_keys)
+        keys = list(filter(func, dataid_container))
         return keys
 
     def sort_dataids_with_preference(self, all_ids, preference):

satpy/dependency_tree.py

@@ -515,26 +515,17 @@ def _get_compositor_by_name(self, key: DataQuery) -> Compositor | None:
         name_query = DataQuery(name=key["name"])
         for sensor_name in sorted(self.compositors):
             sensor_data_dict = self.compositors[sensor_name]
-            try:
-                # get all IDs that have the minimum "distance" for our composite name
-                all_comp_ids = sensor_data_dict.get_key(name_query, num_results=0)
-                # Filter to those that don't disagree with the original query
-                matching_comp_ids = []
-                for comp_id in all_comp_ids:
-                    for query_key, query_val in key.to_dict().items():
-                        # TODO: Handle query_vals that are lists
-                        if comp_id.get(query_key, query_val) != query_val:
-                            break
-                    else:
-                        # all query keys match
-                        matching_comp_ids.append(comp_id)
-                if len(matching_comp_ids) > 1:
-                    warnings.warn("Multiple compositors matching {name_query} to create {key} variant. "
-                                  "Going to use the name-only 'base' compositor definition.")
-                    matching_comp_ids = matching_comp_ids[:1]
-            except KeyError:
+            # get all IDs that have the minimum "distance" for our composite name
+            all_comp_ids = sensor_data_dict.get_key(name_query, num_results=0)
+            if len(all_comp_ids) == 0:
                 continue
 
+            # Filter to those that don't disagree with the original query
+            matching_comp_ids = key.filter_dataids(all_comp_ids, shared_keys=True)
+            if len(matching_comp_ids) > 1:
+                warnings.warn("Multiple compositors matching {name_query} to create {key} variant. "
+                              "Going to use the name-only 'base' compositor definition.")
+                matching_comp_ids = matching_comp_ids[:1]
             if len(matching_comp_ids) != 1:
                 raise KeyError("Can't find compositor {key['name']} by name only.")
             comp_id = matching_comp_ids[0]