def set(self, value):
self.raw = value
if isinstance(value, (list, tuple)):
values = value
elif not isinstance(value, text_type):
values = list(value)
elif self.separator_regex:
# a text regexp separator
values = self.separator_regex.split(value)
else:
# a text static separator
values = value.split(self.separator)
del self[:]
prune = self.prune_empty
success = []
for value in values:
if prune and not value:
continue
child = self.member_schema()
success.append(child.set(value))
self.append(child)
res = all(success)
element_set.send(self, adapted=res)
return res
def set(self, value):
self.raw = value
if isinstance(value, (list, tuple)):
values = value
elif not isinstance(value, string_types):
values = list(value)
elif self.separator_regex:
# a text regexp separator
values = self.separator_regex.split(value)
else:
# a text static separator
values = value.split(self.separator)
del self[:]
prune = self.prune_empty
success = []
for value in values:
if prune and not value:
continue
child = self.member_schema()
success.append(child.set(value))
self.append(child)
res = all(success)
element_set.send(self, adapted=res)
return res
def set(self, value, policy=None):
self.raw = value
pairs = list(to_pairs(value))
self._reset()
if policy is None:
policy = self.policy
if policy not in ('strict', 'subset', 'duck', None):
raise RuntimeError("Unknown %s policy %r" % (
self.__class__.__name__, policy))
if policy == 'strict':
missing, extra = _evaluate_dict_strict_policy(self, pairs)
if missing and extra:
raise KeyError(
'Strict %s %r schema does not allow keys %r and '
'requires keys %r' % (
self.__class__.__name__, self.name,
list(extra), list(missing)))
elif missing:
# match previous logic's exception type here
raise TypeError(
'Strict %s %r schema requires keys %r' % (
self.__class__.__name__, self.name,
list(missing)))
elif extra:
raise KeyError(
'Strict %s %r schema does not allow keys %r' % (
self.__class__.__name__, self.name,
list(extra)))
elif policy == 'subset':
mismatch = _evaluate_dict_subset_policy(self, pairs)
if mismatch:
raise KeyError(
'Subset %s %r schema does not allow keys %r' % (
self.__class__.__name__, self.name,
list(mismatch)))
fields = self.field_schema_mapping
converted = True
for key, value in pairs:
if PY2 and isinstance(key, bytestring_type):
key = key.decode('ascii', 'replace')
if key not in fields:
continue
if dict.__contains__(self, key):
converted &= self[key].set(value)
else:
self[key] = el = fields[key]()
converted &= el.set(value)
element_set.send(self, adapted=converted)
return converted
def set(self, value, policy=None):
self.raw = value
pairs = list(to_pairs(value))
self._reset()
if policy is None:
policy = self.policy
if policy not in ('strict', 'subset', 'duck', None):
raise RuntimeError("Unknown %s policy %r" %
(self.__class__.__name__, policy))
if policy == 'strict':
missing, extra = _evaluate_dict_strict_policy(self, pairs)
if missing and extra:
raise KeyError(
'Strict %s %r schema does not allow keys %r and '
'requires keys %r' % (self.__class__.__name__, self.name,
list(extra), list(missing)))
elif missing:
# match previous logic's exception type here
raise TypeError(
'Strict %s %r schema requires keys %r' %
(self.__class__.__name__, self.name, list(missing)))
elif extra:
raise KeyError(
'Strict %s %r schema does not allow keys %r' %
(self.__class__.__name__, self.name, list(extra)))
elif policy == 'subset':
mismatch = _evaluate_dict_subset_policy(self, pairs)
if mismatch:
raise KeyError(
'Subset %s %r schema does not allow keys %r' %
(self.__class__.__name__, self.name, list(mismatch)))
fields = self.field_schema_mapping
converted = True
for key, value in pairs:
if PY2 and isinstance(key, bytestring_type):
key = key.decode('ascii', 'replace')
if key not in fields:
continue
if dict.__contains__(self, key):
converted &= self[key].set(value)
else:
self[key] = el = fields[key]()
converted &= el.set(value)
element_set.send(self, adapted=converted)
return converted
def set(self, value):
self.raw = value
try:
res = self.explode(value)
# TODO: historically explode() did not need to have a return value
# but it would be nice to return it form set() as below.
res = True if res is None else res # compat
element_set.send(self, adapted=res)
return res
except (SystemExit, KeyboardInterrupt, NotImplementedError):
raise
except Exception:
# not wild about quashing here, but set() doesn't allow
# adaptation exceptions to bubble up.
element_set.send(self, adapted=False)
return False
def set(self, value):
self.raw = value
try:
res = self.explode(value)
# TODO: historically explode() did not need to have a return value
# but it would be nice to return it form set() as below.
res = True if res is None else res # compat
element_set.send(self, adapted=res)
return res
except (SystemExit, KeyboardInterrupt, NotImplementedError):
raise
except Exception:
# not wild about quashing here, but set() doesn't allow
# adaptation exceptions to bubble up.
element_set.send(self, adapted=False)
return False
def set(self, obj):
"""Process *obj* and assign the native and text values.
:returns: True if adaptation of *obj* was successful.
Attempts to adapt the given object and assigns this element's
:attr:`~flatland.Element.value` and :attr:`u`
attributes in tandem.
If adaptation succeeds, ``.value`` will contain the
:meth:`adapted<adapt>` native Python value and ``.u`` will contain a
text :meth:`serialized<serialize>` version of it. A native value
of ``None`` will be represented as ``u''`` in ``.u``.
If adaptation fails, ``.value`` will be ``None`` and ``.u`` will
contain ``str(obj)`` (or unicode), or ``u''`` for none.
"""
self.raw = obj
try:
# adapt and normalize the value, if possible
obj = self.value = self.adapt(obj)
except AdaptationError:
self.value = None # could not be adapted
# but, still try to textify it
if obj is None:
self.u = u''
elif isinstance(obj, text_type):
self.u = obj
else:
try:
self.u = text_transform(obj)
except TypeError:
self.u = u''
except UnicodeDecodeError:
self.u = text_type(obj, errors='replace')
element_set.send(self, adapted=False)
return False
# stringify it, possibly storing what we received verbatim or a
# normalized version of it.
if obj is None:
self.u = u''
else:
self.u = self.serialize(obj)
element_set.send(self, adapted=True)
return True
def set(self, obj):
"""Process *obj* and assign the native and text values.
:returns: True if adaptation of *obj* was successful.
Attempts to adapt the given object and assigns this element's
:attr:`~flatland.Element.value` and :attr:`u`
attributes in tandem.
If adaptation succeeds, ``.value`` will contain the
:meth:`adapted<adapt>` native Python value and ``.u`` will contain a
text :meth:`serialized<serialize>` version of it. A native value
of ``None`` will be represented as ``u''`` in ``.u``.
If adaptation fails, ``.value`` will be ``None`` and ``.u`` will
contain ``str(obj)`` (or unicode), or ``u''`` for none.
"""
self.raw = obj
try:
# adapt and normalize the value, if possible
obj = self.value = self.adapt(obj)
except AdaptationError:
self.value = None # could not be adapted
# but, still try to textify it
if obj is None:
self.u = u''
elif isinstance(obj, text_type):
self.u = obj
else:
try:
self.u = text_transform(obj)
except TypeError:
self.u = u''
except UnicodeDecodeError:
self.u = text_type(obj, errors='replace')
element_set.send(self, adapted=False)
return False
# stringify it, possibly storing what we received verbatim or a
# normalized version of it.
if obj is None:
self.u = u''
else:
self.u = self.serialize(obj)
element_set.send(self, adapted=True)
return True
def set(self, value):
""".. TODO:: doc set()"""
self.raw = value
pairs = to_pairs(value)
self._reset()
seen = set()
converted = True
for key, value in pairs:
if not self.may_contain(key):
raise KeyError('%s %r schema does not allow key %r' %
(type(self).__name__, self.name, key))
converted &= self[key].set(value)
seen.add(key)
required = set(iterkeys(self))
if seen != required:
missing = required - seen
raise TypeError(
'all keys required for a set() operation, missing %s.' %
(','.join(repr(key) for key in missing)))
element_set.send(self, adapted=converted)
return converted
def set(self, value):
""".. TODO:: doc set()"""
self.raw = value
pairs = to_pairs(value)
self._reset()
seen = set()
converted = True
for key, value in pairs:
if not self.may_contain(key):
raise KeyError(
'%s %r schema does not allow key %r' % (
type(self).__name__, self.name, key))
converted &= self[key].set(value)
seen.add(key)
required = set(iterkeys(self))
if seen != required:
missing = required - seen
raise TypeError(
'all keys required for a set() operation, missing %s.' % (
','.join(repr(key) for key in missing)))
element_set.send(self, adapted=converted)
return converted
def set(self, iterable):
"""Assign the native and Unicode value.
Attempts to adapt the given *iterable* and assigns this element's
:attr:`value` and :attr:`u` attributes in tandem. Returns True if the
adaptation was successful. See
:meth:`Element.set()<flatland.schema.base.Element.set>`.
Set must be supplied a Python sequence or iterable:
.. doctest::
>>> from flatland import Integer, List
>>> Numbers = List.of(Integer)
>>> nums = Numbers()
>>> nums.set([1, 2, 3, 4])
True
>>> nums.value
[1, 2, 3, 4]
"""
del self[:]
self.raw = iterable
values, converted = [], True
try:
for v in iterable:
el = self.member_schema()
converted &= el.set(v)
values.append(el)
self.extend(values)
except TypeError:
element_set.send(self, adapted=False)
return False
else:
element_set.send(self, adapted=converted)
return converted
def set(self, iterable):
"""Assign the native and Unicode value.
Attempts to adapt the given *iterable* and assigns this element's
:attr:`value` and :attr:`u` attributes in tandem. Returns True if the
adaptation was successful. See
:meth:`Element.set()<flatland.schema.base.Element.set>`.
Set must be supplied a Python sequence or iterable:
.. doctest::
>>> from flatland import Integer, List
>>> Numbers = List.of(Integer)
>>> nums = Numbers()
>>> nums.set([1, 2, 3, 4])
True
>>> nums.value
[1, 2, 3, 4]
"""
del self[:]
self.raw = iterable
values, converted = [], True
try:
for v in iterable:
el = self.member_schema()
converted &= el.set(v)
values.append(el)
self.extend(values)
except TypeError:
element_set.send(self, adapted=False)
return False
else:
element_set.send(self, adapted=converted)
return converted