Switch to WMO Instruments

satpy/_config.py

@@ -54,6 +54,7 @@
     "readers": {
         "clip_negative_radiances": False,
     },
+    "instruments_key": "sensor"
 }
 
 # Satpy main configuration object

satpy/composites/aux_data.py

@@ -23,6 +23,7 @@
 
 import satpy
 from satpy.aux_download import DataDownloadMixin
+from satpy.utils import set_instruments_attr
 
 from .core import GenericCompositor
 
@@ -156,7 +157,7 @@ def __call__(self, *args, **kwargs):
             if self.area is None:
                 raise AttributeError("Area definition needs to be configured")
             img.attrs["area"] = self.area
-        img.attrs["sensor"] = None
+        set_instruments_attr(img.attrs, set())
         img.attrs["mode"] = "".join(img.bands.data)
         img.attrs.pop("modifiers", None)
         img.attrs.pop("calibration", None)

satpy/composites/config_loader.py

@@ -31,7 +31,7 @@
 from satpy import DataID, DataQuery
 from satpy._config import config_search_paths, get_entry_points_config_dirs, glob_config
 from satpy.dataset.dataid import minimal_default_keys_config
-from satpy.utils import recursive_dict_update
+from satpy.utils import normalize_instrument_name, recursive_dict_update
 
 logger = logging.getLogger(__name__)
 
@@ -268,7 +268,7 @@ def load_compositor_configs_for_sensor(sensor_name: str) -> tuple[dict[str, dict
                 DataID key -> key properties
 
     """
-    config_filename = sensor_name + ".yaml"
+    config_filename = normalize_instrument_name(sensor_name) + ".yaml"
     logger.debug("Looking for composites config file %s", config_filename)
     paths = get_entry_points_config_dirs("satpy.composites")
     composite_configs = config_search_paths(

satpy/composites/core.py

@@ -28,7 +28,7 @@
 
 from satpy.dataset import DataID, combine_metadata
 from satpy.dataset.dataid import minimal_default_keys_config
-from satpy.utils import unify_chunks
+from satpy.utils import get_instruments_from_attrs, set_instruments_attr, unify_chunks
 
 LOG = logging.getLogger(__name__)
 
@@ -433,20 +433,11 @@ def _concat_datasets(self, projectables, mode):
 
         return data
 
-    def _get_sensors(self, projectables):
-        sensor = set()
+    def _get_sensors(self, projectables) -> set[str]:
+        sensors = set()
         for projectable in projectables:
-            current_sensor = projectable.attrs.get("sensor", None)
-            if current_sensor:
-                if isinstance(current_sensor, (str, bytes)):
-                    sensor.add(current_sensor)
-                else:
-                    sensor |= current_sensor
-        if len(sensor) == 0:
-            sensor = None
-        elif len(sensor) == 1:
-            sensor = list(sensor)[0]
-        return sensor
+            sensors.update(get_instruments_from_attrs(projectable.attrs))
+        return sensors
 
     def __call__(
             self,
@@ -512,7 +503,7 @@ def _get_updated_attrs(self, datasets, attrs, mode):
         new_attrs.update(self.attrs)
         if resolution is not None:
             new_attrs["resolution"] = resolution
-        new_attrs["sensor"] = self._get_sensors(datasets)
+        set_instruments_attr(new_attrs, self._get_sensors(datasets))
         new_attrs["mode"] = mode
 
         return new_attrs

satpy/composites/fill.py

@@ -26,6 +26,7 @@
 import xarray as xr
 
 from satpy.dataset import combine_metadata
+from satpy.utils import get_instruments_from_attrs, set_instruments_attr
 
 from .core import (
     GenericCompositor,
@@ -406,9 +407,10 @@ def _combine_metadata_with_mode_and_sensor(self,
         # 'mode' is no longer valid after we've remove the 'A'
         # let the base class __call__ determine mode
         attrs.pop("mode", None)
-        if attrs.get("sensor") is None:
+        if not get_instruments_from_attrs(attrs):
             # sensor can be a set
-            attrs["sensor"] = self._get_sensors([foreground, background])
+            instruments = self._get_sensors([foreground, background])
+            set_instruments_attr(attrs, instruments)
         return attrs
 
     @staticmethod

satpy/composites/glm.py

@@ -97,7 +97,7 @@ def _update_attrs(self, new_data, background_layer, highlight_layer):
         new_data.attrs["units"] = 1
         new_sensors = self._get_sensors((highlight_layer, background_layer))
         new_data.attrs.update({
-            "sensor": new_sensors,
+            "instruments": new_sensors,
         })
 
     def __call__(self, projectables, optional_datasets=None, **attrs):

satpy/enhancements/enhancer.py

@@ -1,4 +1,4 @@
 # Copyright (c) 2025 Satpy developers
 #
 # This file is part of satpy.
 #
@@ -24,7 +24,13 @@
 
 from satpy._config import config_search_paths, get_entry_points_config_dirs
 from satpy.decision_tree import DecisionTree
-from satpy.utils import get_logger, recursive_dict_update
+from satpy.utils import (
+    get_instruments_from_attrs,
+    get_instruments_key,
+    get_logger,
+    normalize_instrument_name,
+    recursive_dict_update,
+)
 
 LOG = get_logger(__name__)
 
@@ -34,16 +40,17 @@
 
     def __init__(self, *decision_dicts, **kwargs):
         """Init the decision tree."""
+        instr_key = get_instruments_key()
         match_keys = kwargs.pop("match_keys",
                                 ("name",
                                  "reader",
                                  "platform_name",
-                                 "sensor",
+                                 instr_key,
                                  "standard_name",
                                  "units",
                                  ))
         self.prefix = kwargs.pop("config_section", "enhancements")
-        multival_keys = kwargs.pop("multival_keys", ["sensor"])
+        multival_keys = kwargs.pop("multival_keys", [instr_key])
         super(EnhancementDecisionTree, self).__init__(
             decision_dicts, match_keys, multival_keys)
 
@@ -122,26 +129,23 @@
 
         self.sensor_enhancement_configs = []
 
-    def get_sensor_enhancement_config(self, sensor):
+    def get_sensor_enhancement_config(self, sensors: set[str]):
         """Get the sensor-specific config."""
-        if isinstance(sensor, str):
-            # one single sensor
-            sensor = [sensor]
-
         paths = get_entry_points_config_dirs("satpy.enhancements")
-        for sensor_name in sensor:
-            config_fn = os.path.join("enhancements", sensor_name + ".yaml")
+        for sensor_name in sensors:
+            basename = normalize_instrument_name(sensor_name) + ".yaml"
+            config_fn = os.path.join("enhancements", basename)
             config_files = config_search_paths(config_fn, search_dirs=paths)
             # Note: Enhancement configuration files can't overwrite individual
             # options, only entire sections are overwritten
             for config_file in config_files:
                 yield config_file
 
-    def add_sensor_enhancements(self, sensor):
+    def add_sensor_enhancements(self, sensors: set[str]):
         """Add sensor-specific enhancements."""
         # XXX: Should we just load all enhancements from the base directory?
         new_configs = []
-        for config_file in self.get_sensor_enhancement_config(sensor):
+        for config_file in self.get_sensor_enhancement_config(sensors):
             if config_file not in self.sensor_enhancement_configs:
                 self.sensor_enhancement_configs.append(config_file)
                 new_configs.append(config_file)
@@ -209,9 +213,9 @@
     if enhancer is None or enhancer.enhancement_tree is None:
         LOG.debug("No enhancement being applied to dataset")
     else:
-        if dataset.attrs.get("sensor", None):
-            enhancer.add_sensor_enhancements(dataset.attrs["sensor"])
-
+        sensors = get_instruments_from_attrs(dataset.attrs)
+        if sensors:
+            enhancer.add_sensor_enhancements(sensors)
         enhancer.apply(img, **dataset.attrs)
 
     if overlay is not None:

satpy/modifiers/_crefl_utils.py

@@ -70,6 +70,7 @@
 import xarray as xr
 
 from satpy.dataset.dataid import WavelengthRange
+from satpy.utils import get_one_instrument_from_attrs, normalize_instrument_name
 
 LOG = logging.getLogger(__name__)
 
@@ -282,7 +283,8 @@ def run_crefl(refl,
     :param avg_elevation: average elevation (usually pre-calculated and stored in CMGDEM.hdf)
 
     """
-    runner_cls = _runner_class_for_sensor(refl.attrs["sensor"])
+    sensor = get_one_instrument_from_attrs(refl.attrs)
+    runner_cls = _runner_class_for_sensor(sensor)
     runner = runner_cls(refl)
     corr_refl = runner(sensor_azimuth, sensor_zenith, solar_azimuth, solar_zenith, avg_elevation)
     return corr_refl
@@ -348,8 +350,9 @@ def _run_crefl(self, mus, muv, phi, solar_zenith, sensor_zenith, height, coeffs)
 
 class _VIIRSMODISCREFLRunner(_CREFLRunner):
     def _run_crefl(self, mus, muv, phi, solar_zenith, sensor_zenith, height, coeffs):
+        instrument = get_one_instrument_from_attrs(self._refl.attrs)
         return da.map_blocks(_run_crefl, self._refl.data, mus.data, muv.data, phi.data,
-                             height, self._refl.attrs.get("sensor"), *coeffs,
+                             height, instrument, *coeffs,
                              meta=np.ndarray((), dtype=self._refl.dtype),
                              chunks=self._refl.chunks, dtype=self._refl.dtype,
                              )
@@ -384,7 +387,7 @@ def _run_crefl(self, mus, muv, phi, solar_zenith, sensor_zenith, height, coeffs)
 
 def _runner_class_for_sensor(sensor_name: str) -> Type[_CREFLRunner]:
     try:
-        return _SENSOR_TO_RUNNER[sensor_name]
+        return _SENSOR_TO_RUNNER[normalize_instrument_name(sensor_name)]
     except KeyError:
         raise NotImplementedError(f"Don't know how to apply CREFL to data from sensor {sensor_name}.")
 

satpy/modifiers/atmosphere.py

@@ -26,6 +26,7 @@
 from satpy.modifiers import ModifierBase
 from satpy.modifiers._crefl import ReflectanceCorrector  # noqa
 from satpy.modifiers.angles import compute_relative_azimuth, get_angles, get_satellite_zenith_angle
+from satpy.utils import get_one_instrument_from_attrs, get_pyspectral_instrument_name
 
 logger = logging.getLogger(__name__)
 
@@ -104,7 +105,10 @@ def __call__(self, projectables, optional_datasets=None, **info):
         logger.info("Removing Rayleigh scattering with atmosphere '%s' and "
                     "aerosol type '%s' for '%s'",
                     atmosphere, aerosol_type, vis.attrs["name"])
-        corrector = Rayleigh(vis.attrs["platform_name"], vis.attrs["sensor"],
+        sensor = get_pyspectral_instrument_name(
+            get_one_instrument_from_attrs(vis.attrs)
+        )
+        corrector = Rayleigh(vis.attrs["platform_name"], sensor,
                              atmosphere=atmosphere,
                              aerosol_type=aerosol_type)
 
@@ -158,8 +162,11 @@ def __call__(self, projectables, optional_datasets=None, **info):
         satz = satz.data  # get dask array underneath
 
         logger.info("Correction for limb cooling")
+        sensor = get_pyspectral_instrument_name(
+            get_one_instrument_from_attrs(band.attrs)
+        )
         corrector = AtmosphericalCorrection(band.attrs["platform_name"],
-                                            band.attrs["sensor"])
+                                            sensor)
 
         atm_corr = da.map_blocks(_call_mapped_correction, satz, band.data,
                                  corrector=corrector,

satpy/modifiers/spectral.py

@@ -22,6 +22,7 @@
 import xarray as xr
 
 from satpy.modifiers import ModifierBase
+from satpy.utils import get_one_instrument_from_attrs, get_pyspectral_instrument_name
 
 try:
     from pyspectral.near_infrared_reflectance import Calculator
@@ -131,8 +132,10 @@ def _init_reflectance_calculator(self, metadata):
         if not Calculator:
             logger.info("Couldn't load pyspectral")
             raise ImportError("No module named pyspectral.near_infrared_reflectance")
-
-        reflectance_3x_calculator = Calculator(metadata["platform_name"], metadata["sensor"], metadata["name"],
+        sensor = get_pyspectral_instrument_name(
+            get_one_instrument_from_attrs(metadata)
+        )
+        reflectance_3x_calculator = Calculator(metadata["platform_name"], sensor, metadata["name"],
                                                sunz_threshold=self.sun_zenith_threshold,
                                                masking_limit=self.masking_limit)
         return reflectance_3x_calculator

satpy/readers/abi_l1b.py

@@ -73,7 +73,7 @@ def get_dataset(self, key, info):
 
     def _adjust_attrs(self, data, key):
         data.attrs.update({"platform_name": self.platform_name,
-                          "sensor": self.sensor})
+                          "sensor": {self.sensor}})
         # Add orbital parameters
         projection = self.nc["goes_imager_projection"]
         data.attrs["orbital_parameters"] = {

satpy/readers/core/file_handlers.py

@@ -155,7 +155,7 @@ def end_time(self):
         return self.filename_info.get("end_time", self.start_time)
 
     @property
-    def sensor_names(self):
+    def sensor_names(self) -> set:
         """List of sensors represented in this file."""
         raise NotImplementedError
 

satpy/scene.py

@@ -1,4 +1,4 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Copyright (c) 2010-2022 Satpy developers
 #
@@ -36,7 +36,11 @@
 from satpy.dependency_tree import DependencyTree
 from satpy.node import CompositorNode, MissingDependencies, ReaderNode
 from satpy.readers.core.loading import load_readers
-from satpy.utils import convert_remote_files_to_fsspec, get_storage_options_from_reader_kwargs
+from satpy.utils import (
+    convert_remote_files_to_fsspec,
+    get_instruments_from_attrs,
+    get_storage_options_from_reader_kwargs,
+)
 
 LOG = logging.getLogger(__name__)
 
@@ -197,12 +201,7 @@
     def _contained_sensor_names(self) -> set[str]:
         sensor_names = set()
         for data_arr in self.values():
-            if "sensor" not in data_arr.attrs:
-                continue
-            if isinstance(data_arr.attrs["sensor"], str):
-                sensor_names.add(data_arr.attrs["sensor"])
-            elif isinstance(data_arr.attrs["sensor"], set):
-                sensor_names.update(data_arr.attrs["sensor"])
+            sensor_names.update(get_instruments_from_attrs(data_arr.attrs))
         return sensor_names
 
     @property

satpy/tests/compositor_tests/test_aux_data.py

@@ -83,7 +83,7 @@ def load(self, arg):
                                       filenames=[IMAGE_FILENAME])
         register.assert_not_called()
         retrieve.assert_not_called()
-        assert res.attrs["sensor"] is None
+        assert res.attrs["sensor"] == set()
         assert "modifiers" not in res.attrs
         assert "calibration" not in res.attrs
 
@@ -95,7 +95,7 @@ def load(self, arg):
         res = comp()
         Scene.assert_called_once_with(reader="generic_image",
                                       filenames=[os.path.join("data_dir", "foo.tif")])
-        assert res.attrs["sensor"] is None
+        assert res.attrs["sensor"] == set()
         assert "modifiers" not in res.attrs
         assert "calibration" not in res.attrs
 

satpy/tests/compositor_tests/test_core.py

@@ -277,13 +277,13 @@ def test_concat_datasets(self):
     def test_get_sensors(self):
         """Test getting sensors from the dataset attributes."""
         res = self.comp._get_sensors([self.all_valid])
-        assert res is None
+        assert res == set()
         dset1 = self.all_valid
         dset1.attrs["sensor"] = "foo"
         res = self.comp._get_sensors([dset1])
-        assert res == "foo"
+        assert res == {"foo"}
         dset2 = self.first_invalid
-        dset2.attrs["sensor"] = "bar"
+        dset2.attrs["sensor"] = {"bar"}
         res = self.comp._get_sensors([dset1, dset2])
         assert "foo" in res
         assert "bar" in res
@@ -327,12 +327,12 @@ def test_call(self):
         """Test calling generic compositor."""
         # Multiple datasets with extra attributes
         all_valid = self.all_valid
-        all_valid.attrs["sensor"] = "foo"
+        all_valid.attrs["sensor"] = {"foo"}
         attrs = {"foo": "bar", "resolution": 333}
         self.comp.attrs["resolution"] = None
         res = self.comp([self.all_valid, self.first_invalid], **attrs)
         # Verify attributes
-        assert res.attrs.get("sensor") == "foo"
+        assert res.attrs.get("sensor") == {"foo"}
         assert "foo" in res.attrs
         assert res.attrs.get("foo") == "bar"
         assert "units" not in res.attrs

satpy/tests/reader_tests/test_abi_l1b.py

@@ -371,7 +371,7 @@ def test_get_dataset(self, c01_data_arr):
             "scan_mode": "M4",
             "scene_abbr": "C",
             "scene_id": None,
-            "sensor": "abi",
+            "sensor": {"abi"},
             "timeline_ID": None,
             "suffix": "suffix",
             "units": "W m-2 um-1 sr-1",