Returns a string representation of a sequence of integers.

    :param ids: Sequence of integers.
    :return: String sequence
489006
def ids2strids(ids: Iterable[int]) -> str:
    
    return C.TOKEN_SEPARATOR.join(map(str, ids))
775205
private String[] asIDs( List<Object> values ) {
        ValueFactory<String> factory = valueFactories.getStringFactory();
        String[] res = new String[values.size()];
        for (int i = 0; i < res.length; i++) {
            res[i] = factory.create(values.get(i));
        }
        return res;
    }
639514
def id2rel(self, xs):
        
        if isinstance(xs, list):
            return [self._id2rel[x] for x in xs]
        return self._id2rel[xs]
652116
def idx_sequence(self):
        
        return [x[1] for x in sorted(zip(self._record, list(range(len(self._record)))))]
295990
def _uniqueid(n=30):
    
    return ''.join(random.SystemRandom().choice(
                   string.ascii_uppercase + string.ascii_lowercase)
                   for _ in range(n))
916052
def get_sequence_str(self):
        '''
        
        '''
        sequence = self.get_sequence()
        return '->'.join(e.dst.name for e in sequence)
1125048
def loadCats(self, ids=[]):
        
        if type(ids) == list:
            return [self.cats[id] for id in ids]
        elif type(ids) == int:
            return [self.cats[ids]]
170479
function getChainIndexById(id, sequence){
    return sequence.map(function(el){
      return el._id;
    }).indexOf(id);
  }
1334074
def _read_id_numbers(self):
        """"""
        _byte = self._read_fileng(4)
        _addr = '.'.join([str(_) for _ in _byte])
        return _addr
211866
private static Object[] getSortedIds(final Scriptable s) {
        final Object[] ids = getIds(s);
        Arrays.sort(ids, (a, b) -> {
            if (a instanceof Integer) {
                if (b instanceof Integer) {
                    return ((Integer)a).compareTo((Integer)b);
                } else if (b instanceof String || b instanceof Symbol) {
                    return -1; // ints before strings or symbols
                }
            } else if (a instanceof String) {
                if (b instanceof String) {
                    return ((String)a).compareTo((String)b);
                } else if (b instanceof Integer) {
                    return 1; // strings after ints
                } else if (b instanceof Symbol) {
                    return -1; // strings before symbols
                }
            } else if (a instanceof Symbol) {
                if (b instanceof Symbol) {
                    // As long as people bother to reasonably name their symbols,
                    // this will work. If there's clashes in symbol names (e.g.
                    // lots of unnamed symbols) it can lead to false inequalities.
                    return getSymbolName((Symbol)a).compareTo(getSymbolName((Symbol)b));
                } else if (b instanceof Integer || b instanceof String) {
                    return 1; // symbols after ints and strings
                }
            }
            // We can only compare Rhino key types: Integer, String, Symbol
            throw new ClassCastException();
        });
        return ids;
    }
266464
def length_by_id(self):
        """"""
        hashmap = dict((seq.id, len(seq)) for seq in self)
        tmp = hashmap.copy()
        hashmap.update(tmp)
        return hashmap
860125
def _stringifyKeys(d):
    
    return dict((k.encode('ascii'), v)  for (k, v) in d.iteritems())
238620
def tokens2ids(tokens: Iterable[str], vocab: Dict[str, int]) -> List[int]:
    
    return [vocab.get(w, vocab[C.UNK_SYMBOL]) for w in tokens]
1065333
def sequence(values):
    
    import ibis.expr.operations as ops

    return ops.ValueList(values).to_expr()
620292
public Set<String> getIdsForIdWithDescendants(String s) {
        buildIsTypeOf();
        Stack<String> idsToConsider = new Stack<String>();
        idsToConsider.add(s);
        Set<String> resultIds = new HashSet<String>();
        while (!idsToConsider.isEmpty()) {
            String id = idsToConsider.pop();
            if (!resultIds.contains(id)) {
                resultIds.add(id);
                if (terms.containsKey(id))
                    idsToConsider.addAll(terms.get(id).getIsTypeOf());
            }
        }
        return resultIds;
    }
71068
public static <S extends Sequence<C>, C extends Compound> String getIDFormat(List<S> sequences) {
		int length = 0;
		for (S as : sequences) {
			length = Math.max(length, (as.getAccession() == null) ? 0 : as.getAccession().toString().length());
		}
		return (length == 0) ? null : "%-" + (length + 1) + "s";
	}
1110253
def id_type(str)
      return false unless str
      str &&= str.to_s.strip
      (Rudy::ID_MAP.detect { |n,v| v == str.split('-').first } || []).first
    end