def __init__(self, **kwargs):
if ('format_str' in kwargs):
drv = tools.get_subprocess_language_driver()
if drv.decode_format is not None:
kwargs['format_str'] = drv.decode_format(kwargs['format_str'])
if isinstance(kwargs.get('datatype', None), MetaschemaType):
self.datatype = kwargs.pop('datatype')
super(SerializeBase, self).__init__(**kwargs)
kwargs = self.extra_kwargs
self.extra_kwargs = {}
# Set defaults
if self.datatype is None:
self.datatype = self.default_datatype
elif ((isinstance(self.datatype, dict)
and (self.datatype != self.default_datatype))):
kwargs['datatype'] = self.datatype
# Update typedef
self.initialized = False
if isinstance(self.datatype, dict):
self.datatype = get_type_from_def(self.default_datatype,
dont_complete=True)
if getattr(self, 'encoded_datatype', None) is None:
self.encoded_datatype = self.default_encoded_datatype
if isinstance(self.encoded_datatype, dict):
self.encoded_datatype = get_type_from_def(self.encoded_datatype,
dont_complete=True)
self.update_serializer(**kwargs)
self.initialized = self.is_initialized()
def test_get_type_from_def():
r"""Test get_type_from_def."""
datatypes.get_type_from_def('float')
datatypes.get_type_from_def({'type': 'float'})
datatypes.get_type_from_def({'a': 'float', 'b': 'int'})
datatypes.get_type_from_def(['float', 'int'])
with pytest.raises(TypeError):
datatypes.get_type_from_def(None)
def test_get_type_from_def():
r"""Test get_type_from_def."""
datatypes.get_type_from_def('float')
datatypes.get_type_from_def({'type': 'float'})
datatypes.get_type_from_def({'a': 'float', 'b': 'int'})
datatypes.get_type_from_def(['float', 'int'])
assert_raises(TypeError, datatypes.get_type_from_def, None)
def __init__(self,
func_serialize=None,
func_deserialize=None,
encode_func_serialize=None,
decode_func_deserialize=None,
func_typedef=None,
**kwargs):
super(DefaultSerialize, self).__init__()
self._alias = None
self.is_user_defined = False
self.extra_kwargs = {}
# Set user defined serialization/deserialization functions
if func_serialize is not None:
assert (not hasattr(self, 'func_serialize'))
if issubclass(func_serialize.__class__, DefaultSerialize):
self.func_serialize = func_serialize.func_serialize
else:
self.func_serialize = func_serialize
self.is_user_defined = True
if func_deserialize is not None:
assert (not hasattr(self, 'func_deserialize'))
if issubclass(func_deserialize.__class__, DefaultSerialize):
self.func_deserialize = func_deserialize.func_deserialize
else:
self.func_deserialize = func_deserialize
self.is_user_defined = True
if encode_func_serialize is not None:
self.encode_func_serialize = encode_func_serialize
if decode_func_deserialize is not None:
self.decode_func_deserialize = decode_func_deserialize
if func_typedef is not None:
self.func_typedef = func_typedef
# Set properties to None
for k, v in self._schema_properties.items():
setattr(self, k, v.get('default', None))
# Update typedef
self._initialized = False
self.datatype = get_type_from_def(self._default_type,
dont_complete=True)
self.func_datatype = get_type_from_def(self.func_typedef,
dont_complete=True)
self.update_serializer(**kwargs)
self._initialized = (self.typedef != self._default_type)
def update_serializer(self, extract=False, skip_type=False, **kwargs):
r"""Update serializer with provided information.
Args:
extract (bool, optional): If True, the updated typedef will be
the bare minimum as extracted from total set of provided
keywords, otherwise the entire set will be sued. Defaults to
False.
skip_type (bool, optional): If True, everything is updated except
the data type. Defaults to False.
**kwargs: Additional keyword arguments are processed as part of
they type definition and are parsed for old-style keywords.
Raises:
RuntimeError: If there are keywords that are not valid typedef
keywords (currect or old-style).
"""
old_datatype = None
if self.initialized:
old_datatype = copy.deepcopy(self.datatype)
_metaschema = get_metaschema()
# Raise an error if the types are not compatible
seritype = kwargs.pop('seritype', self.seritype)
if (seritype != self._seritype) and (seritype !=
'default'): # pragma: debug
raise Exception("Cannot change types form %s to %s." %
(self._seritype, seritype))
# Remove metadata keywords unrelated to serialization
# TODO: Find a better way of tracking these
_remove_kws = [
'body', 'address', 'size', 'id', 'incomplete', 'raw', 'commtype',
'filetype', 'response_address', 'request_id', 'append', 'in_temp',
'is_series', 'working_dir', 'fmts', 'model_driver', 'env',
'send_converter', 'recv_converter', 'typedef_base'
]
kws = list(kwargs.keys())
for k in kws:
if (k in _remove_kws) or k.startswith('zmq'):
kwargs.pop(k)
# Set attributes and remove unused metadata keys
for k in self._schema_properties.keys():
if (k in kwargs) and (k != 'datatype'):
setattr(self, k, kwargs.pop(k))
# Create preliminary typedef
typedef = kwargs.pop('datatype', {})
for k in _metaschema['properties'].keys():
if k in kwargs:
typedef[k] = kwargs.pop(k)
# Update extra keywords
if (len(kwargs) > 0):
self.extra_kwargs.update(kwargs)
self.debug("Extra kwargs: %s" % str(self.extra_kwargs))
# Update type
if not skip_type:
# Update typedef from oldstyle keywords in extra_kwargs
typedef = self.update_typedef_from_oldstyle(typedef)
if typedef.get('type', None):
if extract:
cls = get_type_class(typedef['type'])
typedef = cls.extract_typedef(typedef)
self.datatype = get_type_from_def(typedef)
# Check to see if new datatype is compatible with new one
if old_datatype is not None:
errors = list(
compare_schema(self.typedef, old_datatype._typedef) or ())
if errors:
raise RuntimeError((
"Updated datatype is not compatible with the existing one."
+ " New:\n%s\nOld:\n%s\n") %
(pprint.pformat(self.typedef),
pprint.pformat(old_datatype._typedef)))
# Enfore that strings used with messages are in bytes
for k in self._attr_conv:
v = getattr(self, k, None)
if isinstance(v, (str, bytes)):
setattr(self, k, tools.str2bytes(v))