src/nominatim_db/data/postcode_format.py

   1 # SPDX-License-Identifier: GPL-3.0-or-later
   2 #
   3 # This file is part of Nominatim. (https://nominatim.org)
   4 #
   5 # Copyright (C) 2024 by the Nominatim developer community.
   6 # For a full list of authors see the git log.
   7 """
   8 Functions for formatting postcodes according to their country-specific
   9 format.
  10 """
  11 from typing import Any, Mapping, Optional, Set, Match
  12 import re
  13
  14 from ..errors import UsageError
  15 from . import country_info
  16
  17
  18 class CountryPostcodeMatcher:
  19     """ Matches and formats a postcode according to a format definition
  20         of the given country.
  21     """
  22     def __init__(self, country_code: str, config: Mapping[str, Any]) -> None:
  23         if 'pattern' not in config:
  24             raise UsageError("Field 'pattern' required for 'postcode' "
  25                              f"for country '{country_code}'")
  26
  27         pc_pattern = config['pattern'].replace('d', '[0-9]').replace('l', '[A-Z]')
  28
  29         self.norm_pattern = re.compile(f'\\s*(?:{country_code.upper()}[ -]?)?({pc_pattern})\\s*')
  30         self.pattern = re.compile(pc_pattern)
  31
  32         self.output = config.get('output', r'\g<0>')
  33
  34     def match(self, postcode: str) -> Optional[Match[str]]:
  35         """ Match the given postcode against the postcode pattern for this
  36             matcher. Returns a `re.Match` object if the match was successful
  37             and None otherwise.
  38         """
  39         # Upper-case, strip spaces and leading country code.
  40         normalized = self.norm_pattern.fullmatch(postcode.upper())
  41
  42         if normalized:
  43             return self.pattern.fullmatch(normalized.group(1))
  44
  45         return None
  46
  47     def normalize(self, match: Match[str]) -> str:
  48         """ Return the default format of the postcode for the given match.
  49             `match` must be a `re.Match` object previously returned by
  50             `match()`
  51         """
  52         return match.expand(self.output)
  53
  54
  55 class PostcodeFormatter:
  56     """ Container for different postcode formats of the world and
  57         access functions.
  58     """
  59     def __init__(self) -> None:
  60         # Objects without a country code can't have a postcode per definition.
  61         self.country_without_postcode: Set[Optional[str]] = {None}
  62         self.country_matcher = {}
  63         self.default_matcher = CountryPostcodeMatcher('', {'pattern': '.*'})
  64
  65         for ccode, prop in country_info.iterate('postcode'):
  66             if prop is False:
  67                 self.country_without_postcode.add(ccode)
  68             elif isinstance(prop, dict):
  69                 self.country_matcher[ccode] = CountryPostcodeMatcher(ccode, prop)
  70             else:
  71                 raise UsageError(f"Invalid entry 'postcode' for country '{ccode}'")
  72
  73     def set_default_pattern(self, pattern: str) -> None:
  74         """ Set the postcode match pattern to use, when a country does not
  75             have a specific pattern.
  76         """
  77         self.default_matcher = CountryPostcodeMatcher('', {'pattern': pattern})
  78
  79     def get_matcher(self, country_code: Optional[str]) -> Optional[CountryPostcodeMatcher]:
  80         """ Return the CountryPostcodeMatcher for the given country.
  81             Returns None if the country doesn't have a postcode and the
  82             default matcher if there is no specific matcher configured for
  83             the country.
  84         """
  85         if country_code in self.country_without_postcode:
  86             return None
  87
  88         assert country_code is not None
  89
  90         return self.country_matcher.get(country_code, self.default_matcher)
  91
  92     def match(self, country_code: Optional[str], postcode: str) -> Optional[Match[str]]:
  93         """ Match the given postcode against the postcode pattern for this
  94             matcher. Returns a `re.Match` object if the country has a pattern
  95             and the match was successful or None if the match failed.
  96         """
  97         if country_code in self.country_without_postcode:
  98             return None
  99
 100         assert country_code is not None
 101
 102         return self.country_matcher.get(country_code, self.default_matcher).match(postcode)
 103
 104     def normalize(self, country_code: str, match: Match[str]) -> str:
 105         """ Return the default format of the postcode for the given match.
 106             `match` must be a `re.Match` object previously returned by
 107             `match()`
 108         """
 109         return self.country_matcher.get(country_code, self.default_matcher).normalize(match)