def __repr__(self):
return ('\n'.join(
['%s(' % qualified_name(type(self))] +
[
' %s=%s,' % (p, repr(v))
for p, v in properties_values(self)
] +
[')']
))
def __deepcopy__(self, memo=None):
# type: (dict) -> Memo
new_instance = self.__class__()
# for a in dir(self):
# if a[0] != '_':
# v = getattr(self, a)
# if (v is not None) and (
# (a in ('types', 'required')) or
# (not isinstance(v, Callable))
# ):
for a, v in properties_values(self):
setattr(new_instance, a, deepcopy(v, memo=memo))
return new_instance
def __repr__(self):
representation = [qualified_name(type(self)) + '(']
pd = parameters_defaults(self.__init__)
for p, v in properties_values(self):
if (p not in pd) or pd[p] == v:
continue
if (v is not None) and (v is not NULL):
if isinstance(v, Sequence) and not isinstance(v, (str, bytes)):
rvs = ['(']
for i in v:
ri = (
qualified_name(i)
if isinstance(i, type) else
"'%s'" % str(i)
if isinstance(i, serial.meta.Version) else
repr(i)
)
rils = ri.split('\n')
if len(rils) > 1:
ris = [rils[0]]
for ril in rils[1:]:
ris.append(' ' + ril)
ri = '\n'.join(ris)
rvs.append(' %s,' % ri)
if len(v) > 1:
rvs[-1] = rvs[-1][:-1]
rvs.append(' )')
rv = '\n'.join(rvs)
else:
rv = (
qualified_name(v)
if isinstance(v, type) else
"'%s'" % str(v)
if isinstance(v, serial.meta.Version) else
repr(v)
)
rvls = rv.split('\n')
if len(rvls) > 2:
rvs = [rvls[0]]
for rvl in rvls[1:]:
rvs.append(' ' + rvl)
rv = '\n'.join(rvs)
representation.append(
' %s=%s,' % (p, rv)
)
representation.append(')')
if len(representation) > 2:
return '\n'.join(representation)
else:
return ''.join(representation)
def __deepcopy__(self, memo=None):
# type: (dict) -> Memo
new_instance = self.__class__()
for a, v in properties_values(self):
setattr(new_instance, a, deepcopy(v, memo=memo))
return new_instance
def unmarshal(data, types=None, value_types=None, item_types=None):
# type: (Any, Optional[typing.Sequence[Union[type, serial.properties.Property]]], Optional[bool]) -> typing.Any
"""
Convert ``data`` into ``serial.model`` representations of same.
"""
if (data is None) or (data is serial.properties.NULL):
return data
if isinstance(types, Callable):
types = types(data)
if isinstance(data, Generator):
data = tuple(data)
if types is None:
if isinstance(
data,
(dict, OrderedDict)) and not isinstance(data, Dictionary):
data = Dictionary(data, value_types=value_types)
elif isinstance(data, (Set, Sequence)) and (not isinstance(
data, (str, bytes, native_str, Array))):
data = Array(data, item_types=item_types)
return data
elif (str in types) and (native_str is not str) and (native_str
not in types):
types = tuple(
chain(*(((t, native_str) if (t is str) else (t, ))
for t in types)))
matched = False
error = None
if isinstance(data, Model):
metadata = serial.meta.read(data)
else:
metadata = None
for t in types:
if isinstance(t, serial.properties.Property):
try:
data = t.unmarshal(data)
matched = True
break
except (AttributeError, KeyError, TypeError, ValueError) as e:
error = e
continue
elif isinstance(t, type):
if issubclass(t, Object) and isinstance(data, (dict, OrderedDict)):
try:
data = t(data)
matched = True
break
except (AttributeError, KeyError, TypeError, ValueError) as e:
error = e
pass
elif isinstance(data,
(dict, OrderedDict, Dictionary)) and issubclass(
t, (dict, OrderedDict, Dictionary)):
if issubclass(t, Dictionary):
data = t(data, value_types=value_types)
else:
data = Dictionary(data, value_types=value_types)
matched = True
break
elif (isinstance(data, (Set, Sequence, Generator))
and (not isinstance(data, (str, bytes, native_str)))
and issubclass(t, (Set, Sequence))
and (not issubclass(t, (str, bytes, native_str)))):
if issubclass(t, Array):
data = t(data, item_types=item_types)
else:
data = Array(data, item_types=item_types)
matched = True
break
elif isinstance(data, t):
matched = True
break
if not matched:
if not matched:
if len(types) == 1 and (error is not None):
raise error
else:
raise TypeError(
'\n The data provided does not fit any of the types indicated:\n'
+ ' - data: %s\n' % repr(data) +
' - types: %s' % repr(types))
if metadata is not None:
new_metadata = serial.meta.read(data)
if new_metadata is not None:
if metadata is not new_metadata:
writable = False
for a, v in properties_values(metadata):
try:
if getattr(new_metadata, a) != v:
if not writable:
new_metadata = serial.meta.writable(data)
setattr(new_metadata, a, v)
except AttributeError:
pass
return data