Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def testQratioForceAscii(self):
s1 = "ABCD\u00C1"
s2 = "ABCD"
score = fuzz.QRatio(s1, s2, force_ascii=True)
self.assertEqual(score, 100)
score = fuzz.QRatio(s1, s2, force_ascii=False)
self.assertLess(score, 100)
def testQuickRatioEqual(self):
self.assertEqual(fuzz.QRatio(self.s1, self.s1a), 100)
def testQuickRatioNotEqual(self):
self.assertNotEqual(fuzz.QRatio(self.s1, self.s3), 100)
"new york mets vs chicago cubs",
"chicago cubs at new york mets",
"atlanta braves vs pittsbugh pirates",
"new york yankees vs boston red sox"
]
choices_dict = {
1: "new york mets vs chicago cubs",
2: "chicago cubs vs chicago white sox",
3: "philladelphia phillies vs atlanta braves",
4: "braves vs mets"
}
# in this hypothetical example we care about ordering, so we use quick ratio
query = "new york mets at chicago cubs"
scorer = fuzz.QRatio
# first, as an example, the normal way would select the "more
# 'complete' match of choices[1]"
best = process.extractOne(query, choices)
self.assertEqual(best[0], choices[1])
# now, use the custom scorer
best = process.extractOne(query, choices, scorer=scorer)
self.assertEqual(best[0], choices[0])
best = process.extractOne(query, choices_dict)
self.assertEqual(best[0], choices_dict[1])
def column_name_match(col_name, list_of_words, match_threshold=55):
"""
Helper for matching column names to a list of words.
"""
return any((fuzz.QRatio(word, col_name.lower()) > match_threshold)
for word in list_of_words)
try:
await cmd_obj.get(ctx.message, term)
except:
pass
else:
return None
if commands is None:
choices = set(ctx.bot.walk_commands())
elif isinstance(commands, collections.abc.AsyncIterator):
choices = {c async for c in commands}
else:
choices = set(commands)
# Do the scoring. `extracted` is a list of tuples in the form `(command, score)`
extracted = process.extract(term, choices, limit=5, scorer=fuzz.QRatio)
if not extracted:
return None
# Filter through the fuzzy-matched commands.
matched_commands = []
for command, score in extracted:
if score < min_score:
# Since the list is in decreasing order of score, we can exit early.
break
if await command.can_see(ctx):
matched_commands.append(command)
return matched_commands
def fuzzy(s1, s2):
return [fuzz.ratio(s1, s2) / 100,
fuzz.partial_ratio(s1, s2) / 100,
fuzz.token_sort_ratio(s1, s2) / 100,
fuzz.partial_token_sort_ratio(s1, s2) / 100,
fuzz.token_set_ratio(s1, s2) / 100,
fuzz.partial_token_set_ratio(s1, s2) / 100,
fuzz.QRatio(s1, s2) / 100,
fuzz.WRatio(s1, s2) / 100]
"all comparisons will have score 0. "
"[Query: \'{0}\']".format(query))
# Don't run full_process twice
if scorer in [fuzz.WRatio, fuzz.QRatio,
fuzz.token_set_ratio, fuzz.token_sort_ratio,
fuzz.partial_token_set_ratio, fuzz.partial_token_sort_ratio,
fuzz.UWRatio, fuzz.UQRatio] \
and processor == utils.full_process:
processor = no_process
# Only process the query once instead of for every choice
if scorer in [fuzz.UWRatio, fuzz.UQRatio]:
pre_processor = partial(utils.full_process, force_ascii=False)
scorer = partial(scorer, full_process=False)
elif scorer in [fuzz.WRatio, fuzz.QRatio,
fuzz.token_set_ratio, fuzz.token_sort_ratio,
fuzz.partial_token_set_ratio, fuzz.partial_token_sort_ratio]:
pre_processor = partial(utils.full_process, force_ascii=True)
scorer = partial(scorer, full_process=False)
else:
pre_processor = no_process
processed_query = pre_processor(processed_query)
try:
# See if choices is a dictionary-like object.
for key, choice in choices.items():
processed = pre_processor(processor(choice))
score = scorer(processed_query, processed)
if score >= score_cutoff:
yield (choice, score, key)
except AttributeError: