Distinct keywords (``name`` in :class:`.models.Keyword`)

        :returns: all distinct keywords
        :rtype: list[str]
334352
def keywords(self):
        
        return [x[0] for x in self.session.query(models.Keyword.name).all()]
1298782
def distinct_by_t(func):
    
    def distinct_by(sequence):
        distinct_lookup = {}
        for element in sequence:
            key = func(element)
            if key not in distinct_lookup:
                distinct_lookup[key] = element
        return distinct_lookup.values()
    return Transformation('distinct_by({0})'.format(name(func)), distinct_by, None)
485546
def keys(self):
        """"""
        return set(
            row[self._keycol] for row in self._connection.execute(
                """SELECT DISTINCT {} FROM {} ORDER BY {} ASC;""".format(
                    self.selkeycol,
                    self.table,
                    self._keycol
                )
            )
        )
149455
def filter_core_keywords(keywords):
    """"""
    matches = {}
    for kw, info in keywords.items():
        if kw.core:
            matches[kw] = info
    return matches
1253034
def distinct(self, key):
        
        return set(d[key] for d in filter(lambda d: key in d, self.find()))
623084
def distinct(xs):
    """"""
    # don't use collections.OrderedDict because we do support Python 2.6
    seen = set()
    return [x for x in xs if x not in seen and not seen.add(x)]
415279
def featuretypes(self):
        
        c = self.conn.cursor()
        c.execute(
            '''
            SELECT DISTINCT featuretype from features
            ''')
        for i, in c:
            yield i
905268
def distinct_values driver = nil
      @distinct_values ||= values || @filters.values.inject({}){|memo, filter| memo[filter.name] = filter.label; memo }
    end
520137
def get_existing_keyword(self, keyword):
        
        if self.existing_keywords is None:
            return {}
        if keyword is not None:
            return self.existing_keywords.get(keyword, {})
        else:
            return {}
897990
def most_similar(self, keyword, num):
        
        try:
            result = self.model.most_similar(keyword, topn = num) # most_similar return a list
            return {'key':keyword, 'value':result, 'similarity':1}
        except KeyError as e:
            kemKeyword = self.kemNgram.find(keyword)
            if kemKeyword:
                result = self.model.most_similar(kemKeyword, topn = num)
                return {'key':kemKeyword, 'value':result, 'similarity':self.kemNgram.compare(kemKeyword, keyword)}
            return {'key':keyword, 'value':[], 'similarity':0}
738974
def RemoveKeywordsForName(self, name, keywords):
    
    data_store.DB.IndexRemoveKeywordsForName(self.urn, name, keywords)
336435
def distinct():
    
    def validate(value):
        for i, item in enumerate(value):
            if item in value[i+1:]:
                return e("{} is not a distinct set of values", value)
    return validate
538992
def find_keyword(word_list: List[str], min_len: int = 3) -> Dict[str, int]:
    
    word_list = rank(word_list, exclude_stopwords=True)

    return {k: v for k, v in word_list.items() if v >= min_len}
58014
def distinct(key)
      result = collection.database.command(
        distinct: collection.name,
        key: key.to_s,
        query: selector
      )
      result["values"]
    end
917321
def fast_distinct(self):
        
        return self.model.objects.filter(pk__in=self.values_list('pk', flat=True))
1001920
def __get_keywords(self):
        
        txt = self.text
        for line in txt:
            for word in split_words(line):
                yield(word)
715455
def get_groups(self, table_name):
        
        df = self.dm[table_name]
        return list(df['group'].unique())