X-Git-Url: https://git.openstreetmap.org./nominatim.git/blobdiff_plain/38c3ef3da0134eeafc99bc3f30ea4d310957d79a..c74904d075f8fb622350b73b3dbb03e4c0be4924:/nominatim/tokenizer/sanitizers/config.py diff --git a/nominatim/tokenizer/sanitizers/config.py b/nominatim/tokenizer/sanitizers/config.py index ecfcacbe..79396a75 100644 --- a/nominatim/tokenizer/sanitizers/config.py +++ b/nominatim/tokenizer/sanitizers/config.py @@ -7,30 +7,48 @@ """ Configuration for Sanitizers. """ +from typing import Sequence, Union, Optional, Pattern, Callable, Any, TYPE_CHECKING from collections import UserDict import re from nominatim.errors import UsageError -class SanitizerConfig(UserDict): - """ Dictionary with configuration options for a sanitizer. - - In addition to the usualy dictionary function, the class provides - accessors to standard sanatizer options that are used by many of the +# working around missing generics in Python < 3.8 +# See https://github.com/python/typing/issues/60#issuecomment-869757075 +if TYPE_CHECKING: + _BaseUserDict = UserDict[str, Any] +else: + _BaseUserDict = UserDict + +class SanitizerConfig(_BaseUserDict): + """ The `SanitizerConfig` class is a read-only dictionary + with configuration options for the sanitizer. + In addition to the usual dictionary functions, the class provides + accessors to standard sanitizer options that are used by many of the sanitizers. """ - def get_string_list(self, param, default=tuple()): + def get_string_list(self, param: str, default: Sequence[str] = tuple()) -> Sequence[str]: """ Extract a configuration parameter as a string list. - If the parameter value is a simple string, it is returned as a - one-item list. If the parameter value does not exist, the given - default is returned. If the parameter value is a list, it is checked - to contain only strings before being returned. + + Arguments: + param: Name of the configuration parameter. + default: Takes a tuple or list of strings which will + be returned if the parameter is missing in the + sanitizer configuration. + Note that if this default parameter is not + provided then an empty list is returned. + + Returns: + If the parameter value is a simple string, it is returned as a + one-item list. If the parameter value does not exist, the given + default is returned. If the parameter value is a list, it is + checked to contain only strings before being returned. """ values = self.data.get(param, None) if values is None: - return None if default is None else list(default) + return list(default) if isinstance(values, str): return [values] if values else [] @@ -44,16 +62,42 @@ class SanitizerConfig(UserDict): return values - def get_delimiter(self, default=',;'): - """ Return the 'delimiter' parameter in the configuration as a - compiled regular expression that can be used to split the names on the - delimiters. The regular expression makes sure that the resulting names - are stripped and that repeated delimiters - are ignored but it will still create empty fields on occasion. The - code needs to filter those. + def get_bool(self, param: str, default: Optional[bool] = None) -> bool: + """ Extract a configuration parameter as a boolean. + + Arguments: + param: Name of the configuration parameter. The parameter must + contain one of the yaml boolean values or an + UsageError will be raised. + default: Value to return, when the parameter is missing. + When set to `None`, the parameter must be defined. - The 'default' parameter defines the delimiter set to be used when - not explicitly configured. + Returns: + Boolean value of the given parameter. + """ + value = self.data.get(param, default) + + if not isinstance(value, bool): + raise UsageError(f"Parameter '{param}' must be a boolean value ('yes' or 'no').") + + return value + + + def get_delimiter(self, default: str = ',;') -> Pattern[str]: + """ Return the 'delimiters' parameter in the configuration as a + compiled regular expression that can be used to split strings on + these delimiters. + + Arguments: + default: Delimiters to be used when 'delimiters' parameter + is not explicitly configured. + + Returns: + A regular expression pattern which can be used to + split a string. The regular expression makes sure that the + resulting names are stripped and that repeated delimiters + are ignored. It may still create empty fields on occasion. The + code needs to filter those. """ delimiter_set = set(self.data.get('delimiters', default)) if not delimiter_set: @@ -62,21 +106,46 @@ class SanitizerConfig(UserDict): return re.compile('\\s*[{}]+\\s*'.format(''.join('\\' + d for d in delimiter_set))) - def get_filter_kind(self, *default): - """ Return a filter function for the name kind from the 'filter-kind' - config parameter. The filter functions takes a name item and returns - True when the item passes the filter. - - If the parameter is empty, the filter lets all items pass. If the - paramter is a string, it is interpreted as a single regular expression - that must match the full kind string. If the parameter is a list then - any of the regular expressions in the list must match to pass. + def get_filter(self, param: str, default: Union[str, Sequence[str]] = 'PASS_ALL' + ) -> Callable[[str], bool]: + """ Returns a filter function for the given parameter of the sanitizer + configuration. + + The value provided for the parameter in sanitizer configuration + should be a string or list of strings, where each string is a regular + expression. These regular expressions will later be used by the + filter function to filter strings. + + Arguments: + param: The parameter for which the filter function + will be created. + default: Defines the behaviour of filter function if + parameter is missing in the sanitizer configuration. + Takes a string(PASS_ALL or FAIL_ALL) or a list of strings. + Any other value of string or an empty list is not allowed, + and will raise a ValueError. If the value is PASS_ALL, the filter + function will let all strings to pass, if the value is FAIL_ALL, + filter function will let no strings to pass. + If value provided is a list of strings each string + is treated as a regular expression. In this case these regular + expressions will be used by the filter function. + By default allow filter function to let all strings pass. + + Returns: + A filter function that takes a target string as the argument and + returns True if it fully matches any of the regular expressions + otherwise returns False. """ - filters = self.get_string_list('filter-kind', default) + filters = self.get_string_list(param) or default - if not filters: + if filters == 'PASS_ALL': return lambda _: True + if filters == 'FAIL_ALL': + return lambda _: False - regexes = [re.compile(regex) for regex in filters] + if filters and isinstance(filters, (list, tuple)): + regexes = [re.compile(regex) for regex in filters] + return lambda target: any(regex.fullmatch(target) for regex in regexes) - return lambda name: any(regex.fullmatch(name.kind) for regex in regexes) + raise ValueError("Default parameter must be a non-empty list or a string value \ + ('PASS_ALL' or 'FAIL_ALL').")