Retrieves a comparable string of the attribute values.
    Returns:
      str: comparable string of the attribute values.
356534
def get_attribute_values_string(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, six.binary_type):
        attribute_value = repr(attribute_value)

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

    return ', '.join(attributes)
1142013
def get_attributes(self):
        
        items = {}
        items['form_method'] = self.form_method.strip()
        items['form_tag'] = self.form_tag
        items['form_style'] = self.form_style.strip()
        
        if self.form_action:
            items['form_action'] = self.form_action.strip()
        if self.form_id:
            items['id'] = self.form_id.strip()
        if self.form_class:
            items['class'] = self.form_class.strip()
        if self.inputs:
            items['inputs'] = self.inputs
        if self.form_error_title:
            items['form_error_title'] = self.form_error_title.strip()
        if self.formset_error_title:
            items['formset_error_title'] = self.formset_error_title.strip()
        return items
845341
def getAttrs(self, node):
        
        attrs = {}
        for k,v in node._attrs.items():
            attrs[k] = v.value
        return attrs
1076483
def _attributeStrs(self):
        
        return ";".join([self._attributeStr(name)
                         for name in self.attributes.iterkeys()])
1095771
def get_value(self, attributes,key = None):
        

        value = attributes
        if key is None:
            key = self._splitted_key

        # A splitted key like 'a.b.c' goes into nested properties
        # and the value is retrieved recursively
        for i,elem in enumerate(key):
            if isinstance(value, (list,tuple)):
                #if this is a list, we return all matching values for the given list items
                return [self.get_value(v,key[i:]) for v in value]
            else:
                value = value[elem]

        return value
468048
def getVals(self):
        
        return [(name, self._fieldValDict.get(name)) 
                for name in self._fieldNameList]
1153838
def comparable(self):
    """"""
    sub_comparable_string = 'encoding_method: {0:s}'.format(
        self.encoding_method)
    return self._GetComparable(sub_comparable_string=sub_comparable_string)
1285602
def GetAttributes(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
110425
def get_attribute(self, name):
        
        assert isinstance(name, compat.str_type)
        return self.__attributes.get(name)
427352
def get_attributes(self):
        
        attr = ['chr', 'start', 'stop']
        if self.strandPos is not None:
            attr.append('strand')
        if self.otherPos:
            for i, o in enumerate(self.otherPos):
                attr.append(o[1])

        return attr
369611
def getAttributeValueType(self, index):
        
        offset = self._get_attribute_offset(index)
        return self.m_attributes[offset + const.ATTRIBUTE_IX_VALUE_TYPE]
1181539
def get_attribute(self, attribute):
        
        value = self.api.getAttribute(self.obj_ref(), attribute)
        # IXN returns '::ixNet::OK' for invalid attributes. We want error.
        if value == '::ixNet::OK':
            raise TgnError(self.ref + ' does not have attribute ' + attribute)
        return str(value)
787900
public List<String> listAttributeValues() {
        List<String> list = new ArrayList<String>();
        Collection<String> names = listAttributeNames();
        for (String name : names) {
            try {
                Object val = this.getProperty(name);
                if (val != null) {
                    list.add(name + " : " + val.toString());
                }
            } catch (Exception e) {
                throwException("Could not list attribute values. Reason: ", e);
            }
        }
        return list;
    }
1103169
def attributes_strToDict(astr_attributes, astr_separator=" "):
  
  adict = {}
  alist = str2lst(astr_attributes, astr_separator)
  for str_pair in alist:
    alistTuple = str2lst(str_pair, "=")
    adict.setdefault(alistTuple[0], alistTuple[1].strip(chr(0x22) + chr(0x27)))
  return adict
315282
def get_max_value(self):
        

        value = self.get_default_value()

        if self.attribute_type is str:
            max_value = value.ljust(self.max_length + 1, 'a')

        elif self.attribute_type is int:
            max_value = self.max_length + 1

        else:
            raise TypeError('Attribute %s can not have a maximum value' % self.local_name)

        return max_value
1255250
def getAttributeValue(self, namespaceURI, localName):
        '''
        
        '''
        if self.hasAttribute(namespaceURI, localName):
            attr = self.node.getAttributeNodeNS(namespaceURI,localName)
            return attr.value
        return None
62442
def to_params(self):
        
        params = {}
        for name in self.PROPERTIES:
            attr = '_{0}'.format(name)
            value = getattr(self, attr, None) or getattr(self, name, None)

            # skip attribute
            if value is None:
                continue

            if isinstance(value, datetime):
                params[name] = format_time(value)
            elif isinstance(value, list):
                params[name] = ','.join(map(str, value))
            elif isinstance(value, bool):
                params[name] = str(value).lower()
            else:
                params[name] = value

        return params