def __init__(self, default_config_filename=None, config_files=None, **kwargs):
"""Load configuration files related to this plugin.
This initializes a `self.config` dictionary that can be used to customize the subclass.
Args:
default_config_filename (str): Configuration filename to use if
no other files have been specified with `config_files`.
config_files (list or str): Configuration files to load instead
of those automatically found in `SATPY_CONFIG_PATH` and other
default configuration locations.
kwargs (dict): Unused keyword arguments.
"""
self.default_config_filename = default_config_filename
self.config_files = config_files
if self.config_files is None and self.default_config_filename is not None:
# Specify a default
self.config_files = config_search_paths(self.default_config_filename)
if not isinstance(self.config_files, (list, tuple)):
self.config_files = [self.config_files]
self.config = {}
if self.config_files:
for config_file in self.config_files:
self.load_yaml_config(config_file)
def __init__(self, enhancement_config_file=None):
"""Initialize an Enhancer instance.
Args:
enhancement_config_file: The enhancement configuration to apply, False to leave as is.
"""
self.enhancement_config_file = enhancement_config_file
# Set enhancement_config_file to False for no enhancements
if self.enhancement_config_file is None:
# it wasn't specified in the config or in the kwargs, we should
# provide a default
config_fn = os.path.join("enhancements", "generic.yaml")
self.enhancement_config_file = config_search_paths(config_fn)
if not self.enhancement_config_file:
# They don't want any automatic enhancements
self.enhancement_tree = None
else:
if not isinstance(self.enhancement_config_file, (list, tuple)):
self.enhancement_config_file = [self.enhancement_config_file]
self.enhancement_tree = EnhancementDecisionTree(
*self.enhancement_config_file)
self.sensor_enhancement_configs = []
def configs_for_writer(writer=None):
"""Generate writer configuration files for one or more writers.
Args:
writer (Optional[str]): Yield configs only for this writer
Returns: Generator of lists of configuration files
"""
if writer is not None:
if not isinstance(writer, (list, tuple)):
writer = [writer]
# given a config filename or writer name
config_files = [
w if w.endswith('.yaml') else w + '.yaml' for w in writer
]
else:
writer_configs = glob_config(os.path.join('writers', '*.yaml'))
config_files = set(writer_configs)
for config_file in config_files:
config_basename = os.path.basename(config_file)
writer_configs = config_search_paths(
os.path.join("writers", config_basename))
if not writer_configs:
LOG.warning("No writer configs found for '%s'", writer)
continue
yield writer_configs
def setUp(self):
"""Wrap NetCDF4 file handler with our own fake handler."""
from satpy._config import config_search_paths
from satpy.readers.mimic_TPW2_nc import MimicTPW2FileHandler
self.reader_configs = config_search_paths(os.path.join('readers', self.yaml_file))
# http://stackoverflow.com/questions/12219967/how-to-mock-a-base-class-with-python-mock-library
self.p = mock.patch.object(MimicTPW2FileHandler, '__bases__', (FakeNetCDF4FileHandlerMimicLow,))
self.fake_handler = self.p.start()
self.p.is_local = True
def fixture_reader():
"""Return MVIRI FIDUCEO FCDR reader."""
from satpy._config import config_search_paths
from satpy.readers import load_reader
reader_configs = config_search_paths(
os.path.join("readers", "mviri_l1b_fiduceo_nc.yaml"))
reader = load_reader(reader_configs)
return reader
def reader():
"""Return reader for CMSAF CLAAS-2."""
from satpy._config import config_search_paths
from satpy.readers import load_reader
reader_configs = config_search_paths(
os.path.join("readers", "cmsaf-claas2_l2_nc.yaml"))
reader = load_reader(reader_configs)
return reader
def setup_method(self):
"""Wrap NetCDF4 file handler with our own fake handler."""
from satpy._config import config_search_paths
from satpy.readers.viirs_l1b import VIIRSL1BFileHandler
self.reader_configs = config_search_paths(os.path.join('readers', self.yaml_file))
# http://stackoverflow.com/questions/12219967/how-to-mock-a-base-class-with-python-mock-library
self.p = mock.patch.object(VIIRSL1BFileHandler, '__bases__', (self.fake_cls,))
self.fake_handler = self.p.start()
self.p.is_local = True
def setUp(self):
"""Wrap CDF4 file handler with own fake file handler."""
from satpy._config import config_search_paths
from satpy.readers.viirs_edr_active_fires import VIIRSActiveFiresFileHandler
self.reader_configs = config_search_paths(
os.path.join('readers', self.yaml_file))
self.p = mock.patch.object(VIIRSActiveFiresFileHandler, '__bases__',
(FakeImgFiresNetCDF4FileHandler, ))
self.fake_handler = self.p.start()
self.p.is_local = True
def setup_method(self):
"""Wrap pygrib to read fake data."""
from satpy._config import config_search_paths
self.reader_configs = config_search_paths(os.path.join('readers', self.yaml_file))
try:
import pygrib
except ImportError:
pygrib = None
self.orig_pygrib = pygrib
sys.modules['pygrib'] = mock.MagicMock()
def get_sensor_enhancement_config(self, sensor):
"""Get the sensor-specific config."""
if isinstance(sensor, str):
# one single sensor
sensor = [sensor]
for sensor_name in sensor:
config_fn = os.path.join("enhancements", sensor_name + ".yaml")
config_files = config_search_paths(config_fn)
# Note: Enhancement configuration files can't overwrite individual
# options, only entire sections are overwritten
for config_file in config_files:
yield config_file
def load_writer(writer, **writer_kwargs):
"""Find and load writer `writer` in the available configuration files."""
config_fn = writer + ".yaml" if "." not in writer else writer
config_files = config_search_paths(os.path.join("writers", config_fn))
writer_kwargs.setdefault("config_files", config_files)
if not writer_kwargs['config_files']:
raise ValueError("Unknown writer '{}'".format(writer))
try:
return load_writer_configs(writer_kwargs['config_files'],
**writer_kwargs)
except ValueError:
raise ValueError("Writer '{}' does not exist or could not be "
"loaded".format(writer))
def load_sensor_composites(self, sensor_name):
"""Load all compositor configs for the provided sensor."""
config_filename = 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(os.path.join(
"composites", config_filename),
search_dirs=paths,
check_exists=True)
if not composite_configs:
logger.debug("No composite config found called %s",
config_filename)
return
self._load_config(composite_configs)
def configs_for_reader(reader=None):
"""Generate reader configuration files for one or more readers.
Args:
reader (Optional[str]): Yield configs only for this reader
Returns: Generator of lists of configuration files
"""
if reader is not None:
if not isinstance(reader, (list, tuple)):
reader = [reader]
# check for old reader names
new_readers = []
for reader_name in reader:
if reader_name.endswith(
'.yaml') or reader_name not in OLD_READER_NAMES:
new_readers.append(reader_name)
continue
new_name = OLD_READER_NAMES[reader_name]
# Satpy 0.11 only displays a warning
# Satpy 0.13 will raise an exception
raise ValueError(
"Reader name '{}' has been deprecated, use '{}' instead.".
format(reader_name, new_name))
# Satpy 0.15 or 1.0, remove exception and mapping
reader = new_readers
# given a config filename or reader name
config_files = [
r if r.endswith('.yaml') else r + '.yaml' for r in reader
]
else:
reader_configs = glob_config(os.path.join('readers', '*.yaml'))
config_files = set(reader_configs)
for config_file in config_files:
config_basename = os.path.basename(config_file)
reader_name = os.path.splitext(config_basename)[0]
reader_configs = config_search_paths(
os.path.join("readers", config_basename))
if not reader_configs:
# either the reader they asked for does not exist
# or satpy is improperly configured and can't find its own readers
raise ValueError("No reader named: {}".format(reader_name))
yield reader_configs
def setUp(self, xr_):
"""Create a fake reader to test."""
from satpy.readers import load_reader
from satpy._config import config_search_paths
self.reader_configs = config_search_paths(
os.path.join('readers', self.yaml_file))
fake_dataset = setup_fake_dataset()
xr_.open_dataset.return_value = fake_dataset
r = load_reader(self.reader_configs)
loadables = r.select_files_from_pathnames([
'OR_GLM-L2-GLMC-M3_G16_s20192862159000_e20192862200000_c20192862200350.nc',
])
self.assertEqual(len(loadables), 1)
r.create_filehandlers(loadables)
self.reader = r
def setup(self):
"""Wrap HDF5 file handler with our own fake handler."""
from satpy._config import config_search_paths
from satpy.readers.agri_l1 import HDF_AGRI_L1
self.reader_configs = config_search_paths(
os.path.join('readers', self.yaml_file))
# http://stackoverflow.com/questions/12219967/how-to-mock-a-base-class-with-python-mock-library
self.p = mock.patch.object(HDF_AGRI_L1, '__bases__',
(FakeHDF5FileHandler2, ))
self.fake_handler = self.p.start()
self.p.is_local = True
self.expected = {
1:
np.array([[2.01, 2.02, 2.03, 2.04, 2.05],
[2.06, 2.07, 2.08, 2.09, 2.1]]),
2:
np.array([[4.03, 4.06, 4.09, 4.12, 4.15],
[4.18, 4.21, 4.24, 4.27, 4.3]]),
3:
np.array([[6.05, 6.1, 6.15, 6.2, 6.25],
[6.3, 6.35, 6.4, 6.45, 6.5]]),
4:
np.array([[8.07, 8.14, 8.21, 8.28, 8.35],
[8.42, 8.49, 8.56, 8.63, 8.7]]),
5:
np.array([[10.09, 10.18, 10.27, 10.36, 10.45],
[10.54, 10.63, 10.72, 10.81, 10.9]]),
6:
np.array([[12.11, 12.22, 12.33, 12.44, 12.55],
[12.66, 12.77, 12.88, 12.99, 13.1]]),
7:
np.array([[0.2, 0.3, 0.4, 0.5, 0.6], [0.7, 0.8, 0.9, 1., np.nan]]),
8:
np.array([[0.2, 0.3, 0.4, 0.5, 0.6], [0.7, 0.8, 0.9, 1., np.nan]]),
9:
np.array([[0.2, 0.3, 0.4, 0.5, 0.6], [0.7, 0.8, 0.9, 1., np.nan]]),
10:
np.array([[0.2, 0.3, 0.4, 0.5, 0.6], [0.7, 0.8, 0.9, 1., np.nan]]),
11:
np.array([[0.2, 0.3, 0.4, 0.5, 0.6], [0.7, 0.8, 0.9, 1., np.nan]]),
12:
np.array([[0.2, 0.3, 0.4, 0.5, 0.6], [0.7, 0.8, 0.9, 1., np.nan]]),
13:
np.array([[0.2, 0.3, 0.4, 0.5, 0.6], [0.7, 0.8, 0.9, 1., np.nan]]),
14:
np.array([[0.2, 0.3, 0.4, 0.5, 0.6], [0.7, 0.8, 0.9, 1., np.nan]])
}
def setup_method(self):
"""Wrap pygrib to read fake data."""
from satpy._config import config_search_paths
self.reader_configs = config_search_paths(
os.path.join('readers', self.yaml_file))
