]> git.openstreetmap.org Git - nominatim.git/blob - src/nominatim_db/data/postcode_format.py
Update lookup.py - Correct spelling for "simultaneously"
[nominatim.git] / 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)