def _predicate(extension: Extension) -> bool:
extension_parts = extension.name.split(':', maxsplit=4)
if len(extension_parts) < 3:
raise DataStoreError(
f'Illegal data opener/writer extension name "{extension.name}"'
)
extension_type = TypeSpecifier.parse(extension_parts[0])
type_ok = type_specifier is None or extension_type == TYPE_SPECIFIER_ANY or \
extension_type == TypeSpecifier.normalize(type_specifier)
format_ok = format_id is None or extension_parts[
1] == '*' or extension_parts[1] == format_id
storage_ok = storage_id is None or extension_parts[
2] == '*' or extension_parts[2] == storage_id
return type_ok and format_ok and storage_ok
def test_equality_any(self):
type_specifier = TypeSpecifier(name='*')
self.assertFalse(type_specifier == TypeSpecifier('geodataframe'))
self.assertFalse(
type_specifier == TypeSpecifier('geodataframe', flags={'cube'}))
self.assertFalse(type_specifier == TypeSpecifier('dataset'))
self.assertFalse(
type_specifier == TypeSpecifier('dataset', flags={'multilevel'}))
self.assertFalse(type_specifier == TypeSpecifier(
'dataset', flags={'multilevel', 'cube'}))
self.assertFalse(
type_specifier == TypeSpecifier('dataset', flags={'cube'}))
self.assertTrue(type_specifier == TypeSpecifier('*'))
def test_it_satisfies_with_flags(self):
type_specifier = TypeSpecifier(name='dataset', flags={'cube'})
self._assert_it_not_satisfies(type_specifier,
TypeSpecifier('geodataframe'))
self._assert_it_not_satisfies(
type_specifier, TypeSpecifier('geodataframe', flags={'cube'}))
self._assert_it_not_satisfies(
type_specifier, TypeSpecifier('dataset', flags={'multilevel'}))
self._assert_it_not_satisfies(
type_specifier,
TypeSpecifier('dataset', flags={'multilevel', 'cube'}))
self._assert_it_satisfies(type_specifier, TypeSpecifier('dataset'))
self._assert_it_satisfies(type_specifier,
TypeSpecifier('dataset', flags={'cube'}))
self._assert_it_satisfies(type_specifier, TypeSpecifier('*'))
def test_it_satisfies_as_any(self):
type_specifier = TypeSpecifier(name='*')
self._assert_it_satisfies(type_specifier,
TypeSpecifier('geodataframe'))
self._assert_it_satisfies(
type_specifier, TypeSpecifier('geodataframe', flags={'cube'}))
self._assert_it_satisfies(type_specifier, TypeSpecifier('dataset'))
self._assert_it_satisfies(type_specifier,
TypeSpecifier('dataset', flags={'cube'}))
self._assert_it_satisfies(type_specifier, TypeSpecifier('*'))
def test_normalize(self):
dataset_flagged_specifier = TypeSpecifier(name='dataset',
flags={'cube'})
self.assertEqual(TypeSpecifier.normalize(dataset_flagged_specifier),
dataset_flagged_specifier)
self.assertEqual(TypeSpecifier.normalize('dataset[cube]'),
dataset_flagged_specifier)
dataset_specifier = TypeSpecifier(name='dataset')
self.assertEqual(TypeSpecifier.normalize(dataset_specifier),
dataset_specifier)
self.assertEqual(TypeSpecifier.normalize('dataset'), dataset_specifier)
def __init__(self,
data_id: str,
type_specifier: Union[str, TypeSpecifier],
crs: str = None,
bbox: Tuple[float, float, float, float] = None,
spatial_res: float = None,
time_range: Tuple[Optional[str], Optional[str]] = None,
time_period: str = None,
open_params_schema: JsonObjectSchema = None):
assert_given(data_id, 'data_id')
self._assert_valid_type_specifier(type_specifier)
self.data_id = data_id
self.type_specifier = TypeSpecifier.normalize(type_specifier)
self.crs = crs
self.bbox = tuple(bbox) if bbox else None
self.spatial_res = spatial_res
self.time_range = tuple(time_range) if time_range else None
self.time_period = time_period
self.open_params_schema = open_params_schema
def test_to_dict(self):
var_descriptors = [
VariableDescriptor(name='xf',
dtype='rj',
dims=('dfjhrt', 'sg'),
attrs=dict(ssd=4, zjgrhgu='dgfrf'))
]
descriptor = DatasetDescriptor(data_id='xyz',
type_specifier=TypeSpecifier(
'dataset', flags={'cube'}),
crs='EPSG:9346',
bbox=(10., 20., 30., 40.),
spatial_res=20.,
time_range=('2017-06-05', '2017-06-27'),
time_period='daily',
dims=dict(x=1, y=2, z=3),
data_vars=var_descriptors,
attrs=dict(dzus=236,
tgr7h='rt5',
df='s8fd4w5'))
descriptor_dict = descriptor.to_dict()
self.assertEqual(
dict(data_id='xyz',
type_specifier='dataset[cube]',
crs='EPSG:9346',
bbox=(10., 20., 30., 40.),
spatial_res=20.,
time_range=('2017-06-05', '2017-06-27'),
time_period='daily',
dims=dict(x=1, y=2, z=3),
data_vars=[
dict(name='xf',
dtype='rj',
dims=('dfjhrt', 'sg'),
ndim=2,
attrs=dict(ssd=4, zjgrhgu='dgfrf'))
],
attrs=dict(dzus=236, tgr7h='rt5', df='s8fd4w5')),
descriptor_dict)
def test_name_and_flags(self):
type_specifier = TypeSpecifier(name='dataset',
flags={'cube', 'multilevel'})
self.assertEqual('dataset', type_specifier.name)
self.assertEqual({'cube', 'multilevel'}, type_specifier.flags)
def test_parse_exception(self):
with self.assertRaises(SyntaxError) as cm:
TypeSpecifier.parse('An unparseable expression[')
self.assertEqual(
'"An unparseable expression[" cannot be parsed: No end brackets found',
f'{cm.exception}')
def test_parse(self):
self.assertEqual(TypeSpecifier('*'), TypeSpecifier.parse('*'))
self.assertEqual(TypeSpecifier('dataset'),
TypeSpecifier.parse('dataset'))
self.assertEqual(TypeSpecifier('dataset', {'cube', 'multilevel'}),
TypeSpecifier.parse('dataset[cube,multilevel]'))
def test_it_satisfies_without_flags(self):
type_specifier = TypeSpecifier(name='dataset')
self._assert_it_not_satisfies(type_specifier,
TypeSpecifier('dataset', flags={'cube'}))
self._assert_it_satisfies(type_specifier, TypeSpecifier('dataset'))
self._assert_it_satisfies(type_specifier, TypeSpecifier('*'))
def test_name(self):
type_specifier = TypeSpecifier(name='dataset')
self.assertEqual('dataset', type_specifier.name)
self.assertEqual(set(), type_specifier.flags)
def test_any(self):
type_specifier = TypeSpecifier(name='*')
self.assertEqual('*', type_specifier.name)
def test_equality_flag_order_is_irrelevant(self):
type_specifier_1 = TypeSpecifier(name='dataset',
flags={'cube', 'multilevel'})
type_specifier_2 = TypeSpecifier(name='dataset',
flags={'multilevel', 'cube'})
self.assertTrue(type_specifier_1 == type_specifier_2)
def test_string(self):
type_specifier = TypeSpecifier(name='dataset',
flags={'cube', 'multilevel'})
self.assertEqual(str(type_specifier), 'dataset[cube,multilevel]')
def _assert_it_not_satisfies(self, a: TypeSpecifier, b: TypeSpecifier):
self.assertFalse(a.satisfies(b),
f'"{a}" did unexpectedly satisfy "{b}"')
self.assertFalse(b.is_satisfied_by(a),
f'"{b}" is unexpectedly satisfied by "{a}"')
def test_any_and_flags(self):
with self.assertRaises(ValueError) as cm:
TypeSpecifier(name='*', flags={'cube'})
self.assertEqual('flags are not allowed if name is "*" (any)',
f'{cm.exception}')
