def test_all_datasets_multiple_reader(self, cri, cl):
from satpy import Scene
from satpy.tests.utils import create_fake_reader, test_composites
r = create_fake_reader('fake_reader', 'fake_sensor', datasets=['ds1'])
r2 = create_fake_reader('fake_reader2', 'fake_sensor2', datasets=['ds2'])
cri.return_value = {'fake_reader': r, 'fake_reader2': r2}
comps, mods = test_composites('fake_sensor')
cl.return_value = (comps, mods)
scene = Scene(filenames='bla',
base_dir='bli',
reader='fake_reader')
# patch the cpl
scene.cpl.compositors = comps
scene.cpl.modifiers = mods
id_list = scene.all_dataset_ids()
self.assertEqual(len(id_list), 2)
id_list = scene.all_dataset_ids(composites=True)
self.assertEqual(len(id_list),
2 + len(scene.cpl.compositors['fake_sensor'].keys()))
def test_load_comp8(self, cri, cl):
"""Test loading a composite that has a non-existent prereq"""
import satpy.scene
from satpy.tests.utils import create_fake_reader, test_composites
cri.return_value = {'fake_reader': create_fake_reader('fake_reader', 'fake_sensor')}
comps, mods = test_composites('fake_sensor')
cl.return_value = (comps, mods)
scene = satpy.scene.Scene(filenames='bla',
base_dir='bli',
reader='fake_reader')
self.assertRaises(KeyError, scene.load, ['comp8'])
def test_load_no_exist(self, cri, cl):
"""Test loading a dataset that doesn't exist"""
import satpy.scene
from satpy.tests.utils import create_fake_reader, test_composites
cri.return_value = {'fake_reader': create_fake_reader('fake_reader', 'fake_sensor')}
comps, mods = test_composites('fake_sensor')
cl.return_value = (comps, mods)
scene = satpy.scene.Scene(filenames='bla',
base_dir='bli',
reader='fake_reader')
self.assertRaises(KeyError, scene.load, ['im_a_dataset_that_doesnt_exist'])
def test_load_ds9_fail_load(self, cri, cl):
"""Test loading a dataset that will fail during load"""
import satpy.scene
from satpy.tests.utils import create_fake_reader, test_composites
cri.return_value = {'fake_reader': create_fake_reader('fake_reader', 'fake_sensor')}
comps, mods = test_composites('fake_sensor')
cl.return_value = (comps, mods)
scene = satpy.scene.Scene(filenames='bla',
base_dir='bli',
reader='fake_reader')
scene.load(['ds9_fail_load'])
loaded_ids = list(scene.datasets.keys())
self.assertEquals(len(loaded_ids), 0)
def test_load_ds1_no_comps(self, cri):
"""Test loading one dataset with no loaded compositors"""
import satpy.scene
from satpy.tests.utils import create_fake_reader
from satpy import DatasetID
cri.return_value = {'fake_reader': create_fake_reader('fake_reader', 'fake_sensor')}
scene = satpy.scene.Scene(filenames='bla',
base_dir='bli',
reader='fake_reader')
scene.load(['ds1'])
loaded_ids = list(scene.datasets.keys())
self.assertEquals(len(loaded_ids), 1)
self.assertTupleEqual(tuple(loaded_ids[0]), tuple(DatasetID(name='ds1')))
def test_load_ds6_wl(self, cri, cl):
"""Test loading a dataset by wavelength"""
import satpy.scene
from satpy.tests.utils import create_fake_reader, test_composites
cri.return_value = {'fake_reader': create_fake_reader('fake_reader', 'fake_sensor')}
comps, mods = test_composites('fake_sensor')
cl.return_value = (comps, mods)
scene = satpy.scene.Scene(filenames='bla',
base_dir='bli',
reader='fake_reader')
scene.load([0.22])
loaded_ids = list(scene.datasets.keys())
self.assertEquals(len(loaded_ids), 1)
self.assertEquals(loaded_ids[0].name, 'ds6')
def test_load_ds4_cal(self, cri, cl):
"""Test loading a dataset that has two calibration variations"""
import satpy.scene
from satpy.tests.utils import create_fake_reader, test_composites
cri.return_value = {'fake_reader': create_fake_reader('fake_reader', 'fake_sensor')}
comps, mods = test_composites('fake_sensor')
cl.return_value = (comps, mods)
scene = satpy.scene.Scene(filenames='bla',
base_dir='bli',
reader='fake_reader')
scene.load(['ds4'])
loaded_ids = list(scene.datasets.keys())
self.assertEquals(len(loaded_ids), 1)
self.assertEquals(loaded_ids[0].calibration, 'reflectance')
def test_load_multiple_comps(self, cri, cl):
"""Test loading multiple composites"""
import satpy.scene
from satpy.tests.utils import create_fake_reader, test_composites
cri.return_value = {'fake_reader': create_fake_reader('fake_reader', 'fake_sensor')}
comps, mods = test_composites('fake_sensor')
cl.return_value = (comps, mods)
scene = satpy.scene.Scene(filenames='bla',
base_dir='bli',
reader='fake_reader')
scene.load(['comp1', 'comp2', 'comp3', 'comp4', 'comp5', 'comp6',
'comp7', 'comp9', 'comp10'])
loaded_ids = list(scene.datasets.keys())
self.assertEquals(len(loaded_ids), 9)
def test_start_end_times(self):
import satpy.scene
from satpy.tests.utils import create_fake_reader
from datetime import datetime
with mock.patch('satpy.scene.Scene.create_reader_instances') as cri:
r = create_fake_reader('fake_reader',
start_time=datetime(2017, 1, 1, 0, 0, 0),
end_time=datetime(2017, 1, 1, 1, 0, 0),
)
cri.return_value = {'fake_reader': r}
scene = satpy.scene.Scene(filenames='bla',
base_dir='bli',
sensor='fake_sensor')
self.assertEqual(scene.start_time, r.start_time)
self.assertEqual(scene.end_time, r.end_time)
def test_load_comp6(self, cri, cl):
"""Test loading a composite that has an optional composite prerequisite"""
import satpy.scene
from satpy.tests.utils import create_fake_reader, test_composites
from satpy import DatasetID
cri.return_value = {'fake_reader': create_fake_reader('fake_reader', 'fake_sensor')}
comps, mods = test_composites('fake_sensor')
cl.return_value = (comps, mods)
scene = satpy.scene.Scene(filenames='bla',
base_dir='bli',
reader='fake_reader')
scene.load(['comp6'])
loaded_ids = list(scene.datasets.keys())
self.assertEquals(len(loaded_ids), 1)
self.assertTupleEqual(tuple(loaded_ids[0]), tuple(DatasetID(name='comp6')))
def test_load_modified(self, cri, cl):
"""Test loading a modified dataset"""
import satpy.scene
from satpy.tests.utils import create_fake_reader, test_composites
from satpy import DatasetID
cri.return_value = {'fake_reader': create_fake_reader('fake_reader', 'fake_sensor')}
comps, mods = test_composites('fake_sensor')
cl.return_value = (comps, mods)
scene = satpy.scene.Scene(filenames='bla',
base_dir='bli',
reader='fake_reader')
scene.load([DatasetID(name='ds1', modifiers=('mod1', 'mod2'))])
loaded_ids = list(scene.datasets.keys())
self.assertEquals(len(loaded_ids), 1)
self.assertTupleEqual(loaded_ids[0].modifiers, ('mod1', 'mod2'))
def test_load_comp17(self, cri, cl):
"""Test loading a composite that depends on a composite that won't load
"""
import satpy.scene
from satpy.tests.utils import create_fake_reader, test_composites
cri.return_value = {'fake_reader': create_fake_reader('fake_reader', 'fake_sensor')}
comps, mods = test_composites('fake_sensor')
cl.return_value = (comps, mods)
scene = satpy.scene.Scene(filenames='bla',
base_dir='bli',
reader='fake_reader')
# it is fine that an optional prereq doesn't exist
scene.load(['comp17'])
loaded_ids = list(scene.datasets.keys())
self.assertEquals(len(loaded_ids), 0)
def test_init_with_sensor(self):
import satpy.scene
from satpy.tests.utils import create_fake_reader
with mock.patch('satpy.scene.Scene.create_reader_instances') as cri:
cri.return_value = {
'fake_reader': create_fake_reader('fake_reader', sensor_name='fake_sensor'),
}
scene = satpy.scene.Scene(filenames='bla',
base_dir='bli',
sensor='fake_sensor')
self.assertIsInstance(scene.info['sensor'], set)
scene = satpy.scene.Scene(filenames='bla',
base_dir='bli',
sensor=['fake_sensor'])
self.assertIsInstance(scene.info['sensor'], set)
def test_load_comp13(self, cri, cl):
"""Test loading a composite that depends on a modified dataset where the resolution changes"""
import satpy.scene
from satpy.tests.utils import create_fake_reader, test_composites
from satpy import DatasetID
cri.return_value = {'fake_reader': create_fake_reader('fake_reader', 'fake_sensor')}
comps, mods = test_composites('fake_sensor')
cl.return_value = (comps, mods)
scene = satpy.scene.Scene(filenames='bla',
base_dir='bli',
reader='fake_reader')
# it is fine that an optional prereq doesn't exist
scene.load(['comp13'])
loaded_ids = list(scene.datasets.keys())
self.assertEquals(len(loaded_ids), 1)
self.assertTupleEqual(tuple(loaded_ids[0]), tuple(DatasetID(name='comp13')))
def test_load_comp16(self, cri, cl):
"""Test loading a composite whose opt prereq can't be loaded
Note that the prereq exists in the reader, but fails in loading
"""
import satpy.scene
from satpy.tests.utils import create_fake_reader, test_composites
cri.return_value = {'fake_reader': create_fake_reader('fake_reader', 'fake_sensor')}
comps, mods = test_composites('fake_sensor')
cl.return_value = (comps, mods)
scene = satpy.scene.Scene(filenames='bla',
base_dir='bli',
reader='fake_reader')
# it is fine that an optional prereq doesn't exist
scene.load(['comp16'])
loaded_ids = list(scene.datasets.keys())
self.assertEquals(len(loaded_ids), 1)
self.assertEqual(loaded_ids[0].name, 'comp16')
def test_resample_comp1(self, cri, cl):
"""Test loading and resampling a single dataset"""
import satpy.scene
from satpy.tests.utils import create_fake_reader, test_composites
from satpy import DatasetID, Dataset
cri.return_value = {'fake_reader': create_fake_reader('fake_reader', 'fake_sensor')}
comps, mods = test_composites('fake_sensor')
cl.return_value = (comps, mods)
scene = satpy.scene.Scene(filenames='bla',
base_dir='bli',
reader='fake_reader')
scene.load(['ds1'])
with mock.patch.object(Dataset, 'resample', autospec=True) as r:
r.side_effect = lambda self, x, **kwargs: self
new_scene = scene.resample(None) # None is our fake Area destination
loaded_ids = list(new_scene.datasets.keys())
self.assertEquals(len(loaded_ids), 1)
self.assertTupleEqual(tuple(loaded_ids[0]), tuple(DatasetID(name='ds1')))
def test_load_dataset_after_composite2(self, cri, cl):
"""Test load complex composite followed by other datasets"""
import satpy.scene
from satpy.tests.utils import create_fake_reader, test_composites
from satpy import DatasetID
r = create_fake_reader('fake_reader', 'fake_sensor')
cri.return_value = {'fake_reader': r}
comps, mods = test_composites('fake_sensor')
cl.return_value = (comps, mods)
scene = satpy.scene.Scene(filenames='bla',
base_dir='bli',
reader='fake_reader')
scene.load(['comp10'])
self.assertEqual(r.load.call_count, 1)
loaded_ids = list(scene.datasets.keys())
self.assertEquals(len(loaded_ids), 1)
with mock.patch.object(scene, 'read_composites', wraps=scene.read_composites) as m:
scene.load(['ds1'])
self.assertEqual(r.load.call_count, 2)
loaded_ids = list(scene.datasets.keys())
self.assertEquals(len(loaded_ids), 2)
# this is the unmodified ds1
self.assertIn(DatasetID(name='ds1'), loaded_ids)
# m.assert_called_once_with(set([scene.dep_tree['ds1']]))
m.assert_called_once_with(set())
with mock.patch.object(scene, 'read_composites', wraps=scene.read_composites) as m:
scene.load(['ds1'])
self.assertEqual(r.load.call_count, 2)
loaded_ids = list(scene.datasets.keys())
self.assertEquals(len(loaded_ids), 2)
# this is the unmodified ds1
self.assertIn(DatasetID(name='ds1'), loaded_ids)
m.assert_called_once_with(set())
# we should only compute the composite once
self.assertEqual(comps['fake_sensor'][
'comp10'].side_effect.call_count, 1)
# Create the modded ds1 at comp10, then load the numodified version
# again
self.assertEqual(comps['fake_sensor']['ds1']._call_mock.call_count, 1)
loaded_ids = list(scene.datasets.keys())
self.assertEquals(len(loaded_ids), 2)
def test_load_ds1_load_twice(self, cri):
"""Test loading one dataset with no loaded compositors"""
import satpy.scene
from satpy.tests.utils import create_fake_reader
from satpy import DatasetID
r = create_fake_reader('fake_reader', 'fake_sensor')
cri.return_value = {'fake_reader': r}
scene = satpy.scene.Scene(filenames='bla',
base_dir='bli',
reader='fake_reader')
scene.load(['ds1'])
loaded_ids = list(scene.datasets.keys())
self.assertEquals(len(loaded_ids), 1)
self.assertTupleEqual(tuple(loaded_ids[0]), tuple(DatasetID(name='ds1')))
with mock.patch.object(r, 'load') as m:
scene.load(['ds1'])
loaded_ids = list(scene.datasets.keys())
self.assertEquals(len(loaded_ids), 1)
self.assertTupleEqual(tuple(loaded_ids[0]), tuple(DatasetID(name='ds1')))
self.assertFalse(m.called, "Reader.load was called again when loading something that's already loaded")
def test_load_dataset_after_composite(self, cri, cl):
"""Test load composite followed by other datasets"""
import satpy.scene
from satpy.tests.utils import create_fake_reader, test_composites
r = create_fake_reader('fake_reader', 'fake_sensor')
cri.return_value = {'fake_reader': r}
comps, mods = test_composites('fake_sensor')
cl.return_value = (comps, mods)
scene = satpy.scene.Scene(filenames='bla',
base_dir='bli',
reader='fake_reader')
scene.load(['comp3'])
self.assertEqual(r.load.call_count, 1)
scene.load(['ds1'])
self.assertEqual(r.load.call_count, 2)
scene.load(['ds1'])
# we should only load from the file twice
self.assertEqual(r.load.call_count, 2)
# we should only compute the composite once
self.assertEqual(comps['fake_sensor']['comp3'].side_effect.call_count, 1)
loaded_ids = list(scene.datasets.keys())
self.assertEquals(len(loaded_ids), 2)
def test_load_no_exist2(self, cri, cl):
"""Test loading a dataset that doesn't exist then another load"""
from satpy.tests.utils import create_fake_reader, test_composites
from satpy import DatasetID, Scene
r = create_fake_reader('fake_reader', 'fake_sensor')
cri.return_value = {'fake_reader': r}
comps, mods = test_composites('fake_sensor')
cl.return_value = (comps, mods)
scene = Scene(filenames='bla',
base_dir='bli',
reader='fake_reader')
scene.load(['ds9_fail_load'])
loaded_ids = list(scene.datasets.keys())
self.assertEquals(len(loaded_ids), 0)
r.load.assert_called_once_with(set([DatasetID(name='ds9_fail_load', wavelength=(1.0, 1.1, 1.2))]))
scene.load(['ds1'])
loaded_ids = list(scene.datasets.keys())
self.assertEqual(r.load.call_count, 2)
# most recent call should have only been ds1
r.load.assert_called_with(set([DatasetID(name='ds1')]))
self.assertEquals(len(loaded_ids), 1)
