Output the top level cells from the GDSII data.

        Top level cells are those that are not referenced by any other
        cells.

        Returns
        -------
        out : list
            List of top level cells.
434231
def top_level(self):
        
        top = list(self.cell_dict.values())
        for cell in self.cell_dict.values():
            for dependency in cell.get_dependencies():
                if dependency in top:
                    top.remove(dependency)
        return top
473678
public void getRowHeadingBasedOnCells(TableCandidate tc) {
	String rowHeadingThisTable = "";
	int footnoteLineIndex = tc.getFootnoteBeginRow();
	String[][] cells = tc.getCells();
	// if (cells[0][0].length()==0 ) {
	for (int j = 0; j < footnoteLineIndex; j++) {
	    if (cells[j][0].length() > 0)
		rowHeadingThisTable = rowHeadingThisTable + cells[j][0] + "; ";
	}
	// }
	rowHeadingThisTable = tc
		.replaceAllSpecialChracters(rowHeadingThisTable);
	tc.setHeadingRows(rowHeadingThisTable);
    }
590914
def _get_table(self):
        
        data = get_inner_data(self.report)
        labels = data.keys()
        row = [
            data[key]
            for key in labels
        ]
        return list(labels), [row]
1069386
def output(self):
        """"""
        subts = [s.output for s in self.sims]
        sub_ndim = subts[0].ndim
        if sub_ndim is 1:
            subts = [distob.expand_dims(ts, 1) for ts in subts]
            sub_ndim += 1
        nodeaxis = sub_ndim
        subts = [distob.expand_dims(ts, nodeaxis) for ts in subts]
        ts = subts[0].concatenate(subts[1:], axis=nodeaxis)
        ts.labels[nodeaxis] = self._node_labels()
        return ts
1231574
def topLevelWindows(self):
        
        out = []
        clean = []
        for ref in self._topLevelWindows:
            window = ref()
            if window is not None:
                clean.append(ref)
                out.append(window)

        self._topLevelWindows = clean
        return out
371348
def sort_top_targets(self, top, orders):
        '''
        
        '''
        sorted_top = collections.defaultdict(OrderedDict)
        # pylint: disable=cell-var-from-loop
        for saltenv, targets in six.iteritems(top):
            sorted_targets = sorted(targets,
                    key=lambda target: orders[saltenv][target])
            for target in sorted_targets:
                sorted_top[saltenv][target] = targets[target]
        # pylint: enable=cell-var-from-loop
        return sorted_top
640481
def get_output_nodes(G: nx.DiGraph) -> List[str]:
    
    return [n for n, d in G.out_degree() if d == 0]
993944
def mapCellsToPoints(self):
        
        c2p = vtk.vtkCellDataToPointData()
        c2p.SetInputData(self.polydata(False))
        c2p.Update()
        return self.updateMesh(c2p.GetOutput())
1367337
def getBestMatchingCell(self, c, activeState):
    
    # Collect all cells in column c that have at least minThreshold in the most
    # activated segment
    bestActivityInCol = self.minThreshold
    bestSegIdxInCol = -1
    bestCellInCol = -1

    for i in xrange(self.cellsPerColumn):

      maxSegActivity = 0
      maxSegIdx = 0

      for j,s in enumerate(self.cells[c][i]):

        activity = self.getSegmentActivityLevel(s, activeState, connectedSynapsesOnly =False)

        if self.verbosity >= 6:
          print " Segment Activity for column ", c, " cell ", i, " segment ", " j is ", activity

        if activity > maxSegActivity:
          maxSegActivity = activity
          maxSegIdx = j

      if maxSegActivity >= bestActivityInCol:
        bestActivityInCol = maxSegActivity
        bestSegIdxInCol = maxSegIdx
        bestCellInCol = i

    if self.verbosity >= 6:
      print "Best Matching Cell In Col: ", bestCellInCol
    if bestCellInCol == -1:
      return (None, None)
    else:
      return bestCellInCol, self.cells[c][bestCellInCol][bestSegIdxInCol]
467584
def output_links(self):
        """"""
        output_links = []

        pm_dict = self.get_dict()
        output_links.append('surface_sample')
        if pm_dict['target_volume'] != 0.0:
            output_links.append('cell')

        return output_links
1353881
function _fnCoordsFromCell( n )
	{
		if ( _oDatatable )
		{
			return [
				$('td', n.parentNode).index(n),
				$('tr', n.parentNode.parentNode).index(n.parentNode) + _oDatatable._iDisplayStart
			];
		}
		else
		{
			return [
				$('td', n.parentNode).index(n),
				$('tr', n.parentNode.parentNode).index(n.parentNode)
			];
		}
	}
829475
def cells(self):
        

        n = 0

        for (order, cells) in self:
            n += len(cells)

        return n
102533
def toPostArgs(self):
        
        args = {}

        # Add namespace definitions to the output
        for ns_uri, alias in self.namespaces.items():
            if self.namespaces.isImplicit(ns_uri):
                continue
            if alias == NULL_NAMESPACE:
                ns_key = 'openid.ns'
            else:
                ns_key = 'openid.ns.' + alias
            args[ns_key] = oidutil.toUnicode(ns_uri)

        for (ns_uri, ns_key), value in self.args.items():
            key = self.getKey(ns_uri, ns_key)
            # Ensure the resulting value is an UTF-8 encoded *bytestring*.
            args[key] = oidutil.toUnicode(value)

        return args
793979
def show_top(**kwargs):
    '''
    
    '''
    __opts__['grains'] = __grains__
    opts = salt.utils.state.get_sls_opts(__opts__, **kwargs)
    st_ = salt.client.ssh.state.SSHHighState(
            opts,
            __pillar__,
            __salt__,
            __context__['fileclient'])
    top_data = st_.get_top()
    errors = []
    errors += st_.verify_tops(top_data)
    if errors:
        return errors
    matches = st_.top_matches(top_data)
    return matches
1287595
def _get_top_level_images(imagedata, subset=None):
    '''
    
    '''
    try:
        parents = [imagedata[x]['ParentId'] for x in imagedata]
        filter_ = subset if subset is not None else imagedata
        return [x for x in filter_ if x not in parents]
    except (KeyError, TypeError):
        raise CommandExecutionError(
            'Invalid image data passed to _get_top_level_images(). Please '
            'report this issue. Full image data: {0}'.format(imagedata)
        )
260049
def get_cell_lines(self, column_idx):
        '''
            
        '''
        return [] if column_idx >= len(self.columns) else self.columns[column_idx].get_cell_lines()
628950
private static List<String> getDeviceDescriptionsLowLevel()
	{
		final Context ctx = new Context();
		final int err = LibUsb.init(ctx);
		if (err != 0) {
			slogger.error("LibUsb initialization error {}: {}", -err, LibUsb.strError(err));
			return Collections.emptyList();
		}
		try {
			final DeviceList list = new DeviceList();
			final int res = LibUsb.getDeviceList(ctx, list);
			if (res < 0) {
				slogger.error("LibUsb device list error {}: {}", -res, LibUsb.strError(res));
				return Collections.emptyList();
			}
			try {
				return StreamSupport.stream(list.spliterator(), false).map(UsbConnection::printInfo)
						.collect(Collectors.toList());
			}
			finally {
				LibUsb.freeDeviceList(list, true);
			}
		}
		finally {
			LibUsb.exit(ctx);
		}
	}