Return the information summary for an Element. This consists
        of the dotted name followed by an value dimension names.
762473
def element_info(cls_or_slf, node, siblings, level, value_dims):
        
        info = cls_or_slf.component_type(node)
        if len(node.kdims) >= 1:
            info += cls_or_slf.tab + '[%s]' % ','.join(d.name for d in node.kdims)
        if value_dims and len(node.vdims) >= 1:
            info += cls_or_slf.tab + '(%s)' % ','.join(d.name for d in node.vdims)
        return level, [(level, info)]
1224983
def info(self):
        ''' 
        '''
        return sorted(self._checkers.values(), key=lambda x: (x.ns, x.name))
1321090
def get_summary(content):
  """"""
  soup = BeautifulSoup(content, "html.parser")
  summary = soup.find_all(attrs={
      'class': re.compile(r".*\bsummary-content\b.*")})

  if summary[0].p.string is None:
    return summary[0].p.p.getText()
  return summary[0].p.getText()
862369
def tag_info(self):
        """"""
        return self.__class__.__name__ + (
            '(%r)' % self.name if self.name
            else "") + ": " + self.valuestr()
494863
def info(self):
        """"""
        itext = self.class_info
        if self.prop.info:
            itext += ' (each item is {})'.format(self.prop.info)
        if self.max_length is None and self.min_length is None:
            return itext
        if self.max_length is None:
            lentext = 'length >= {}'.format(self.min_length)
        elif self.max_length == self.min_length:
            lentext = 'length of {}'.format(self.min_length)
        else:
            lentext = 'length between {mn} and {mx}'.format(
                mn='0' if self.min_length is None else self.min_length,
                mx=self.max_length,
            )
        return '{} with {}'.format(itext, lentext)
581799
def get_summary(self):
        
        return {
            "count": self.count(),
            "pass": self.success_count(),
            "fail": self.failure_count(),
            "skip": self.skip_count(),
            "inconclusive": self.inconclusive_count(),
            "retries": self.retry_count(),
            "duration": self.total_duration()
        }
443702
function findLargestAbsElement (M) {
  const te = M.elements;
  const n = M.dimension;
  let max = _Math.abs(te[0]);
  let rowCol = {
    row: 0,
    column: 0,
    value: te[0]
  };
  for (let i = 0; i < n; ++i) {
    for (let j = 0; j < n; ++j) {
      const val = te[i * n + j];
      const ti = _Math.abs(val);
      if (ti > max) {
        max = ti;
        rowCol.row = j;
        rowCol.column = i;
        rowCol.value = val;
      }
    }
  }
  return rowCol;
}
459922
async def info(self):
        '''
        
        '''
        stat = self._items.stat()
        return {'indx': self._items.index(), 'metrics': self._metrics.index(), 'stat': stat}
307005
def summary( self ):
        
        child_text = []
        
        for c in range(self.childCount()):
            child = self.child(c)
            text = [child.text(0), child.text(1), child.text(2), child.text(3)]
            text = map(str, text)
            
            while ( '' in text ):
                text.remove('')
            
            child_text.append( ' '.join(text) )
        
        return ' '.join(child_text)
651207
def get_gradebook_column_summary_mdata():
    """"""
    return {
        'gradebook_column': {
            'element_label': {
                'text': 'gradebook column',
                'languageTypeId': str(DEFAULT_LANGUAGE_TYPE),
                'scriptTypeId': str(DEFAULT_SCRIPT_TYPE),
                'formatTypeId': str(DEFAULT_FORMAT_TYPE),
            },
            'instructions': {
                'text': 'accepts an osid.id.Id object',
                'languageTypeId': str(DEFAULT_LANGUAGE_TYPE),
                'scriptTypeId': str(DEFAULT_SCRIPT_TYPE),
                'formatTypeId': str(DEFAULT_FORMAT_TYPE),
            },
            'required': False,
            'read_only': False,
            'linked': False,
            'array': False,
            'default_id_values': [''],
            'syntax': 'ID',
            'id_set': [],
        },
    }
1279772
function describeElement(elem) {
	  if (!elem || !elem.tagName) {
	    return null;
	  }
	  var out = {}, className, key, attr, i;
	  out.tagName = elem.tagName.toLowerCase();
	  if (elem.id) {
	    out.id = elem.id;
	  }
	  className = elem.className;
	  if (className && (typeof className === 'string')) {
	    out.classes = className.split(/\s+/);
	  }
	  var attributes = ['type', 'name', 'title', 'alt'];
	  out.attributes = [];
	  for (i = 0; i < attributes.length; i++) {
	    key = attributes[i];
	    attr = elem.getAttribute(key);
	    if (attr) {
	      out.attributes.push({key: key, value: attr});
	    }
	  }
	  return out;
	}
294705
def _get_hover_data(self, data, element):
        
        if 'hover' not in self.handles or self.static_source:
            return

        npath = len([vs for vs in data.values()][0])
        for d in element.vdims:
            dim = util.dimension_sanitizer(d.name)
            if dim not in data:
                if element.level is not None:
                    data[dim] = np.full(npath, element.level)
                elif element.interface.isscalar(element, d):
                    data[dim] = element.dimension_values(d, expanded=False)
                else:
                    data[dim] = element.split(datatype='array', dimensions=[d])
            elif isinstance(data[dim], np.ndarray) and data[dim].dtype.kind == 'M':
                data[dim+'_dt_strings'] = [d.pprint_value(v) for v in data[dim]]

        for k, v in self.overlay_dims.items():
            dim = util.dimension_sanitizer(k.name)
            if dim not in data:
                data[dim] = [v for _ in range(len(list(data.values())[0]))]
587975
def __summary(self):
        """"""
        text = "Time: %s\n" % self.when
        text += "Comitter: %s\n" % self.editor

        inst = self.timemachine.presently

        if self.action_type == "dl":
            text += "Deleted %s\n" % inst._object_type_text()
        elif self.action_type == "cr":
            text += "Created %s\n" % inst._object_type_text()
        else:
            text += "Modified %s\n" % inst._object_type_text()
        text += self._details(nohtml=True)
        return text
342576
def _summary(self, name=None):
        
        if len(self) > 0:
            head = self[0]
            if hasattr(head, 'format') and not isinstance(head, str):
                head = head.format()
            tail = self[-1]
            if hasattr(tail, 'format') and not isinstance(tail, str):
                tail = tail.format()
            index_summary = ', %s to %s' % (pprint_thing(head),
                                            pprint_thing(tail))
        else:
            index_summary = ''

        if name is None:
            name = type(self).__name__
        return '%s: %s entries%s' % (name, len(self), index_summary)
826929
def _get_info_score(info):
        
        search = re.search(pattern="score (?P<eval>\w+) (?P<value>-?\d+)", string=info)
        return {"score": {"eval": search.group("eval"), "value": int(search.group("value"))}}
508419
def count_elements(doc):
    ""
    summary = {}
    for el in doc.iter():
        try:
            namespace, element_name = re.search('^{(.+)}(.+)$', el.tag).groups()
        except:
            namespace = None
            element_name = el.tag
        if not summary.has_key(namespace):
            summary[namespace] = {}
        if not summary[namespace].has_key(element_name):
            summary[namespace][element_name] = 1
        else:
            summary[namespace][element_name] += 1
    return summary
902156
def summarize(self):
        ''''''

        self.speak('Here is a brief summary of {}.'.format(self.nametag))
        s = '\n'+pprint.pformat(self.__dict__)
        print(s.replace('\n', '\n'+' '*(len(self._prefix)+1)) + '\n')