code: def getDecodableAttributes(self, obj, attrs, codec=None):
          
          if not self._compiled:
              self.compile()
  
          changed = False
  
          props = set(attrs.keys())
  
          if self.static_attrs:
              missing_attrs = self.static_attrs_set.difference(props)
  
              if missing_attrs:
                  raise AttributeError('Static attributes %r expected '
                      'when decoding %r' % (missing_attrs, self.klass))
  
              props.difference_update(self.static_attrs)
  
          if not props:
              return attrs
  
          if not self.dynamic:
              if not self.decodable_properties:
                  props = set()
              else:
                  props.intersection_update(self.decodable_properties)
  
              changed = True
  
          if self.readonly_attrs:
              props.difference_update(self.readonly_attrs)
              changed = True
  
          if self.exclude_attrs:
              props.difference_update(self.exclude_attrs)
              changed = True
  
          if self.proxy_attrs is not None and codec:
              context = codec.context
  
              for k in self.proxy_attrs:
                  try:
                      v = attrs[k]
                  except KeyError:
                      continue
  
                  attrs[k] = context.getObjectForProxy(v)
  
          if self.synonym_attrs:
              missing = object()
  
              for k, v in self.synonym_attrs.iteritems():
                  value = attrs.pop(k, missing)
  
                  if value is missing:
                      continue
  
                  attrs[v] = value
  
          if not changed:
              return attrs
  
          a = {}
  
          [a.__setitem__(p, attrs[p]) for p in props]
  
          return a
docs: Returns a dictionary of attributes for C{obj} that has been filtered,
          based on the supplied C{attrs}. This allows for fine grain control
          over what will finally end up on the object or not.
  
          @param obj: The object that will recieve the attributes.
          @param attrs: The C{attrs} dictionary that has been decoded.
          @param codec: An optional argument that will contain the decoder
              instance calling this function.
          @return: A dictionary of attributes that can be applied to C{obj}
          @since: 0.5