def toUnicode(self, value):
if isinstance(value, FlowSubmissionData):
return json.dumps(dict(value))
elif IContextAwareDefaultFactory.providedBy(value):
return dottedname(value)
elif IDefaultFactory.providedBy(value):
return dottedname(value)
raise NotImplementedError()
def getDefaultValue(self, form):
if self.defaultValue is NO_VALUE:
if self.defaultFactory is not None:
if IContextAwareDefaultFactory.providedBy(self.defaultFactory):
return self.defaultFactory(form)
return self.defaultFactory()
elif callable(self.defaultValue):
return self.defaultValue(form)
return self.defaultValue
def _default_from_schema(context, schema, fieldname):
"""helper to lookup default value of a field
"""
if schema is None:
return _marker
field = schema.get(fieldname, None)
if field is None:
return _marker
if IContextAwareDefaultFactory.providedBy(
getattr(field, 'defaultFactory', None)):
bound = field.bind(context)
return deepcopy(bound.default)
else:
return deepcopy(field.default)
def _default_from_schema(context, schema, fieldname):
"""helper to lookup default value of a field
"""
if schema is None:
return _marker
field = schema.get(fieldname, None)
if field is None:
return _marker
if IContextAwareDefaultFactory.providedBy(
getattr(field, 'defaultFactory', None)
):
bound = field.bind(context)
return deepcopy(bound.default)
else:
return deepcopy(field.default)
def _default_from_schema(context, schema, fieldname):
"""helper to lookup default value of a field
"""
if schema is None:
return _marker
field = schema.get(fieldname, None)
if field is None:
return _marker
default_factory = getattr(field, 'defaultFactory', None)
if (
# check for None to avoid one expensive providedBy (called often)
default_factory is not None
and IContextAwareDefaultFactory.providedBy(default_factory)):
return deepcopy(field.bind(context).default)
return deepcopy(field.default)
def patched_default_from_schema(context, schema, fieldname):
"""helper to lookup default value of a field
"""
if schema is None:
return _marker
field = schema.get(fieldname, None)
if field is None:
return _marker
# logger.info(fieldname)
# logger.info(schema)
# logger.info(field)
# import pdb; pdb.set_trace()
if IContextAwareDefaultFactory.providedBy(
getattr(field, 'defaultFactory', None)):
bound = field.bind(context)
schnupsi = bound
else:
schnupsi = field
if IRelationChoice.providedBy(schnupsi):
return schnupsi.default
else:
return deepcopy(schnupsi.default)
return _marker
def read(self, element):
"""Read a field from the element and return a new instance
"""
attributes = {}
deferred = {}
deferred_nonvalidated = {}
for attribute_element in element.iterchildren(tag=etree.Element):
parseinfo.stack.append(attribute_element)
attribute_name = noNS(attribute_element.tag)
if 'r' in self.filteredAttributes.get(attribute_name, ''):
continue
attributeField = self.fieldAttributes.get(attribute_name, None)
if attributeField is not None:
if attribute_name in self.fieldTypeAttributes:
deferred[attribute_name] = attribute_element
elif attribute_name in self.nonValidatedfieldTypeAttributes:
deferred_nonvalidated[attribute_name] = attribute_element
elif attribute_name in self.fieldInstanceAttributes:
attributeField_type = attribute_element.get('type')
handler = queryUtility(IFieldExportImportHandler, name=attributeField_type)
if handler is None:
raise NotImplementedError(u"Type %s used for %s not supported" %
(attributeField_type, attribute_name))
attributes[attribute_name] = handler.read(attribute_element)
else:
attributes[attribute_name] = \
self.readAttribute(attribute_element, attributeField)
parseinfo.stack.pop()
name = element.get('name')
if name is not None:
name = str(name)
attributes['__name__'] = name
field_instance = self._constructField(attributes)
# some fields can't validate fully until they're finished setting up
field_instance._init_field = True
# Handle those elements that can only be set up once the field is
# constructed, in the preferred order.
for attribute_name in self.fieldTypeAttributes:
if attribute_name in deferred:
attribute_element = deferred[attribute_name]
parseinfo.stack.append(attribute_element)
value = self.readAttribute(attribute_element, field_instance)
setattr(field_instance, attribute_name, value)
parseinfo.stack.pop()
for attribute_name in self.nonValidatedfieldTypeAttributes:
if attribute_name in deferred_nonvalidated:
# this is pretty nasty: we need the field's fromUnicode(),
# but this always validates. The missing_value field may by
# definition be invalid. Therefore, we need to fake it.
clone = self.klass.__new__(self.klass)
clone.__dict__.update(field_instance.__dict__)
clone.__dict__['validate'] = lambda value: True
attribute_element = deferred_nonvalidated[attribute_name]
parseinfo.stack.append(attribute_element)
value = self.readAttribute(attribute_element, clone)
setattr(field_instance, attribute_name, value)
parseinfo.stack.pop()
field_instance._init_field = True
if field_instance.defaultFactory is not None:
# we want to add some additional requirements for defaultFactory.
# zope.schema will be happy with any function, we'd like to
# restrict to those that provide IContextAwareDefaultFactory
# or IDefaultFactory
if not (
IContextAwareDefaultFactory.providedBy(field_instance.defaultFactory) or
IDefaultFactory.providedBy(field_instance.defaultFactory)
):
raise ImportError(u"defaultFactory must provide "
"zope.schema.interfaces.IContextAwareDefaultFactory "
"or plone.supermodel.IDefaultFactory")
return field_instance
def read(self, element):
"""Read a field from the element and return a new instance
"""
attributes = {}
deferred = {}
deferred_nonvalidated = {}
for attribute_element in element.iterchildren(tag=etree.Element):
parseinfo.stack.append(attribute_element)
attribute_name = noNS(attribute_element.tag)
if 'r' in self.filteredAttributes.get(attribute_name, ''):
continue
attributeField = self.fieldAttributes.get(attribute_name, None)
if attributeField is not None:
if attribute_name in self.fieldTypeAttributes:
deferred[attribute_name] = attribute_element
elif attribute_name in self.nonValidatedfieldTypeAttributes:
deferred_nonvalidated[attribute_name] = attribute_element
elif attribute_name in self.fieldInstanceAttributes:
attributeField_type = attribute_element.get('type')
handler = queryUtility(
IFieldExportImportHandler,
name=attributeField_type
)
if handler is None:
raise NotImplementedError(
u"Type %s used for %s not supported" %
(attributeField_type, attribute_name)
)
attributes[attribute_name] = handler.read(
attribute_element
)
else:
attributes[attribute_name] = self.readAttribute(
attribute_element,
attributeField
)
parseinfo.stack.pop()
name = element.get('name')
if name is not None:
name = str(name)
attributes['__name__'] = name
field_instance = self._constructField(attributes)
# some fields can't validate fully until they're finished setting up
field_instance._init_field = True
# Handle those elements that can only be set up once the field is
# constructed, in the preferred order.
for attribute_name in self.fieldTypeAttributes:
if attribute_name in deferred:
attribute_element = deferred[attribute_name]
parseinfo.stack.append(attribute_element)
value = self.readAttribute(attribute_element, field_instance)
setattr(field_instance, attribute_name, value)
parseinfo.stack.pop()
for attribute_name in self.nonValidatedfieldTypeAttributes:
if attribute_name in deferred_nonvalidated:
# this is pretty nasty: we need the field's fromUnicode(),
# but this always validates. The missing_value field may by
# definition be invalid. Therefore, we need to fake it.
clone = self.klass.__new__(self.klass)
clone.__dict__.update(field_instance.__dict__)
clone.__dict__['validate'] = lambda value: True
attribute_element = deferred_nonvalidated[attribute_name]
parseinfo.stack.append(attribute_element)
value = self.readAttribute(attribute_element, clone)
setattr(field_instance, attribute_name, value)
parseinfo.stack.pop()
field_instance._init_field = True
if field_instance.defaultFactory is not None:
# we want to add some additional requirements for defaultFactory.
# zope.schema will be happy with any function, we'd like to
# restrict to those that provide IContextAwareDefaultFactory
# or IDefaultFactory
if not (
IContextAwareDefaultFactory.providedBy(
field_instance.defaultFactory
) or
IDefaultFactory.providedBy(field_instance.defaultFactory)
):
raise ImportError(
u"defaultFactory must provide "
u"zope.schema.interfaces.IContextAwareDefaultFactory "
u"or plone.supermodel.IDefaultFactory"
)
return field_instance