hdx-python-utilities 4.1.2__tar.gz → 4.2.0__tar.gz

{hdx_python_utilities-4.1.2 → hdx_python_utilities-4.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: hdx-python-utilities
-Version: 4.1.2
+Version: 4.2.0
 Summary: HDX Python Utilities for streaming tabular data, date and time handling and other helpful functions
 Project-URL: Homepage, https://github.com/OCHA-DAP/hdx-python-utilities
 Author-email: Michael Rans <rans@email.com>
@@ -32,6 +32,7 @@ Requires-Dist: loguru
 Requires-Dist: openpyxl>=3.1.2
 Requires-Dist: pyphonetics
 Requires-Dist: python-dateutil<2.9.1,>=2.9.0
+Requires-Dist: rapidfuzz
 Requires-Dist: ratelimit
 Requires-Dist: requests-file
 Requires-Dist: ruamel-yaml

{hdx_python_utilities-4.1.2 → hdx_python_utilities-4.2.0}/documentation/index.md

@@ -33,6 +33,11 @@ The code for the library is [here](https://github.com/OCHA-DAP/hdx-python-utilit
 The library has detailed API documentation which can be found in the menu at the top.
 
 ## Breaking Changes
+From 4.2.0, get_code_from_name fuzzy matches using RapidFuzzMatcher rather than
+Phonetics by default. Pass matcher=Phonetics() for the previous behaviour. A name
+made of parts (eg. "Protection - GBV") is resolved from its parts, and a list of
+names (eg. "Wash & Protection") is not fuzzy matched.
+
 From 4.1.0, save_hxlated_output and Download.hxl_row removed. Parameter use_hxl removed
 from all calls in Download and Retrieve.
 
@@ -877,7 +882,19 @@ Efficient Hashing of files that produces a stable hash even for zip and xlsx fil
 
 Examples:
 
+    # Fuzzy match a name to one of a list of names using rapidfuzz scoring
     possible_names = ["Al Maharah", "Ad Dali", "Dhamar"]
+    matcher = RapidFuzzMatcher()
+    assert matcher.match(possible_names, "al dali") == 1
+
+    # place_name_scorer does not match place names that share a word but differ
+    # in another that distinguishes places
+    kalimantan = ["kalimantan utara", "kalimantan tengah"]
+    assert matcher.match(kalimantan, "central kalimantan") == 0
+    matcher = RapidFuzzMatcher(RapidFuzzMatcher.place_name_scorer)
+    assert matcher.match(kalimantan, "central kalimantan") is None
+
+    # Phonetics is an alternative matcher using Refined Soundex
     phonetics = Phonetics()
     assert phonetics.match(possible_names, "al dali") == 1
 
@@ -887,6 +904,22 @@ Examples:
     }
     assert get_code_from_name("NATIONAL_NGO", lookup, [], fuzzy_match=False) == "441"
 
+    # get_code_from_name fuzzy matches with RapidFuzzMatcher unless given
+    # another matcher. It resolves names made of parts and does not fuzzy
+    # match lists of names.
+    sector_lookup = {"food security": "FSC", "protection": "PRO", "gbv": "PRO-GBV", "wash": "WSH"}
+    assert get_code_from_name("Food Securty", sector_lookup, []) == "FSC"
+    assert get_code_from_name("Food Securty", sector_lookup, [], matcher=Phonetics()) == "FSC"
+    assert get_code_from_name("Protection - GBV", sector_lookup, []) == "PRO-GBV"
+    assert get_code_from_name("Wash & Protection", sector_lookup, []) is None
+
+    # Resolve a name made of parts, returning the code and whether it is a
+    # list of names. The third parameter is a part that qualifies the other,
+    # eg. a parent admin name.
+    admin_lookup = {"acosta": "VE1101", "falcon": "VE1109"}
+    assert resolve_name_parts("Falcón, Acosta", admin_lookup) == (None, True)
+    assert resolve_name_parts("Falcón, Acosta", admin_lookup, "falcon") == ("VE1101", False)
+
     a = "The quick brown fox jumped over the lazy dog. It was so fast!"
 
     # Replace multiple strings in a string simultaneously

{hdx_python_utilities-4.1.2 → hdx_python_utilities-4.2.0}/pyproject.toml

@@ -52,6 +52,7 @@ dependencies = [
     "typing_extensions",
     "loguru",
     "pyphonetics",
+    "rapidfuzz",
     "python-dateutil>=2.9.0, <2.9.1",
     "ratelimit",
     "requests-file",

{hdx_python_utilities-4.1.2 → hdx_python_utilities-4.2.0}/src/hdx/utilities/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '4.1.2'
-__version_tuple__ = version_tuple = (4, 1, 2)
+__version__ = version = '4.2.0'
+__version_tuple__ = version_tuple = (4, 2, 0)
 
 __commit_id__ = commit_id = None

{hdx_python_utilities-4.1.2 → hdx_python_utilities-4.2.0}/src/hdx/utilities/matching.py

@@ -3,10 +3,14 @@ import re
 from collections.abc import Callable, Sequence
 
 from pyphonetics import RefinedSoundex
+from rapidfuzz import fuzz as rapidfuzz_fuzz
 
 from hdx.utilities.text import normalise
 
 TEMPLATE_VARIABLES = re.compile("{{.*?}}")
+NON_WORD_CHARACTERS = re.compile(r"[\W_]+")
+LIST_SEPARATORS = re.compile(r"\s*(?:[,;/:&\n]|\s(?:and|et)\s)\s*", re.IGNORECASE)
+HYPHEN = re.compile(r"\s*-\s*")
 
 
 class Phonetics(RefinedSoundex):
@@ -58,15 +62,212 @@ class Phonetics(RefinedSoundex):
         return matching_index
 
 
+class RapidFuzzMatcher:
+    """
+    Default matcher for names, using rapidfuzz edit-distance scoring instead
+    of phonetic (Soundex-family) encoding as Phonetics does. Phonetic algorithms
+    encode English pronunciation rules, so they are a poor fit for matching
+    multilingual or transliterated names (eg. "Sana'a" vs "Sanaa") that are
+    spelling variants rather than being phonetically similar in English
+    terms. Edit distance on normalised strings tends to place such variants
+    closer together.
+
+    Args:
+        scorer: Function taking two strings and returning a similarity score
+            from 0-100. Defaults to default_scorer. Use place_name_scorer for
+            place names. Ties are broken by rapidfuzz.fuzz.ratio over the
+            whole strings.
+
+    Caveat: "<name> city" scores ~100 against "<name>", as for any name whose
+    words are a subset of the other's. So withholding a text replacement that
+    strips " city" does not stop "Kenge city" matching "Kenge".
+    """
+
+    def __init__(self, scorer: Callable[[str, str], float] | None = None) -> None:
+        self.scorer = scorer or self.default_scorer
+
+    @staticmethod
+    def default_scorer(name: str, possible_name: str) -> float:
+        """
+        Score two strings with token_set_ratio, or with ratio on the strings
+        with spaces and punctuation removed if that is at least 90 and higher.
+
+        Args:
+            name: Name to match
+            possible_name: Possible name
+
+        Returns:
+            Similarity score from 0-100
+        """
+        score = rapidfuzz_fuzz.token_set_ratio(name, possible_name)
+        joined_score = rapidfuzz_fuzz.ratio(
+            NON_WORD_CHARACTERS.sub("", name),
+            NON_WORD_CHARACTERS.sub("", possible_name),
+        )
+        if joined_score >= 90:
+            return max(score, joined_score)
+        return score
+
+    @staticmethod
+    def place_name_scorer(name: str, possible_name: str) -> float:
+        """
+        Score two strings with default_scorer, but score 0 if they share a
+        word, each has other words of 3+ characters, and one of the words on
+        the side with fewer has ratio < 60 to all those on the other side (eg.
+        "central kalimantan" vs "kalimantan utara", but not "central west" vs
+        "centre west"). Suits place names, where the differing word usually
+        distinguishes places, but not names like sectors, where extra words
+        are often descriptive (eg. "food security and livelihood").
+
+        Args:
+            name: Name to match
+            possible_name: Possible name
+
+        Returns:
+            Similarity score from 0-100
+        """
+        words = set(name.split())
+        possible_words = set(possible_name.split())
+
+        def long_words(words: set[str]) -> set[str]:
+            return {word for word in words if len(word) > 2}
+
+        extra_words = long_words(words - possible_words)
+        possible_extra_words = long_words(possible_words - words)
+        if words & possible_words and extra_words and possible_extra_words:
+            fewer, more = sorted((extra_words, possible_extra_words), key=len)
+            for word in fewer:
+                if max(rapidfuzz_fuzz.ratio(word, other) for other in more) < 60:
+                    return 0.0
+        return RapidFuzzMatcher.default_scorer(name, possible_name)
+
+    def match(
+        self,
+        possible_names: Sequence,
+        name: str,
+        alternative_name: str | None = None,
+        transform_possible_names: Sequence[Callable] = [],
+        threshold: float = 65.0,
+    ) -> int | None:
+        """
+        Match name to one of the given possible names. Returns None if no
+        match or the index of the matching name.
+
+        Args:
+            possible_names: Possible names
+            name: Name to match
+            alternative_name: Alternative name to match. Defaults to None.
+            transform_possible_names: Functions to transform possible names.
+            threshold: Minimum similarity score, 0-100. Defaults to 65.0.
+
+        Returns:
+            Index of matching name from possible names or None
+        """
+        maxscore = None
+        matching_index = None
+        names = [name.lower()]
+        if alternative_name:
+            names.append(alternative_name.lower())
+        all_transforms = (lambda x: x, *transform_possible_names)
+        for i, possible_name in enumerate(possible_names):
+            for transform_possible_name in all_transforms:
+                transformed_possible_name = transform_possible_name(possible_name)
+                if not transformed_possible_name:
+                    continue
+                transformed_possible_name = transformed_possible_name.lower()
+                for query in names:
+                    score = (
+                        self.scorer(query, transformed_possible_name),
+                        rapidfuzz_fuzz.ratio(query, transformed_possible_name),
+                    )
+                    if maxscore is None or score > maxscore:
+                        maxscore = score
+                        matching_index = i
+        if maxscore is None or maxscore[0] < threshold:
+            return None
+        return matching_index
+
+
+def split_name(name: str, separators: re.Pattern) -> list[str]:
+    """
+    Split name on separators, dropping parts that are empty once normalised.
+
+    Args:
+        name: Name to split
+        separators: Compiled regular expression matching separators
+
+    Returns:
+        List of parts
+    """
+    parts = [part.strip() for part in separators.split(name)]
+    return [part for part in parts if normalise(part)]
+
+
+def resolve_name_parts(
+    name: str, name_to_code: dict[str, str], ignore: str | None = None
+) -> tuple[str | None, bool]:
+    """
+    Resolve a name made of parts split by separators (",", ";", "/", ":", "&",
+    newline, "and", "et") or, if there are none, by a hyphen. Parts are looked
+    up in name_to_code. A name with two parts gives a code if:
+    - one part's normalised form equals ignore and the other part has a code
+      (eg. "Falcón, Acosta" with the parent admin name "falcon")
+    - one part's code followed by "-" starts the other's (eg. "Protection -
+      GBV" gives PRO-GBV)
+    - both parts have the same code.
+    It is a list of names (eg. "Wash & Protection") if it has more than two
+    parts, or two parts with different codes (eg. "Guba-Khachmaz").
+
+    Args:
+        name: Name to resolve
+        name_to_code: Mapping from names (raw or normalised) to codes
+        ignore: Normalised name of a part that qualifies the other part.
+            Defaults to None.
+
+    Returns:
+        Tuple of code (or None) and whether name is a list of names
+    """
+    parts = split_name(name, LIST_SEPARATORS)
+    if len(parts) > 2:
+        return None, True
+    if len(parts) < 2:
+        parts = split_name(name, HYPHEN)
+        if len(parts) != 2:
+            return None, False
+    normalised_parts = [normalise(part) for part in parts]
+    if ignore in normalised_parts:
+        index = 1 - normalised_parts.index(ignore)
+        parts = [parts[index]]
+        normalised_parts = [normalised_parts[index]]
+    codes = []
+    for part, normalised_part in zip(parts, normalised_parts):
+        code = name_to_code.get(part, name_to_code.get(normalised_part))
+        if not code:
+            return None, False
+        codes.append(code)
+    code = codes[0]
+    if len(codes) == 1:
+        return code, False
+    other_code = codes[1]
+    if code == other_code or other_code.startswith(f"{code}-"):
+        return other_code, False
+    if code.startswith(f"{other_code}-"):
+        return code, False
+    return None, True
+
+
 def get_code_from_name(
     name: str,
     code_lookup: dict[str, str],
     unmatched: list[str],
     fuzzy_match: bool = True,
     match_threshold: int = 5,
+    matcher: Phonetics | RapidFuzzMatcher | None = None,
 ) -> str | None:
     """
-    Given a name (org type, sector, etc), return the corresponding code.
+    Given a name (org type, sector, etc), return the corresponding code. A
+    name made of parts is resolved by resolve_name_parts, and is not fuzzy
+    matched if it is a list of names.
 
     Args:
         name: Name to match
@@ -74,6 +275,7 @@ def get_code_from_name(
         unmatched: List of unmatched names
         fuzzy_match: Allow fuzzy matching or not
         match_threshold: Match threshold
+        matcher: Fuzzy matcher to use. Defaults to None (RapidFuzzMatcher).
 
     Returns:
         Matching code
@@ -91,11 +293,17 @@ def get_code_from_name(
     if len(name) <= match_threshold:
         unmatched.append(name)
         return None
-    if not fuzzy_match:
+    code, is_list = resolve_name_parts(name, code_lookup)
+    if code:
+        code_lookup[name] = code
+        return code
+    if not fuzzy_match or is_list:
         unmatched.append(name)
         return None
     names = [x for x in code_lookup.keys() if len(x) > match_threshold]
-    name_index = Phonetics().match(
+    if matcher is None:
+        matcher = RapidFuzzMatcher()
+    name_index = matcher.match(
         possible_names=names,
         name=name,
         alternative_name=name_clean,

{hdx_python_utilities-4.1.2 → hdx_python_utilities-4.2.0}/tests/hdx/utilities/test_downloader.py

@@ -462,7 +462,7 @@ class TestDownloader:
         with Download() as downloader:
             text = downloader.download_text(fixtureurl)
             assert downloader.get_status() == 200
-            assert len(downloader.get_headers()) in (24, 25)
+            assert len(downloader.get_headers()) == 26
             assert (
                 bool(re.match(r"7\d\d", downloader.get_header("Content-Length")))
                 is True

{hdx_python_utilities-4.1.2 → hdx_python_utilities-4.2.0}/tests/hdx/utilities/test_matching.py

@@ -2,6 +2,7 @@
 
 from hdx.utilities.matching import (
     Phonetics,
+    RapidFuzzMatcher,
     earliest_index,
     get_code_from_name,
     get_matching_text,
@@ -9,6 +10,7 @@ from hdx.utilities.matching import (
     get_matching_then_nonmatching_text,
     match_template_variables,
     multiple_replace,
+    resolve_name_parts,
 )
 from hdx.utilities.text import normalise
 
@@ -29,6 +31,161 @@ class TestMatching:
             is None
         )
 
+    def test_rapidfuzz_matcher(self):
+        possible_names = ["Al Maharah", "Ad Dali", "Dhamar"]
+        matcher = RapidFuzzMatcher()
+        assert matcher.match(possible_names, "al dali") == 1
+        assert matcher.match(possible_names, "xxx", "Damar") == 2
+        transform_possible_names = [lambda x: None]
+        assert (
+            matcher.match(possible_names, "xxx", "yyy", transform_possible_names)
+            is None
+        )
+
+    def test_rapidfuzz_matcher_transliteration(self):
+        # UKR admin_name_mappings entries that Phonetics cannot match
+        possible_names = [
+            "Avtonomna Respublika Krym",
+            "Vinnytska",
+            "Volynska",
+            "Dnipropetrovska",
+            "Donetska",
+            "Zhytomyrska",
+            "Zakarpatska",
+            "Zaporizka",
+            "Ivano Frankivska",
+            "Kyivska",
+            "Kirovohradska",
+            "Luhanska",
+            "Lvivska",
+            "Mykolaivska",
+            "Odeska",
+            "Poltavska",
+            "Rivnenska",
+            "Sumska",
+            "Ternopilska",
+            "Kharkivska",
+            "Khersonska",
+            "Khmelnytska",
+            "Cherkaska",
+            "Chernivetska",
+            "Chernihivska",
+            "Sevastopol",
+        ]
+        replacements = {" oblast": ""}
+
+        def resolve(matcher, query):
+            normalised_query = normalise(query)
+            alt = multiple_replace(normalised_query, replacements)
+            index = matcher.match(
+                possible_names, normalised_query, alternative_name=alt
+            )
+            return possible_names[index] if index is not None else None
+
+        phonetics = Phonetics()
+        rapidfuzz_matcher = RapidFuzzMatcher()
+        for query, expected in (
+            ("Chernіvеtskaja Oblast", "Chernivetska"),
+            ("Luganskaja Oblast", "Luhanska"),
+            ("Rovenskaja Oblast", "Rivnenska"),
+            ("Sevastopol City", "Sevastopol"),
+            ("Zapоrіzskaja Oblast", "Zaporizka"),
+        ):
+            assert resolve(phonetics, query) is None
+            assert resolve(rapidfuzz_matcher, query) == expected
+
+        # A naming-scheme difference, not a spelling variant
+        assert resolve(phonetics, "Chernigovskaja Oblast") is None
+        assert resolve(rapidfuzz_matcher, "Chernigovskaja Oblast") != "Chernihivska"
+
+    def test_rapidfuzz_matcher_naming_scheme_mismatch(self):
+        # Unrelated names that only admin_name_mappings can resolve
+        phonetics = Phonetics()
+        rapidfuzz_matcher = RapidFuzzMatcher()
+        cases = (
+            (["Federal Capital Territory"], "Abuja"),  # NGA: informal vs formal name
+            (["Nando"], "Centre-Ouest"),  # BFA: region renamed
+            (["Avtonomna Respublika Krym"], "Crimea"),  # UKR: colloquial vs formal
+        )
+        for possible_names, query in cases:
+            assert phonetics.match(possible_names, normalise(query)) is None
+            assert rapidfuzz_matcher.match(possible_names, normalise(query)) is None
+
+    def test_rapidfuzz_matcher_extra_word_caveat(self):
+        # Phonetics rejects both; RapidFuzzMatcher accepts both
+        phonetics = Phonetics()
+        rapidfuzz_matcher = RapidFuzzMatcher()
+        for query in ("sevastopol city", "kenge city"):
+            name = query.split(" ")[0].capitalize()
+            assert phonetics.match([name], query) is None
+            assert rapidfuzz_matcher.match([name], query) == 0
+
+    def test_rapidfuzz_matcher_word_split(self):
+        # Admin names from pipeline inputs that differ from the COD name only
+        # in spacing/punctuation. token_set_ratio alone scores these < 65.
+        rapidfuzz_matcher = RapidFuzzMatcher()
+        for possible_names, query, expected in (
+            (["dawlat abad", "kaldar", "sharak e hayratan"], "dawlatabad", 0),
+            (["waghaz", "qara bagh", "jaghuri"], "qarabagh", 1),
+            (["pemagatshel", "paro", "punakha"], "pema gatshel", 0),
+            (["north east", "grande'anse", "artibonite"], "grande anse", 1),
+            (["west", "north east", "north west"], "nord ouest", 2),
+        ):
+            assert rapidfuzz_matcher.match(possible_names, query) == expected
+
+    def test_rapidfuzz_matcher_different_extra_words(self):
+        # Names sharing a word where each has another word the other lacks.
+        # default_scorer matches "central kalimantan" to "kalimantan utara"
+        # and "bas sassandra" to "haut sassandra".
+        rapidfuzz_matcher = RapidFuzzMatcher(RapidFuzzMatcher.place_name_scorer)
+        kalimantan = [
+            "kalimantan barat",
+            "kalimantan tengah",
+            "kalimantan selatan",
+            "kalimantan timur",
+            "kalimantan utara",
+        ]
+        for possible_names, query, expected in (
+            (kalimantan, "central kalimantan", None),
+            (kalimantan, "north kalimantan", None),
+            (["haut sassandra", "bas uele"], "bas sassandra", None),
+            (["centre east", "centre west"], "central west", 1),
+            (["hodh gharbi", "hodh chargui"], "hosh ech chargui", 1),
+            (["ad dali", "al maharah"], "al dali", 0),
+        ):
+            assert rapidfuzz_matcher.match(possible_names, query) == expected
+
+    def test_rapidfuzz_matcher_subset_tie_break(self):
+        # Haiti has both "West" and "North West" departments. For the
+        # translated alternative "north west", token_set_ratio scores "west",
+        # "north" and "north west" all at 100; fuzz.ratio breaks the tie.
+        possible_names = [
+            "west",
+            "south east",
+            "north",
+            "north east",
+            "artibonite",
+            "centre",
+            "south",
+            "grande'anse",
+            "north west",
+            "nippes",
+        ]
+        replacements = {"sud": "south", "ouest": "west", "est": "east", "nord": "north"}
+        rapidfuzz_matcher = RapidFuzzMatcher()
+
+        normalised_query = normalise("Nord-Ouest")
+        translated_query = multiple_replace(normalised_query, replacements)
+        assert translated_query == "north west"
+
+        index = rapidfuzz_matcher.match(possible_names, normalised_query)
+        assert possible_names[index] == "north west"
+
+        index = rapidfuzz_matcher.match(
+            possible_names, normalised_query, alternative_name=translated_query
+        )
+        assert possible_names[index] == "north west"
+
     def test_get_code_from_name_org_type(self):
         org_type_lookup = {
             "Academic / Research": "431",
@@ -172,6 +329,99 @@ class TestMatching:
             is None
         )
 
+    def test_resolve_name_parts(self):
+        sector_lookup = {
+            "food security": "FSC",
+            "nutrition": "NUT",
+            "protection": "PRO",
+            "gbv": "PRO-GBV",
+            "wash": "WSH",
+            "abris": "SHL",
+            "sante": "HEA",
+        }
+        for name, expected in (
+            ("Wash & Protection", (None, True)),
+            ("Santé/Nutrition", (None, True)),
+            ("Santé\nProtection", (None, True)),
+            ("developpement, paix, genre", (None, True)),
+            ("Protection - GBV", ("PRO-GBV", False)),
+            ("GBV/Protection", ("PRO-GBV", False)),
+            ("Wash - Wash", ("WSH", False)),
+            ("Food Security and Livelihood", (None, False)),
+            ("Abris et Non vivres", (None, False)),
+            ("Protection", (None, False)),
+        ):
+            assert resolve_name_parts(name, sector_lookup) == expected
+        falcon_lookup = {"acosta": "VE1101", "falcon": "VE1109"}
+        assert resolve_name_parts("Falcón, Acosta", falcon_lookup) == (None, True)
+        for name, expected in (
+            ("Falcón, Acosta", ("VE1101", False)),
+            ("Acosta, Falcón", ("VE1101", False)),
+            ("Falcón, Falcón", ("VE1109", False)),
+            ("Falcón, Acostta", (None, False)),
+        ):
+            assert resolve_name_parts(name, falcon_lookup, "falcon") == expected
+        aze_lookup = {"guba": "AZ30300001", "khachmaz": "AZ30200001"}
+        for name, expected in (
+            ("Guba-Khachmaz", (None, True)),
+            ("Guba - Khachmaz", (None, True)),
+            ("Guba-Khizi", (None, False)),
+        ):
+            assert resolve_name_parts(name, aze_lookup) == expected
+        assert resolve_name_parts("Mbanza-Ngungu", {"mbanza ngungu": "CD2013"}) == (
+            None,
+            False,
+        )
+
+    def test_get_code_from_name_list_of_names(self):
+        sector_lookup = {
+            "Food Security": "FSC",
+            "Nutrition": "NUT",
+            "Protection": "PRO",
+            "Emergency Shelter and NFI": "SHL",
+            "Health": "HEA",
+            "Gender Based Violence": "PRO-GBV",
+            "GBV": "PRO-GBV",
+        }
+        actual_sector_lookup = {normalise(k): v for k, v in sector_lookup.items()}
+        actual_sector_lookup.update(sector_lookup)
+        matcher = RapidFuzzMatcher()
+        for name, code in (
+            ("Protection - GBV", "PRO-GBV"),
+            ("GBV - Protection", "PRO-GBV"),
+            ("Health-Nutrition", None),
+            ("Nutrition, Protection", None),
+            ("Food Security and Livelihood", "FSC"),
+            ("Emergency Shelter and NFI", "SHL"),
+        ):
+            assert (
+                get_code_from_name(name, actual_sector_lookup, [], matcher=matcher)
+                == code
+            )
+
+    def test_get_code_from_name_rapidfuzz_matcher(self):
+        sector_lookup = {
+            "Emergency Shelter and NFI": "SHL",
+            "Camp Coordination / Management": "CCM",
+            "Education": "EDU",
+            "Health": "HEA",
+        }
+        actual_sector_lookup = {normalise(k): v for k, v in sector_lookup.items()}
+        org_type_lookup = {
+            "International NGO": "437",
+            "National NGO": "441",
+            "United Nations": "447",
+        }
+        actual_org_type_lookup = {normalise(k): v for k, v in org_type_lookup.items()}
+        matcher = RapidFuzzMatcher()
+        for name, lookup, expected in (
+            ("Educaton", actual_sector_lookup, "EDU"),
+            ("Healht", actual_sector_lookup, "HEA"),
+            # WRatio matches this to "International NGO"
+            ("COOPÉRATION_INTERNATIONALE", actual_org_type_lookup, None),
+        ):
+            assert get_code_from_name(name, lookup, [], matcher=matcher) == expected
+
     def test_multiple_replace(self):
         result = multiple_replace(
             self.a, {"quick": "slow", "fast": "slow", "lazy": "busy"}