Returns an iterator over all terminal mapped attributes for the given
        mapped class and attribute key. See :method:`get_attribute_map` for
        details.
557225
def terminal_attribute_iterator(self, mapped_class=None, key=None):
        
        for attr in self._attribute_iterator(mapped_class, key):
            if attr.kind == RESOURCE_ATTRIBUTE_KINDS.TERMINAL:
                yield attr
11041
function getAttrMap(attrs)
{
	var i;
	var map = {};
	var numAttrs = attrs.length;
	
	for (i=0; i<numAttrs; i++)
	{
		map[ attrs[i].name ] = attrs[i].value;
	}
	
	return map;
}
1047386
def typed_fields_with_attrnames(cls):
        
        # Checking cls._typed_fields could return a superclass _typed_fields
        # value. So we check our class __dict__ which does not include
        # inherited attributes.
        klassdict = cls.__dict__

        try:
            return klassdict["_typed_fields_with_attrnames"]
        except KeyError:
            # No typed_fields set on this Entity yet. Find them and store
            # them in the _typed_fields class attribute.
            from . import fields
            typed_fields = tuple(fields.iterfields(cls))
            cls._typed_fields_with_attrnames = typed_fields
        return typed_fields
902160
def attribute(self, keys):
        
        if self['meta']['prefix'] is None:
            k = keys
        else:
            k = self['meta']['prefix'] + "." + keys
        return self.get(k)
707108
def keys(self):
        
        return sorted([k for k in dir(self) if
                       k[0:1] != '_' and k != 'keys' and not k.isupper() and
                       not inspect.ismethod(getattr(self, k)) and
                       not (hasattr(self.__class__, k) and
                            isinstance(getattr(self.__class__, k),
                                       property)) and
                       not isinstance(getattr(self, k), property)])
1299365
def get_attributes(klass)
      return @attribute_store[klass] if @attribute_store.key?(klass)

      attributes = []
      klass.ancestors.map do |k|
        hash = k.instance_variable_get(:@class_kit_attributes)
        if hash != nil
          hash.values.each do |a|
            attributes.push(a)
          end
        end
      end
      attributes.compact!

      @attribute_store[klass] = attributes
      attributes
    end
787810
def attrs(self) -> Mapping:
        
        if self._attrs is None:
            self._attrs = OrderedDict()
        return self._attrs
280122
def get_domain_class_member_attribute_iterator(ent):
    
    for attr in itervalues_(ent.__everest_attributes__):
        if attr.kind == RESOURCE_ATTRIBUTE_KINDS.MEMBER:
            yield attr
307795
public Iterable<Attribute> getOwnAttributes() {
    return stream(getOwnAllAttributes()).filter(attr -> attr.getParent() == null).collect(toList());
  }
410948
function(attrs) {
    for (var key in attrs) {
      //convert cls to class
      var mappedKey = key == 'cls' ? 'class' : key;
      
      this.attributes[mappedKey] = attrs[key];
    }
    return this;
  }
934
def iterclass(cls):
    
    for field in dir(cls):
        if hasattr(cls, field):
            value = getattr(cls, field)
            yield field, value
72091
def _make_attr_tuple_class(cls_name, attr_names):
    
    attr_class_name = "{}Attributes".format(cls_name)
    attr_class_template = [
        "class {}(tuple):".format(attr_class_name),
        "    __slots__ = ()",
    ]
    if attr_names:
        for i, attr_name in enumerate(attr_names):
            attr_class_template.append(
                _tuple_property_pat.format(index=i, attr_name=attr_name)
            )
    else:
        attr_class_template.append("    pass")
    globs = {"_attrs_itemgetter": itemgetter, "_attrs_property": property}
    eval(compile("\n".join(attr_class_template), "", "exec"), globs)

    return globs[attr_class_name]
775287
def keys(self):
        

        keys = list()

        for attribute_name, type_instance in inspect.getmembers(self):

            # ignore parameters with __ and if they are methods
            if attribute_name.startswith('__') or inspect.ismethod(type_instance):

                continue

            keys.append(attribute_name)

        return keys
381612
public Map<String, Object> getAttributes() {
        if (attributes == null) {
            return null;
        }
        Lock lock = lockForRead();
        try {
            return cloneData(attributes);
        } finally {
            lock.unlock();
        }
    }
179336
def _get_attrs(self, names):
        
        assert isinstance(names, str)
        names = names.replace(",", " ").split(" ")
        res = []
        for n in names:
            if n == "":
                continue
            if n not in self.__dict__:
                raise KeyError("Unknown name for Container attribute: '{}'".format(n))
            res.append(getattr(self, n))
        return res
249879
def get_attributes(self):
    
    for attribute_name, attribute_value in iter(self.__dict__.items()):
      # Not using startswith to improve performance.
      if attribute_name[0] == '_' or attribute_value is None:
        continue

      yield attribute_name, attribute_value
1258200
def getEncodableAttributes(self, obj, **kwargs):
        
        attrs = pyamf.ClassAlias.getEncodableAttributes(self, obj, **kwargs)

        if not self.exclude_sa_key:
            # primary_key_from_instance actually changes obj.__dict__ if
            # primary key properties do not already exist in obj.__dict__
            attrs[self.KEY_ATTR] = self.mapper.primary_key_from_instance(obj)

        if not self.exclude_sa_lazy:
            lazy_attrs = []

            for attr in self.properties:
                if attr not in obj.__dict__:
                    lazy_attrs.append(attr)

            attrs[self.LAZY_ATTR] = lazy_attrs

        return attrs