def test_it(self):
class _FormatterTest1:
def to_dict(self):
return dict()
# Should work
register_json_formatter(_FormatterTest1)
class _FormatterTest2:
def to_dictomat(self):
return dict()
# Should not work
with self.assertRaises(ValueError) as cm:
register_json_formatter(_FormatterTest2)
self.assertTrue(f'{cm.exception}'.endswith(
"FormatterTest2'> must define a to_dict() method"),
msg=f'{cm.exception}')
for property_name, property_schema in self.properties.items():
if property_name in mapping:
property_value = mapping[property_name]
converted_property_value = getattr(property_schema,
method_name)(property_value)
converted_mapping[property_name] = converted_property_value
else:
property_value = property_schema.default
if property_value is not UNDEFINED:
converted_property_value = getattr(
property_schema, method_name)(property_value)
if property_name in required_set or converted_property_value is not None:
converted_mapping[
property_name] = converted_property_value
if self.additional_properties is None or self.additional_properties:
properties_schema = self.additional_properties \
if isinstance(self.additional_properties, JsonSchema) else None
# Note, additional_properties defaults to True
for property_name, property_value in mapping.items():
if property_name not in converted_mapping and property_value is not UNDEFINED:
if properties_schema:
property_value = properties_schema.from_instance(
property_value)
converted_mapping[property_name] = property_value
return converted_mapping
register_json_formatter(JsonSchema)
f'illegal data_type,'
f' must be compatible with {GEO_DATA_FRAME_TYPE!r}')
self.feature_schema = feature_schema
@classmethod
def get_schema(cls) -> JsonObjectSchema:
schema = super().get_schema()
schema.properties.update(
feature_schema=JsonObjectSchema(additional_properties=True), )
schema.required = ['data_id']
schema.additional_properties = False
schema.factory = cls
return schema
register_json_formatter(DataDescriptor)
register_json_formatter(DatasetDescriptor)
register_json_formatter(VariableDescriptor)
register_json_formatter(MultiLevelDatasetDescriptor)
register_json_formatter(GeoDataFrameDescriptor)
#############################################################################
# Implementation helpers
def _build_variable_descriptor_dict(variables) \
-> Mapping[str, 'VariableDescriptor']:
return {
str(var_name): VariableDescriptor(
name=str(var_name),
dtype=str(var.dtype),
getattr(self._component, 'to_dict')):
component = self._component.to_dict()
else:
component = repr(self._component)
else:
component = '<not loaded yet>'
d = dict(
name=self.name,
**self.metadata,
point=self.point,
component=component,
)
return d
register_json_formatter(Extension)
# noinspection PyShadowingBuiltins
class ExtensionRegistry:
"""
A registry of extensions.
Typically used by plugins to register extensions.
"""
def __init__(self):
self._extension_points = {}
def has_extension(self, point: str, name: str) -> bool:
"""
Test if an extension with given *point* and *name* is registered.