def __init__(self) -> None:
    """Create an empty blacklist."""
    self._blacklist = set()

def configure(self, config: dict, json_key: str='blacklist') -> int:
    """Configure the blacklist.

        :param config: (dict) Configuration dictionary.
        :param json_key: (str) Key of the blacklist list in JSON files.
        :return: (int) Number of blacklisted URLs.

        """
    items = config.get(json_key, [])
    if isinstance(items, list) is False:
        raise TypeError(f"JSON key '{json_key}' must be a list.")
    out: set[str] = set()
    for it in items:
        if isinstance(it, str) is True and len(it) > 0:
            out.add(it)
            logging.info("Blacklisted entry '" + it + "'")
    self._blacklist = out
    return len(out)

def match(self, value: str) -> bool:
    """Return True if a blacklist entry is found inside the given string.

        This method is intended for headers like User-Agent.
        Each blacklist entry is a plain string token.
        Matching rule: substring search.

        :param value: (str) A string to test (example: a User-Agent header).
        :return: (bool) True if blacklisted, False otherwise.

        """
    if type(value) is not str:
        raise TypeError('Value must be a string.')
    for entry in self._blacklist:
        if entry in value:
            return True
    return False

def load(self, filepath: str, json_key: str='blacklist') -> int:
    """Load blacklist entries from a file.

        If filepath ends with '.json', entries are loaded from the given json_key.
        Otherwise, entries are loaded from a text file (one entry per line).

        :param filepath: (str) Path of the file.
        :param json_key: (str) Key of the blacklist list in JSON files.
        :raises: TypeError: filepath is not a string.
        :raises: IOError: file does not exist.
        :raises: ValueError: JSON content is invalid, or json_key is not a list.
        :return: (int) Number of loaded entries.

        """
    if type(filepath) is not str:
        raise TypeError('Blacklist filepath must be a string.')
    if os.path.exists(filepath) is False:
        raise IOError(f'Blacklist file {filepath} does not exist.')
    if filepath.lower().endswith('.json'):
        return self.__load_json(filepath, json_key)
    return self.__load_text(filepath)

def __load_text(self, filepath: str) -> int:
    items: set[str] = set()
    with open(filepath, 'r', encoding='utf-8') as fp:
        for line in fp:
            s = line.strip()
            if len(s) == 0 or s.startswith('#'):
                continue
            items.add(s)
    self._blacklist = items
    return len(items)

def __load_json(self, filepath: str, json_key: str) -> int:
    with open(filepath, 'r', encoding='utf-8') as fp:
        try:
            _full_data = json.load(fp)
        except json.JSONDecodeError as e:
            raise ValueError(f'Invalid JSON file: {filepath}') from e
    if 'WhakerPy' not in _full_data:
        raise KeyError(f"{filepath!r} is missing the required 'WhakerPy' section.")
    _section = _full_data['WhakerPy']
    if isinstance(_section, dict) is False:
        raise TypeError("JSON key 'WhakerPy' must be a dict.")
    return self.configure(_section)

def __contains__(self, item):
    """Return True if the given URL path exists in the blacklist."""
    return item in self._blacklist

def __str__(self):
    return str(self._blacklist)

def __repr__(self):
    return self.__class__.__name__ + ': ' + str(self._blacklist)