def METHOD_NAME(callables: List[str], patch_func: PatchFunction) -> None:
    """Patch the given list of callables.
    Parameters
    ----------
    callables : List[str]
        Patch all of these callables (functions or methods).
    patch_func : PatchFunction
        Called on every callable to patch it.
    Notes
    -----
    The callables list should look like:
    [
        "module.module.ClassName.method_name",
        "module.function_name"
        ...
    ]
    Nested classes and methods not allowed, but support could be added.
    An example patch_func is::
        import wrapt
        def _my_patcher(parent: CallableParent, callable: str, label: str):
            @wrapt.patch_function_wrapper(parent, callable)
            def my_announcer(wrapped, instance, args, kwargs):
                print(f"Announce {label}")
                return wrapped(*args, **kwargs)
    """
    patched: Set[str] = set()
    for target_str in callables:
        if target_str in patched:
            # Ignore duplicated targets in the config file.
            print(f"Patcher: [WARN] skipping duplicate {target_str}")
            continue
        # Patch the target and note that we did.
        try:
            module, attribute_str = _import_module(target_str)
            if module is not None and attribute_str is not None:
                _patch_attribute(module, attribute_str, patch_func)
        except PatchError as exc:
            # We don't stop on error because if you switch around branches
            # but keep the same config file, it's easy for your config
            # file to contain targets that aren't in the code.
            print(f"Patcher: [ERROR] {exc}")
        patched.add(target_str)