Look up the attributes of a list.

        Args:
            name (str): The name of the list

        Returns:
            dict: attributes of the list
19674
def list_attributes(self, name):
        
        result = self.client.service.getListAttributes(name, self.proxy_id)
        if isinstance(result, list) and len(result) == 1:
            return result[0]
        return result
772709
def values(self, name):
        
        return list(self.lookup_variables.get(unnest_path(name), Null))
1333803
def attrs(self) -> _Attrs:
        
        if self._attrs is None:
            self._attrs = {k: v for k, v in self.element.items()}

            # Split class and rel up, as there are ussually many of them:
            for attr in ['class', 'rel']:
                if attr in self._attrs:
                    self._attrs[attr] = tuple(self._attrs[attr].split())

        return self._attrs
813514
def _attrs_(mcs, cls, attr_name: str) -> Tuple[Any, ...]:
        
        return tuple(map(lambda x: getattr(x, attr_name), list(cls)))
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
895897
def GetAttribute(self, name):
        
        ret = libxml2mod.xmlTextReaderGetAttribute(self._o, name)
        return ret
404711
def attributes(self):
        
        length = c_bst_ulong()
        sarr = ctypes.POINTER(ctypes.c_char_p)()
        _check_call(_LIB.XGBoosterGetAttrNames(self.handle,
                                               ctypes.byref(length),
                                               ctypes.byref(sarr)))
        attr_names = from_cstr_to_pystr(sarr, length)
        return {n: self.attr(n) for n in attr_names}
895118
def getAttribute(self, attribute):
        
        if type(attribute) in (list, tuple):
            if len(attribute) != 2:
                raise LookupError, 'To access attributes must use name or (namespace,name)'

            ns_dict = self.attributes.get(attribute[0])
            if ns_dict is None:
                return None

            return ns_dict.get(attribute[1])

        return self.attributes.get(attribute)
940006
def findattr(self, name):
        

        try:
            att = self.attr(name)
            if att._index is None:
                att = None
        except HDF4Error:
            att = None
        return att
242024
def get_attributes(element)
      attribute_hash = {}
      attributes = element.attributes
      for i in 0...attributes.length
         attribute_hash[attributes.item(i).name] =  attributes.item(i).value
       end
      attribute_hash
    end
1142558
def getParam(self, name=None):
        
        if 'parameters' in self.keys():
            l = {x['name']: x['value'] for x in self['parameters'].values()}
            if name:
                if name in l.keys():
                    return l[name]
                else:
                    return False
            else:
                return l
444163
def view_attr(attr_name):
    

    def view_attr(_value, context, **_params):
        value = getattr(context["view"], attr_name)
        return _attr(value)

    return view_attr
65232
def named(self, name):
        ''''''
        name = self.serialize(name)
        return self.get_by('name', name)
1325356
def attributes(self):
        
        if not self._attribute_pages:
            self.fetch_attributes()
        result = {}
        for page in self._attribute_pages.values():
            result.update(page.attributes)
        return result
939693
def attributes(name, **kwargs):
    ''''''
    print('%s has attributes:' % name)
    for key, value in kwargs.items():
        print('\t%s => %s' % (key, value))
842217
def getFeatureSetByName(self, name):
        
        if name not in self._featureSetNameMap:
            raise exceptions.FeatureSetNameNotFoundException(name)
        return self._featureSetNameMap[name]
73467
def get_attribute(self, name):
        
        for child, ancestry in self.attributes():
            if child.name == name:
                return (child, ancestry)
        return (None, [])