Return a unique BDD.
179703
def _bdd(node):
    """"""
    try:
        bdd = _BDDS[node]
    except KeyError:
        bdd = _BDDS[node] = BinaryDecisionDiagram(node)
    return bdd
738777
def add_unique(self, attr, item):
        
        return self.set(attr, operation.AddUnique([item]))
963012
def get_instance_from_id(unique_id):
        """"""
        for instance in PolygonFilter.instances:
            if instance.unique_id == unique_id:
                return instance
        # if this does not work:
        raise KeyError("PolygonFilter with unique_id {} not found.".
                       format(unique_id))
412335
def _derive_unique_path(self):
        """"""
        base, ext = path.splitext(self._input_filename)
        return '%s.unique%s' % (base, ext)
39197
def uniquenessRatio(self, value):
        """"""
        if value >= 5 and value <= 15:
            self._uniqueness = value
        else:
            raise InvalidUniquenessRatioError("Uniqueness ratio must be "
                                              "between 5 and 15.")
        self._replace_bm()
1004620
def pad_block(block, block_size):
    """"""
    unique_vals, unique_counts = np.unique(block, return_counts=True)
    most_frequent_value = unique_vals[np.argmax(unique_counts)]
    return np.pad(block,
                  tuple((0, desired_size - actual_size)
                        for desired_size, actual_size
                        in zip(block_size, block.shape)),
                  mode="constant", constant_values=most_frequent_value)
506655
def choose_one(things):
    """"""
    choice = SystemRandom().randint(0, len(things) - 1)
    return things[choice].strip()
510575
def get_unique_id(element):
    """"""
    this_id = make_id(element)
    dup = True
    while dup:
        if this_id not in ids:
            dup = False
            ids.append(this_id)
        else:
            this_id = make_id(element)
    return ids[-1]
723077
def unique(series: pd.Series) -> pd.Series:
    """"""
    return ~series.duplicated(keep=False)
108577
def unique_everseen(seq):
    """"""
    seen = set()
    seen_add = seen.add
    return [x for x in seq if not (x in seen or seen_add(x))]
769361
def _unique_name(name, seen):
        """"""
        if name in seen:
            n = seen[name]
            while (name + ".%d" % n) in seen:
                n += 1
            seen[name] = n + 1
            name += ".%d" % n
        seen[name] = 1
        return name
1243201
def i2b(self, pkt, x):
        """"""
        if type(x) is str:
          x = bytes([ ord(i) for i in x ])
        return x
712487
def get_jid(jid):
    '''
    
    '''
    cb_ = _get_connection()
    _verify_views()

    ret = {}

    for result in cb_.query(DESIGN_NAME, 'jid_returns', key=six.text_type(jid), include_docs=True):
        ret[result.value] = result.doc.value

    return ret
700805
public void createUniqueData()
    {
        LoginGenerator.LoginRecord unique_login;
        unique_login = random_login_generator.createUniqueLogin("voltdb", true);
        doLogin(unique_login);
        unique_login = random_login_generator.createUniqueLogin("voltdb2", false);
        doLogin(unique_login);
    }
1013582
def uniqueID(size=6, chars=string.ascii_uppercase + string.digits):
    """"""
    return ''.join(random.choice(chars) for x in xrange(size))
55443
def unique_everseen(iterable):
    """"""
    # unique_everseen('AAAABBBCCDAABBB')    --> A B C D
    seen = set()
    seen_add = seen.add

    for element in six.moves.filterfalse(seen.__contains__, iterable):
        seen_add(element)
        yield element
864941
def _id(self):
        """"""
        result = ''
        while self.char is not None and (self.char.isalnum() or self.char == '_'):
            result += self.char
            self.advance()

        token = RESERVED_KEYWORDS.get(result, Token(Nature.ID, result))
        return token