def decode(dump, target=None, target_class=None):
    data = simplejson.loads(dump)
    registry = get_current_registry()

    fields = {}

    # collect all target's fields by their name
    if target:
        for interface in target.__provides__.interfaces():
            for name in getFieldNamesInOrder(interface):
                fields[name] = interface[name]

    # collect all target_class' fields by their name
    if target_class:
        for interface in target_class.__implemented__.interfaces():
            for name in getFieldNamesInOrder(interface):
                fields[name] = interface[name]

    values = {}
    for k, v in data.iteritems():
        # convert dictionary keys from unicode to str
        if isinstance(k, unicode):
            k = k.encode("utf-8")
        # convert dictionary values to proper field values
        if k in fields:
            v = registry.queryMultiAdapter(
                (fields[k], v), IFieldValue, default=v)
        values[k] = v

    return values

    def _set_default_configuration(self):
        defaults = {}
        tile_type = getUtility(ITileType, name=self.tile.__name__)
        fields = getFieldNamesInOrder(tile_type.schema)

        for name, field in getFieldsInOrder(tile_type.schema):
            order = unicode(fields.index(name))
            # default configuration attributes for all fields
            defaults[name] = {"order": order, "visibility": u"on"}
            if name == "css_class":
                # css_class, set default
                defaults[name] = field.default
            if ITextLine.providedBy(field):
                # field is TextLine, we should add 'htmltag'
                defaults[name]["htmltag"] = u"h2"
            elif INamedBlobImageField.providedBy(field):
                # field is an image, we should add 'position' and 'imgsize'
                defaults[name]["position"] = u"left"
                defaults[name]["imgsize"] = u"mini 200:200"
            elif IInt.providedBy(field):
                defaults[name][name] = field.default
            elif IDatetime.providedBy(field):
                # field is Datetime, we should add 'format'
                defaults[name]["format"] = "datetime"

        return defaults

def format_street_address(item, formatter):
    address_parts = []
    for attribute in getFieldNamesInOrder(IAddress):
        address_part = getattr(item, attribute, None)
        if address_part is not None:
            address_parts.append(address_part)
    return ", ".join(address_parts)

    def _normalize(self):
        if self.for_ is None:
            self.for_ = self.schema

        if self.class_ is None:
            self.bases = (self.view,)
        else:
            self.bases = (self.class_, self.view)

        if self.template is not None:
            self.template = os.path.abspath(str(self.template))
            if not os.path.isfile(self.template):
                raise ConfigurationError("No such file", self.template)
        else:
            self.template = self.default_template

        self.names = getFieldNamesInOrder(self.schema)

        if self.fields:
            for name in self.fields:
                if name not in self.names:
                    raise ValueError("Field name is not in schema",
                                     name, self.schema)
        else:
            self.fields = self.names

 def __init__(self, context, request=None):
     self.context = context
     self.request = request
     self.datasets = []
     self.datapoints = {}
     self.schema = IFormDefinition(self.context).schema
     self.fieldnames = getFieldNamesInOrder(self.schema)

 def __init__(self, schema, **kwargs):
     if IInterface.providedBy(schema):
         self.identifier = schema.__identifier__
     else:
         self.identifier = str(schema)
     for name in getFieldNamesInOrder(interfaces.IFlavor):
         if name in kwargs:
             setattr(self, name, kwargs.get(name))

 def __init__(self, context, request=None):
     ## context should be context of API view, not API view itself
     self.context = context
     self.__parent__ = context  # may be re-parented by API to view
     self.request = getRequest() if request is None else request
     self.definition = IFormDefinition(self.context)
     self._schema = self.definition.schema
     self._fieldnames = getFieldNamesInOrder(self._schema)

def getFields(context):
    domain_model = proxy.removeSecurityProxy(context.domain_model)
    domain_interface = queryModelInterface(domain_model)
    field_names = schema.getFieldNamesInOrder(domain_interface)
    for f in field_names:
        field = domain_interface[f]
        if isinstance(field, (schema.Choice, schema.Object, schema.List, schema.Tuple, schema.Bytes)):
            continue
        yield field

def get_unknown_fields(action_data, schema):
    """Return an error list of unknown fields that are not part of the schema.
    """
    errors = []
    known_field_names = getFieldNamesInOrder(schema)
    for key in action_data:
        if key not in known_field_names:
            errors.append((key, UnknownField(key)))
    return errors

 def available_fields(self):
     fields = []
     names = [
         name for name in getFieldNamesInOrder(IListingSearchTile)
         if name.startswith('form_')
     ]
     for name in names:
         if self.data.get(name, False):
             fields.append(name.split('form_')[1])
     return fields

def values(obj):
    registry = get_current_registry()
    values = {}
    for interface in obj.__provides__.interfaces():
        for name in getFieldNamesInOrder(interface):
            field = interface[name]
            bound = field.bind(obj)
            value = bound.get(obj)
            values[name] = registry.queryMultiAdapter(
                (field, value), IJSONValue, default=value)
    return values

 def __init__(self, context, request):
     self.context = context
     self.request = request
     self.portal = getSite()
     self.definition = IFormDefinition(self.context)
     self.series = context.__parent__  # assumes series <>--- form
     self.title = '%s: %s' % (self.series.Title().strip(), context.Title())
     self.seriesinfo = dict(
         [(k, v) for k, v in self.series.__dict__.items()
          if v is not None and k in getFieldNamesInOrder(IFormSeries)]
         )

    def __init__(cls, name, bases, dct, map_kind=True):
        """Initializes a class that might implement interfaces"""

        registry = get_current_registry()
        implements = getattr(cls, "__implements_advice_data__", None)
        for interface in (implements and implements[0] or ()):
            for name in schema.getFieldNamesInOrder(interface):
                field = interface[name]
                setattr(cls, name, registry.getAdapter(field, IProperty))
                dct.update({name: getattr(cls, name)})
        super(SchemaPropertiedClass, cls).__init__(name, bases, dct, map_kind)

    def testSA2ZS(self):

        iusers = transmute(users)
        self.assertEqual(tuple(schema.getFieldNamesInOrder(iusers)), ("user_id", "user_name"))

        fields = dict(schema.getFieldsInOrder(iusers))
        # assert types and constraints
        self.assertTrue(isinstance(fields["user_id"], schema.Int))
        self.assertTrue(fields["user_id"].required)
        self.assertTrue(isinstance(fields["user_name"], schema.TextLine))
        self.assertEqual(fields["user_name"].max_length, 40)
        self.assertEqual(fields["user_name"].default, u"hello world")

    def test_syncSchema_overwrite(self):
        class ISource(Interface):
            one = schema.TextLine(title=u"A")
            two = schema.Int(title=u"B")

        class IDest(Interface):
            one = schema.TextLine(title=u"C")
            three = schema.Int(title=u"D")

        ISource.setTaggedValue("tag1", "tag one")
        ISource.setTaggedValue("tag2", "tag two")
        IDest.setTaggedValue("tag1", "first tag")

        utils.syncSchema(ISource, IDest, overwrite=True)

        self.assertEqual(u"A", IDest["one"].title)

        self.assertEqual(["one", "two"], getFieldNamesInOrder(ISource))
        self.assertEqual(["one", "two"], getFieldNamesInOrder(IDest))

        self.assertEqual("tag one", IDest.getTaggedValue("tag1"))
        self.assertEqual("tag two", IDest.getTaggedValue("tag2"))

 def __getattr__(self, name):
     """If field, return default for attribute value"""
     if name.startswith('_v_'):
         raise AttributeError(name)  # no magic tricks with these.
     schema = self.__class__.schema.__get__(self)  # aq property workaround!
     if name == 'schema':
         return schema
     if schema is not None:
         fieldnames = getFieldNamesInOrder(schema)
         if name in fieldnames:
             field = schema.get(name)
             return field.default
     raise AttributeError(name)

    def setUpWidgets(self, ignore_request=False):
        self.adapters = self.adapters is not None and self.adapters or {}

        # grab all the adapters and fields from the entire wizard form sequence
        # (till the current step)
        adapters = self.wizard.data_manager.adapters
        fields = self.wizard.data_manager.fields

        formSchemas = component.getUtility(interfaces.IFormSchemas)
        # edit widgets for payment info
        self.widgets = form.setUpEditWidgets(
            self.form_fields.select(
                *schema.getFieldNamesInOrder(
                    formSchemas.getInterface('payment')
                )
            ),
            self.prefix, self.context, self.request,
            adapters=adapters, ignore_request=ignore_request
            )

        # display widgets for bill/ship address
        bill_ship_fields = []
        for i in (formSchemas.getInterface('billing_address'),
                  formSchemas.getInterface('shipping_address')):
            bill_ship_fields.append(
                fields.select(
                    *schema.getFieldNamesInOrder(i)
                )
            )
        # make copies of custom widgets.. (typically for edit, we want display)
        bill_ship_fields = sanitize_custom_widgets(
            reduce(operator.__add__, bill_ship_fields)
            )

        self.widgets += form.setUpEditWidgets(
            bill_ship_fields,  self.prefix, self.context, self.request,
            adapters=adapters, for_display=True, ignore_request=ignore_request
            )

    def attributes(self):
        context = removeSecurityProxy(self.context)
        attrs = [{'name': (ns and context.prefixes[ns]+':' or '') + name,
                  'value': value, 'url': None, 'values': []}
                 for (ns, name), value in context.attrs.items()]

        names = context.schema.names(True)
        rootURL = absoluteURL(findDocModule(self), self.request)
        for attr in attrs:
            name = (attr['name'] in names) and attr['name'] or attr['name']+'_'
            field = context.schema.get(name)

            if isinstance(field, (GlobalObject, GlobalInterface)):
                attr['url'] = self.objectURL(attr['value'], field, rootURL)

            elif isinstance(field, Tokens):
                field = field.value_type
                values = attr['value'].strip().split()
                if len(values) == 1:
                    attr['value'] = values[0]
                    attr['url'] = self.objectURL(values[0], field, rootURL)
                else:
                    for value in values:
                        if isinstance(field,
                                           (GlobalObject, GlobalInterface)):
                            url = self.objectURL(value, field, rootURL)
                        else:
                            break
                        attr['values'].append({'value': value, 'url': url})

        # Make sure that the attributes are in the same order they are defined
        # in the schema.
        fieldNames = getFieldNamesInOrder(context.schema)
        fieldNames = [name.endswith('_') and name[:-1] or name
                      for name in fieldNames]
        attrs.sort(lambda x, y: _compareAttrs(x, y, fieldNames))

        if not IRootDirective.providedBy(context):
            return attrs

        xmlns = []
        for uri, prefix in context.prefixes.items():
            name = prefix and ':'+prefix or ''
            xmlns.append({'name': 'xmlns'+name,
                          'value': uri,
                          'url': None,
                          'values': []})

        xmlns.sort(lambda x, y: cmp(x['name'], y['name']))
        return xmlns + attrs

def setUpColumns(domain_model):
    """Use model descriptor on domain model extract columns for table listings
    """
    columns = []
    table_schema = bungeni.alchemist.utils.get_derived_table_schema(
        domain_model)
    if not table_schema:
        raise SyntaxError(
            "Model must have domain interface %r" % (domain_model))
    descriptor_model = bungeni.alchemist.utils.get_descriptor(table_schema)

    field_column_names = \
        descriptor_model and descriptor_model.listing_columns \
        or schema.getFieldNamesInOrder(table_schema)

    # quick hack for now, dates are last in listings
    remainder = []

    for field_name in field_column_names:
        if not field_name in table_schema:
            # we can specify additional columns for tables that are not present in the
            # the interface, iff they are fully spec'd as columns in the descriptor/annotation
            if (descriptor_model and field_name in descriptor_model
                    and descriptor_model[field_name].listing_column):
                pass
            else:
                #print "bad field, container", field_name, table_schema.__name__
                continue

        info = descriptor_model and descriptor_model.get(field_name) or None

        if info is not None and info.listing_column:
            columns.append(info.listing_column)
            continue

        field = table_schema[field_name]

        if isinstance(field, schema.Datetime):
            remainder.append(
                column.GetterColumn(
                    title=field.title or field.__name__,
                    getter=DateGetter(field.query)))
            continue
        columns.append(
            column.GetterColumn(
                title=(field.title or field.__name__),
                getter=Getter(field.query)))
    columns.extend(remainder)
    return columns

    def _get_scss_variables(self, obj):
        schema = queryMultiAdapter((obj, obj.REQUEST),
                                   ICustomDesignVariablesSchema)
        if not schema:
            return

        annotations = IAnnotations(obj, None)
        if not annotations:
            return
        variables = annotations.get(VARIABLES_ANNOTATION_KEY) or {}

        form_fields = getFields(schema)
        for field_name in getFieldNamesInOrder(schema):
            yield (form_fields[field_name].variable_name,
                   variables.get(field_name))