279 lines
9.5 KiB
Python
279 lines
9.5 KiB
Python
from tests.compat import unittest
|
|
from tests.test_levenshtein import TestFindNearMatchesLevenshteinBase
|
|
from fuzzysearch.common import Match, get_best_match_in_group, group_matches
|
|
from tests.test_substitutions_only import TestSubstitionsOnlyBase, \
|
|
TestHasNearMatchSubstitionsOnly
|
|
from fuzzysearch.generic_search import \
|
|
_find_near_matches_generic_linear_programming as fnm_generic_lp, \
|
|
find_near_matches_generic_ngrams as fnm_generic_ngrams, \
|
|
has_near_match_generic_ngrams as hnm_generic_ngrams, \
|
|
find_near_matches_generic
|
|
|
|
|
|
class TestGenericSearchLpAsLevenshtein(TestFindNearMatchesLevenshteinBase,
|
|
unittest.TestCase):
|
|
def search(self, subsequence, sequence, max_l_dist):
|
|
return [
|
|
get_best_match_in_group(group)
|
|
for group in group_matches(
|
|
fnm_generic_lp(subsequence, sequence, max_l_dist,
|
|
max_l_dist, max_l_dist, max_l_dist)
|
|
)
|
|
]
|
|
|
|
|
|
class TestGenericSearchNgramsAsLevenshtein(TestFindNearMatchesLevenshteinBase,
|
|
unittest.TestCase):
|
|
def search(self, subsequence, sequence, max_l_dist):
|
|
return fnm_generic_ngrams(subsequence, sequence, max_l_dist,
|
|
max_l_dist, max_l_dist, max_l_dist)
|
|
|
|
|
|
class TestGenericSearchLpAsSubstitutionsOnly(TestSubstitionsOnlyBase,
|
|
unittest.TestCase):
|
|
def search(self, subsequence, sequence, max_subs):
|
|
return list(
|
|
fnm_generic_lp(subsequence, sequence, max_subs, 0, 0, max_subs)
|
|
)
|
|
|
|
|
|
class TestGenericSearchNgramsAsSubstitutionsOnly(TestSubstitionsOnlyBase,
|
|
unittest.TestCase):
|
|
def search(self, subsequence, sequence, max_subs):
|
|
return fnm_generic_ngrams(subsequence, sequence,
|
|
max_subs, 0, 0, max_subs)
|
|
|
|
@unittest.skip("Ngrams search doesn't return overlapping matches")
|
|
def test_double_first_item(self):
|
|
return super(TestGenericSearchNgramsAsSubstitutionsOnly,
|
|
self).test_double_first_item()
|
|
|
|
|
|
class TestGenericSearchBase(object):
|
|
def search(self, pattern, sequence, max_subs, max_ins, max_dels,
|
|
max_l_dist=None):
|
|
raise NotImplementedError
|
|
|
|
def expectedOutcomes(self, search_result, expected_outcomes):
|
|
raise NotImplementedError
|
|
|
|
def test_empty_sequence(self):
|
|
self.assertEqual(self.search('PATTERN', '', 0, 0, 0, 0), [])
|
|
|
|
def test_empty_subsequence_exeption(self):
|
|
with self.assertRaises(ValueError):
|
|
self.search('', 'TEXT', 0, 0, 0, 0)
|
|
|
|
def test_match_identical_sequence(self):
|
|
self.assertEqual(
|
|
self.search('PATTERN', 'PATTERN', 0, 0, 0, 0),
|
|
[Match(start=0, end=7, dist=0)],
|
|
)
|
|
|
|
def test_substring(self):
|
|
substring = 'PATTERN'
|
|
text = 'aaaaaaaaaaPATTERNaaaaaaaaa'
|
|
expected_match = Match(start=10, end=17, dist=0)
|
|
|
|
self.assertEqual(
|
|
self.search(substring, text, 0, 0, 0, 0),
|
|
[expected_match],
|
|
)
|
|
|
|
def test_double_first_item(self):
|
|
# sequence = 'abcdefg'
|
|
# pattern = 'bde'
|
|
|
|
self.expectedOutcomes(
|
|
self.search('def', 'abcddefg', 0, 0, 0, 0),
|
|
[Match(start=4, end=7, dist=0)],
|
|
)
|
|
|
|
self.expectedOutcomes(
|
|
self.search('def', 'abcddefg', 1, 0, 0, 1),
|
|
[Match(start=4, end=7, dist=0)],
|
|
)
|
|
|
|
self.expectedOutcomes(
|
|
self.search('def', 'abcddefg', 0, 0, 1, 1),
|
|
[Match(start=4, end=7, dist=0),
|
|
Match(start=5, end=7, dist=1)]
|
|
)
|
|
|
|
self.expectedOutcomes(
|
|
self.search('def', 'abcddefg', 0, 1, 0, 1),
|
|
[Match(start=3, end=7, dist=1),
|
|
Match(start=4, end=7, dist=0)],
|
|
)
|
|
|
|
def test_missing_second_item(self):
|
|
# sequence = 'abcdefg'
|
|
# pattern = 'bde'
|
|
|
|
self.assertEqual(
|
|
self.search('bde', 'abcdefg', 0, 1, 0, 1),
|
|
[Match(start=1, end=5, dist=1)],
|
|
)
|
|
|
|
self.assertEqual(
|
|
self.search('bde', 'abcdefg', 0, 0, 0, 0),
|
|
[],
|
|
)
|
|
|
|
self.assertEqual(
|
|
self.search('bde', 'abcdefg', 1, 0, 0, 1),
|
|
[Match(start=2, end=5, dist=1)],
|
|
)
|
|
|
|
self.assertEqual(
|
|
self.search('bde', 'abcdefg', 0, 0, 1, 1),
|
|
[Match(start=3, end=5, dist=1)],
|
|
)
|
|
|
|
|
|
class TestGenericSearch(TestGenericSearchBase, unittest.TestCase):
|
|
def search(self, pattern, sequence, max_subs, max_ins, max_dels,
|
|
max_l_dist=None):
|
|
return list(find_near_matches_generic(pattern, sequence,
|
|
max_subs, max_ins,
|
|
max_dels, max_l_dist))
|
|
|
|
def expectedOutcomes(self, search_result, expected_outcomes):
|
|
return search_result == expected_outcomes
|
|
|
|
def test_valid_none_arguments(self):
|
|
# check that no exception is raised when some values are None
|
|
self.assertEqual(
|
|
self.search('a', 'b', 0, None, None, 0),
|
|
[],
|
|
)
|
|
|
|
self.assertEqual(
|
|
self.search('a', 'b', None, 0, None, 0),
|
|
[],
|
|
)
|
|
|
|
self.assertEqual(
|
|
self.search('a', 'b', None, None, 0, 0),
|
|
[],
|
|
)
|
|
|
|
self.assertEqual(
|
|
self.search('a', 'b', 0, 0, None, 0),
|
|
[],
|
|
)
|
|
|
|
self.assertEqual(
|
|
self.search('a', 'b', 0, None, 0, 0),
|
|
[],
|
|
)
|
|
|
|
self.assertEqual(
|
|
self.search('a', 'b', None, 0, 0, 0),
|
|
[],
|
|
)
|
|
|
|
self.assertEqual(
|
|
self.search('a', 'b', None, None, None, 0),
|
|
[],
|
|
)
|
|
|
|
self.assertEqual(
|
|
self.search('a', 'b', 0, 0, 0, None),
|
|
[],
|
|
)
|
|
|
|
def test_invalid_none_arguments(self):
|
|
# check that an exception is raised when max_l_dist is None as well as
|
|
# at least one other limitation
|
|
with self.assertRaises(ValueError):
|
|
self.search('a', 'b', None, None, None, None)
|
|
|
|
|
|
class TestGenericSearchLp(TestGenericSearchBase, unittest.TestCase):
|
|
def search(self, pattern, sequence, max_subs, max_ins, max_dels,
|
|
max_l_dist=None):
|
|
return list(fnm_generic_lp(pattern, sequence,
|
|
max_subs, max_ins, max_dels, max_l_dist))
|
|
|
|
def expectedOutcomes(self, search_result, expected_outcomes, *args, **kw):
|
|
self.assertEqual(search_result, expected_outcomes, *args, **kw)
|
|
|
|
def test_double_first_item_two_results(self):
|
|
# sequence = 'abcdefg'
|
|
# pattern = 'bde'
|
|
self.expectedOutcomes(
|
|
self.search('def', 'abcddefg', 0, 1, 0, 1),
|
|
[Match(start=3, end=7, dist=1),
|
|
Match(start=4, end=7, dist=0)],
|
|
)
|
|
|
|
def test_missing_second_item_complex(self):
|
|
self.expectedOutcomes(
|
|
self.search('bde', 'abcdefg', 1, 1, 1, 1),
|
|
[Match(start=1, end=5, dist=1),
|
|
Match(start=2, end=5, dist=1),
|
|
Match(start=3, end=5, dist=1)],
|
|
)
|
|
|
|
self.assertTrue(
|
|
set([
|
|
Match(start=1, end=5, dist=1),
|
|
Match(start=2, end=5, dist=1),
|
|
Match(start=3, end=5, dist=1),
|
|
Match(start=2, end=5, dist=3),
|
|
]).issubset(set(
|
|
self.search('bde', 'abcdefg', 1, 1, 1, 3),
|
|
))
|
|
)
|
|
|
|
class TestGenericSearchNgrams(TestGenericSearchBase, unittest.TestCase):
|
|
def search(self, pattern, sequence, max_subs, max_ins, max_dels,
|
|
max_l_dist=None):
|
|
return fnm_generic_ngrams(pattern, sequence,
|
|
max_subs, max_ins, max_dels, max_l_dist)
|
|
|
|
def expectedOutcomes(self, search_result, expected_outcomes):
|
|
best_from_groups = [
|
|
get_best_match_in_group(group)
|
|
for group in group_matches(search_result)
|
|
]
|
|
return search_result == best_from_groups
|
|
|
|
def test_missing_second_item_complex(self):
|
|
self.assertTrue(
|
|
set(self.search('bde', 'abcdefg', 1, 1, 1, 1)).issubset([
|
|
Match(start=1, end=5, dist=1),
|
|
Match(start=2, end=5, dist=1),
|
|
Match(start=3, end=5, dist=1),
|
|
])
|
|
)
|
|
|
|
|
|
class TestHasNearMatchGenericNgramsAsSubstitutionsOnly(
|
|
TestHasNearMatchSubstitionsOnly,
|
|
):
|
|
def search(self, subsequence, sequence, max_subs):
|
|
return hnm_generic_ngrams(subsequence, sequence,
|
|
max_subs, 0, 0, max_subs)
|
|
|
|
|
|
class TestHasNearMatchGenericNgrams(TestGenericSearchBase, unittest.TestCase):
|
|
def search(self, pattern, sequence, max_subs, max_ins, max_dels,
|
|
max_l_dist=None):
|
|
return hnm_generic_ngrams(pattern, sequence,
|
|
max_subs, max_ins, max_dels, max_l_dist)
|
|
|
|
def expectedOutcomes(self, search_result, expected_outcomes, *args, **kw):
|
|
self.assertEqual(search_result, bool(expected_outcomes), *args, **kw)
|
|
|
|
def assertEqual(self, actual_value, expected_value, *args, **kw):
|
|
return super(TestHasNearMatchGenericNgrams, self).assertEqual(
|
|
actual_value, bool(expected_value), *args, **kw)
|
|
|
|
def test_missing_second_item_complex(self):
|
|
# skip this because ngrams search requires that the subsequence's
|
|
# length is greater than the maximum Levenshtein distance
|
|
# self.assertTrue(self.search('bde', 'abcdefg', 1, 1, 1, 3))
|
|
pass
|