def validate(self, element, state):
if (element.raw is Unset or element.raw is None or # perverse case
hasattr(element.raw, 'next')):
return True
try:
set_with = list(to_pairs(element.raw))
except TypeError:
# wasn't iterable
return True
missing, unexpected = _evaluate_dict_strict_policy(element, set_with)
if not missing and not unexpected:
return True
elif missing and unexpected:
message = 'both'
elif missing:
message = 'missing'
else:
message = 'unexpected'
n_miss, miss = len(missing), u', '.join(sorted(missing))
n_unex, unex = len(unexpected), u', '.join(sorted(unexpected))
return self.note_error(element,
state,
message,
n_missing=n_miss,
missing=miss,
n_unexpected=n_unex,
unexpected=unex)
def set(self, value, policy=None):
"""TODO: doc set()"""
self.raw = value
pairs = to_pairs(value)
self._reset()
if policy is not None:
assert policy in ("strict", "subset", "duck")
else:
policy = self.policy
fields = self.field_schema_mapping
seen = set()
converted = True
for key, value in pairs:
if key not in fields:
if policy != "duck":
raise KeyError("Dict %r schema does not allow key %r" % (self.name, key))
continue
if dict.__contains__(self, key):
converted &= self[key].set(value)
else:
self[key] = el = fields[key]()
converted &= el.set(value)
seen.add(key)
if policy == "strict":
required = set(fields.iterkeys())
if seen != required:
missing = required - seen
raise TypeError(
"strict-mode Dict requires all keys for "
"a set() operation, missing %s." % (",".join(repr(key) for key in missing))
)
return converted
def validate(self, element, state):
if (element.raw is Unset or
element.raw is None or # perverse case
hasattr(element.raw, 'next')):
return True
try:
set_with = list(to_pairs(element.raw))
except TypeError:
# wasn't iterable
return True
missing, unexpected = _evaluate_dict_strict_policy(element, set_with)
if not missing and not unexpected:
return True
elif missing and unexpected:
message = 'both'
elif missing:
message = 'missing'
else:
message = 'unexpected'
n_miss, miss = len(missing), u', '.join(sorted(missing))
n_unex, unex = len(unexpected), u', '.join(sorted(unexpected))
return self.note_error(element, state, message,
n_missing=n_miss,
missing=miss,
n_unexpected=n_unex,
unexpected=unex)
def update(self, *dictish, **kwargs):
"""Update with keys from dict-like *\*dictish* and *\*\*kwargs*"""
if len(dictish) > 1:
raise TypeError("update expected at most 1 arguments, got %s" % len(dictish))
elif dictish:
for key, value in to_pairs(dictish[0]):
self[key] = value
for key, value in kwargs.iteritems():
self[key] = value
def update(self, *dictish, **kwargs):
"""Update with keys from dict-like *\*dictish* and *\*\*kwargs*"""
if len(dictish) > 1:
raise TypeError("update expected at most 1 arguments, got %s" %
len(dictish))
elif dictish:
for key, value in to_pairs(dictish[0]):
self[key] = value
for key, value in iteritems(kwargs):
self[key] = value
def update(self, *iterable, **kwargs):
if len(iterable):
if len(iterable) > 1:
raise TypeError("update expected at most 1 arguments, got %s" %
(len(iterable)))
source = to_pairs(iterable[0])
for key, value in source:
self[key] = value
for key, value in kwargs.iteritems():
self[key.decode('ascii')] = value
def update(self, *iterable, **kwargs):
if len(iterable):
if len(iterable) > 1:
raise TypeError(
"update expected at most 1 arguments, got %s" % (
len(iterable)))
source = to_pairs(iterable[0])
for key, value in source:
self[key] = value
for key, value in six.iteritems(kwargs):
self[key] = value
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 validate(self, element, state):
if (element.raw is Unset or
element.raw is None or # perverse case
hasattr(element.raw, 'next')):
return True
try:
set_with = list(to_pairs(element.raw))
except TypeError:
# wasn't iterable
return True
unexpected = _evaluate_dict_subset_policy(element, set_with)
if not unexpected:
return True
n_unex, unex = len(unexpected), u', '.join(sorted(unexpected))
return self.note_error(element, state, 'unexpected',
unexpected=unex,
n_unexpected=n_unex)
def validate(self, element, state):
if (element.raw is Unset or element.raw is None or # perverse case
hasattr(element.raw, 'next')):
return True
try:
set_with = list(to_pairs(element.raw))
except TypeError:
# wasn't iterable
return True
unexpected = _evaluate_dict_subset_policy(element, set_with)
if not unexpected:
return True
n_unex, unex = len(unexpected), u', '.join(sorted(unexpected))
return self.note_error(element,
state,
'unexpected',
unexpected=unex,
n_unexpected=n_unex)
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(self.iterkeys())
if seen != required:
missing = required - seen
raise TypeError(
"all keys required for a set() operation, missing %s." % (",".join(repr(key) for key in missing))
)
return converted
def set(self, value):
"""TODO: doc set()"""
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(self.iterkeys())
if seen != required:
missing = required - seen
raise TypeError(
'all keys required for a set() operation, missing %s.' % (
','.join(repr(key) for key in missing)))
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, value, policy=None):
"""TODO: doc set()"""
pairs = to_pairs(value)
self._reset()
if policy is not None:
assert policy in ('strict', 'subset', 'duck')
else:
policy = self.policy
fields = self.field_schema_mapping
seen = set()
converted = True
for key, value in pairs:
if key not in fields:
if policy != 'duck':
raise KeyError(
'Dict %r schema does not allow key %r' % (
self.name, key))
continue
if dict.__contains__(self, key):
converted &= self[key].set(value)
else:
self[key] = el = fields[key]()
converted &= el.set(value)
seen.add(key)
if policy == 'strict':
required = set(fields.iterkeys())
if seen != required:
missing = required - seen
raise TypeError(
'strict-mode Dict requires all keys for '
'a set() operation, missing %s.' % (
','.join(repr(key) for key in missing)))
return converted
def set_by_object(self, obj, include=None, omit=None, rename=None):
"""Set fields with an object's attributes.
:param obj: any object
:param include: optional, an iterable of attribute names to pull from
*obj*, if present on the object. Only these attributes will be
included.
:param omit: optional, an iterable of attribute names to ignore on
**obj**. All other attributes matching a named field on the Form
will be included.
:param rename: optional, a mapping of attribute-to-field name
transformations. Attributes specified in the mapping will be
included regardless of *include* or *omit*.
*include* and *omit* are mutually exclusive.
Sets fields on *self*, using as many attributes as possible from
*obj*. Object attributes that do not correspond to field names are
ignored.
Mapping instances have two corresponding methods useful for
round-tripping values in and out of your domain objects.
.. testsetup::
# FIXME
from flatland import Form, String
class UserForm(Form):
login = String
password = String
verify_password = String
class User(object):
def __init__(self, login=None, password=None):
self.login = login
self.password = password
:meth:`update_object` performs the inverse of :meth:`set_object`, and
:meth:`slice` is useful for constructing new objects.
.. doctest::
>>> user = User('biff', 'secret')
>>> form = UserForm()
>>> form.set_by_object(user)
>>> form['login'].value
u'biff'
>>> form['password'] = u'new-password'
>>> form.update_object(user, omit=['verify_password'])
>>> user.password
u'new-password'
>>> user_keywords = form.slice(omit=['verify_password'], key=str)
>>> sorted(user_keywords.keys())
['login', 'password']
>>> new_user = User(**user_keywords)
"""
fields = set(self.iterkeys())
attributes = fields.copy()
if rename:
rename = list(to_pairs(rename))
attributes.update(key for key, value in rename if value in attributes)
if omit:
omit = list(omit)
attributes.difference_update(omit)
possible = ((attr, getattr(obj, attr)) for attr in attributes if hasattr(obj, attr))
sliced = keyslice_pairs(possible, include=include, omit=omit, rename=rename)
final = dict((key, value) for key, value in sliced if key in fields)
self.set(final)
def set_by_object(self, obj, include=None, omit=None, rename=None):
"""Set fields with an object's attributes.
:param obj: any object
:param include: optional, an iterable of attribute names to pull from
*obj*, if present on the object. Only these attributes will be
included.
:param omit: optional, an iterable of attribute names to ignore on
**obj**. All other attributes matching a named field on the
mapping will be included.
:param rename: optional, a mapping of attribute-to-field name
transformations. Attributes specified in the mapping will be
included regardless of *include* or *omit*.
*include* and *omit* are mutually exclusive.
Sets fields on *self*, using as many attributes as possible from
*obj*. Object attributes that do not correspond to field names are
ignored.
Mapping instances have two corresponding methods useful for
round-tripping values in and out of your domain objects.
.. testsetup::
# FIXME
from flatland import Schema, String
class UserForm(Schema):
login = String
password = String
verify_password = String
class User(object):
def __init__(self, login=None, password=None):
self.login = login
self.password = password
:meth:`update_object` performs the inverse of :meth:`set_object`, and
:meth:`slice` is useful for constructing new objects.
.. doctest::
>>> user = User('biff', 'secret')
>>> form = UserForm()
>>> form.set_by_object(user)
>>> form['login'].value
u'biff'
>>> form['password'] = u'new-password'
>>> form.update_object(user, omit=['verify_password'])
>>> user.password
u'new-password'
>>> user_keywords = form.slice(omit=['verify_password'], key=str)
>>> sorted(user_keywords.keys())
['login', 'password']
>>> new_user = User(**user_keywords)
"""
fields = set(iterkeys(self))
attributes = fields.copy()
if rename:
rename = list(to_pairs(rename))
attributes.update(key for key, value in rename
if value in attributes)
if omit:
omit = list(omit)
attributes.difference_update(omit)
possible = ((attr, getattr(obj, attr)) for attr in sorted(attributes)
if hasattr(obj, attr))
sliced = keyslice_pairs(possible,
include=include,
omit=omit,
rename=rename)
final = dict((key, value) for key, value in sliced if key in fields)
self.set(final)