Return attribute names of this model.
174845
public String[] _getAttrNames() {
		Set<String> attrNameSet = attrs.keySet();
		return attrNameSet.toArray(new String[attrNameSet.size()]);
	}
1076483
def _attributeStrs(self):
        
        return ";".join([self._attributeStr(name)
                         for name in self.attributes.iterkeys()])
528057
public function attributeNames()
    {
        $className = get_class($this);
        if (!isset(self::$_names[$className])) {
            $reflection = Unit::getReflectionClass($this);
            $names = [];
            foreach ($reflection->getProperties() as $property) {
                $name = $property->getName();
                if ($property->isPublic() && !$property->isStatic()) {
                    $names[] = $name;
                }
            }
            self::$_names[$className] = $names;
        }
        return self::$_names[$className];
    }
619391
public Set<String> getAttributeNames() {
    if (attributes == null) {
      return Collections.emptySet();
    } else {
      return Collections.unmodifiableSet(attributes.keySet());
    }
  }
648477
def simpleAttrs(self):
        """"""
        simpleAttrs = {}
        for k,v in iteritems(self.attrs):
            if k in ["_matches"]: continue # attributes to specifically ignore
            try:    simpleAttrs[k] = v.type
            except: simpleAttrs[k] = v
        return simpleAttrs
764242
public String[] getAttributeNames()
    {
        Set      keys   = (attributeMap == null ? new HashSet() : attributeMap.keySet());
        String[] result = new String[keys.size()];

        keys.toArray(result);
        return result;
    }
316709
def getFields(self):
        
        d = {}
        for i in self._attrsList:
            key = i
            value = getattr(self,  i)
            d[key] = value
        return d
161750
public final Set<BodyQName> getAttributeNames() {
        Map<BodyQName, String> attrs = getAttributes();
        return Collections.unmodifiableSet(attrs.keySet());
    }
476355
def attributes(self):
        
        return dict([(name, getattr(self, name)) for (name, _) in self.format.values() if name is not None and not name.startswith('_')])
522430
def GetAttributeValuesString(self):
    
    attributes = []
    for attribute_name, attribute_value in sorted(self.__dict__.items()):
      # Not using startswith to improve performance.
      if attribute_name[0] == '_' or attribute_value is None:
        continue

      if isinstance(attribute_value, dict):
        attribute_value = sorted(attribute_value.items())

      elif isinstance(attribute_value, py2to3.BYTES_TYPE):
        attribute_value = repr(attribute_value)

      attribute_string = '{0:s}: {1!s}'.format(attribute_name, attribute_value)
      attributes.append(attribute_string)

    return ', '.join(attributes)
221103
def get_feature_names(self):
        
        feature_names = []
        for name, trans, weight in self._iter():
            if not hasattr(trans, 'get_feature_names'):
                raise AttributeError("Transformer %s (type %s) does not "
                                     "provide get_feature_names."
                                     % (str(name), type(trans).__name__))
            feature_names.extend([name + "__" + f for f in
                                  trans.get_feature_names()])
        return feature_names
32743
def get_attrs(self, *names):
        """"""
        attrs = [getattr(self, name) for name in names]
        return attrs
511055
def get_pk_attrnames(obj) -> List[str]:
    
    return [attrname
            for attrname, column in gen_columns(obj)
            if column.primary_key]
548732
def to_list(self):
        """"""

        ret = OrderedDict()
        for attrname in self.attrs:
            ret[attrname] = self.__getattribute__(attrname)
        return ret
1371773
def _get_default_field_names(self, declared_fields, model_info):
        
        return (
            [model_info.pk.name] +
            list(declared_fields.keys()) +
            list(model_info.fields.keys()) +
            list(model_info.relations.keys())
        )
358779
def _repr_name(self):
        
        names = {"name", "attrname"}
        if all(name not in self._astroid_fields for name in names):
            return getattr(self, "name", getattr(self, "attrname", ""))
        return ""
1280266
def get_names():
    """"""
    res = list(cmaps.keys())
    res = sorted(res, key=lambda s: s.lower())
    return res