Returns a tuple of all nested bencode elements.
516154
def __wrap_with_tuple(self) -> tuple:
        """"""
        l = list()
        length = len(self.data)
        while self.idx < length:
            l.append(self.__parse())
        return tuple(l)
405747
private List<Tuple> tuplesResult(EntityKey[] keys, TupleContext tupleContext, ClosableIterator<NodeWithEmbeddedNodes> nodes, Long txId, HttpNeo4jEntityQueries queries) {
		// The list is initialized with null because some keys might not have a corresponding node
		Tuple[] tuples = new Tuple[keys.length];
		while ( nodes.hasNext() ) {
			NodeWithEmbeddedNodes node = nodes.next();
			for ( int i = 0; i < keys.length; i++ ) {
				String[] keyNames = keys[i].getColumnNames();
				Object[] keyValues = keys[i].getColumnValues();
				Map<String, Object> nodeProperties = node.getOwner().getProperties();
				if ( RemoteNeo4jHelper.matches( nodeProperties, keyNames, keyValues ) ) {
					EntityKeyMetadata metadata = keys[i].getMetadata();
					Map<String, Node> toOneEntities = HttpNeo4jAssociatedNodesHelper.findAssociatedNodes( client, txId, node, metadata,
							tupleContext.getTupleTypeContext(), queries );
					tuples[i] = new Tuple(
							new HttpNeo4jTupleSnapshot(
									node,
									metadata,
									toOneEntities,
									tupleContext.getTupleTypeContext() ),
							SnapshotType.UPDATE );
					// We assume there are no duplicated keys
					break;
				}
			}
		}
		return Arrays.asList( tuples );
	}
1158378
def all_combinations_for_elements(self, element_symbols):
        
        d = OrderedDict()
        for symbol in element_symbols:
            d[symbol] = self.select_symbols(symbol, ret_list=True)

        from itertools import product
        return list(product(*d.values()))
930432
def get_all(self):
        # type: () -> typing.Iterable[typing.Tuple[str, str]]
        
        for name, values in six.iteritems(self._as_list):
            for value in values:
                yield (name, value)
372959
@Nonnull
  @ReturnsMutableCopy
  public ICommonsList <CSSKeyframesRule> getAllKeyframesRules ()
  {
    return m_aRules.getAllMapped (r -> r instanceof CSSKeyframesRule, r -> (CSSKeyframesRule) r);
  }
280693
function mapHierarchicalCodelist (e) {
    // TODO add levels
    var hcl = mapMaintainableArtefact(e);

    var hierarchies = _getChildrenNS(e, 'Hierarchy');
    if (hierarchies.length === 0) return hcl;

    hcl.items = hierarchies.map(function (h) {
      return mapItemScheme(h);
    });

    return hcl;
  }
497350
def getElements(self, node, name, nsuri=None):
        """"""
        nsmatch = self.nsUriMatch
        result = []
        ELEMENT_NODE = node.ELEMENT_NODE
        for child in node.childNodes:
            if child.nodeType == ELEMENT_NODE:
                if ((child.localName == name or name is None) and (
                    (nsuri is None) or nsmatch(child.namespaceURI, nsuri))):
                    result.append(child)
        return result
247273
def iter_members(self):
        
        if self.everything:
            raise ValueError("Can not iterate everything")
        for coord in sorted(self.elements):
            yield coord
337735
public List<List<Object>> getTuples() {
    Iterator<KeyValue> keyValueIter = indicators.keyValueIterator();
    List<List<Object>> tuples = Lists.newArrayList();
    while (keyValueIter.hasNext()) {
      KeyValue keyValue = keyValueIter.next();
      if (keyValue.getValue() != 0.0) {
        tuples.add(vars.intArrayToAssignment(keyValue.getKey()).getValues());
      }
    }
    return tuples;
  }
84043
def getAllNodeUids(self):
        '''
            
        '''
        # Start with a set including this tag's uuid
        ret = { self.uid }

        ret.update(self.getAllChildNodeUids())

        return ret
1257562
def getAllElementsOfHirarchy(self):
        
        allElements=[]
        for element in self.getAllElements():
            allElements.append(element)
            if isinstance(element, BaseElement):
                allElements.extend(element.getAllElementsOfHirarchy())
        return allElements
1176073
private List<Tuple> tuplesResult(EntityKey[] keys, TupleContext tupleContext, ResourceIterator<Node> nodes) {
		// The list is initialized with null because some keys might not have a corresponding node
		Tuple[] tuples = new Tuple[keys.length];
		while ( nodes.hasNext() ) {
			Node node = nodes.next();
			for ( int i = 0; i < keys.length; i++ ) {
				if ( matches( node, keys[i].getColumnNames(), keys[i].getColumnValues() ) ) {
					tuples[i] = new Tuple( EmbeddedNeo4jTupleSnapshot.fromNode( node,
							tupleContext.getTupleTypeContext().getAllAssociatedEntityKeyMetadata(),
							tupleContext.getTupleTypeContext().getAllRoles(),
							keys[i].getMetadata() ), SnapshotType.UPDATE );
					// We assume there are no duplicated keys
					break;
				}
			}
		}
		return Arrays.asList( tuples );
	}
344702
def _get_codes_for_sorting(self):
        
        from pandas.core.arrays import Categorical

        def cats(level_codes):
            return np.arange(np.array(level_codes).max() + 1 if
                             len(level_codes) else 0,
                             dtype=level_codes.dtype)

        return [Categorical.from_codes(level_codes, cats(level_codes),
                                       ordered=True)
                for level_codes in self.codes]
1097761
def get_indices(s: Union[str, 'ChainedBase']) -> Dict[int, str]:
    
    codes = get_code_indices(s)
    if not codes:
        # This function is not for non-escape-code stuff, but okay.
        return {i: c for i, c in enumerate(s)}

    indices = {}
    for codeindex in sorted(codes):
        code = codes[codeindex]
        if codeindex == 0:
            indices[codeindex] = code
            continue
        # Grab characters before codeindex.
        start = max(indices or {0: ''}, key=int)
        startcode = indices.get(start, '')
        startlen = start + len(startcode)
        indices.update({i: s[i] for i in range(startlen, codeindex)})
        indices[codeindex] = code

    if not indices:
        return {i: c for i, c in enumerate(s)}
    lastindex = max(indices, key=int)
    lastitem = indices[lastindex]
    start = lastindex + len(lastitem)
    textlen = len(s)
    if start < (textlen - 1):
        # Grab chars after last code.
        indices.update({i: s[i] for i in range(start, textlen)})
    return indices
627897
def all_elements(self):
        
        return [(k, getattr(self, k)) for k, v in get_members_safety(self.__class__)
                if not k.startswith("_") and isinstance(v, (BasePageElement,))]
1240139
def _get_components(self):
        
        return tuple([self._getitem__components(i) for
                     i in range(self._len__components())])
645136
def all(self):
        
        return {
            self._decode(k): self._loads(v)
            for k, v in self._client.hgetall(self.key_prefix).items()
        }