]> git.openstreetmap.org Git - nominatim.git/blob - nominatim/tools/special_phrases.py
fd46a18d827810aaf11a380a9cee659d3187a3fb
[nominatim.git] / nominatim / tools / special_phrases.py
1 """
2     Functions to import special phrases into the database.
3 """
4 import logging
5 import os
6 from pathlib import Path
7 import re
8 import subprocess
9 import json
10 from os.path import isfile
11 from icu import Transliterator
12 from psycopg2.sql import Identifier, Literal, SQL
13 from nominatim.tools.exec_utils import get_url
14 from nominatim.errors import UsageError
15
16 LOG = logging.getLogger()
17 class SpecialPhrasesImporter():
18     # pylint: disable-msg=too-many-instance-attributes
19     # pylint: disable-msg=too-few-public-methods
20     """
21         Class handling the process of special phrases importations.
22     """
23     def __init__(self, config, phplib_dir, db_connection) -> None:
24         self.db_connection = db_connection
25         self.config = config
26         self.phplib_dir = phplib_dir
27         self.black_list, self.white_list = self._load_white_and_black_lists()
28         #Compile the regex here to increase performances.
29         self.occurence_pattern = re.compile(
30             r'\| ([^\|]+) \|\| ([^\|]+) \|\| ([^\|]+) \|\| ([^\|]+) \|\| ([\-YN])'
31         )
32         self.sanity_check_pattern = re.compile(r'^\w+$')
33         self.transliterator = Transliterator.createFromRules("special-phrases normalizer",
34                                                              self.config.TERM_NORMALIZATION)
35
36     def import_from_wiki(self, languages=None):
37         """
38             Iterate through all specified languages and
39             extract corresponding special phrases from the wiki.
40         """
41         if languages is not None and not isinstance(languages, list):
42             raise TypeError('The \'languages\' argument should be of type list.')
43
44         #Get all languages to process.
45         languages = self._load_languages() if not languages else languages
46
47         #Store pairs of class/type for further processing
48         class_type_pairs = set()
49
50         for lang in languages:
51             LOG.warning('Import phrases for lang: %s', lang)
52             wiki_page_xml_content = SpecialPhrasesImporter._get_wiki_content(lang)
53             class_type_pairs.update(self._process_xml_content(wiki_page_xml_content, lang))
54
55         self._create_place_classtype_table_and_indexes(class_type_pairs)
56         self.db_connection.commit()
57         LOG.warning('Import done.')
58
59     def _load_white_and_black_lists(self):
60         """
61             Load white and black lists from phrases-settings.json.
62         """
63         settings_path = (self.config.config_dir / 'phrase-settings.json').resolve()
64
65         if self.config.PHRASE_CONFIG:
66             settings_path = self._convert_php_settings_if_needed(self.config.PHRASE_CONFIG)
67
68         with open(settings_path, "r") as json_settings:
69             settings = json.load(json_settings)
70         return settings['blackList'], settings['whiteList']
71
72     def _load_languages(self):
73         """
74             Get list of all languages from env config file
75             or default if there is no languages configured.
76             The system will extract special phrases only from all specified languages.
77         """
78         default_languages = [
79             'af', 'ar', 'br', 'ca', 'cs', 'de', 'en', 'es',
80             'et', 'eu', 'fa', 'fi', 'fr', 'gl', 'hr', 'hu',
81             'ia', 'is', 'it', 'ja', 'mk', 'nl', 'no', 'pl',
82             'ps', 'pt', 'ru', 'sk', 'sl', 'sv', 'uk', 'vi']
83         return self.config.LANGUAGES or default_languages
84
85     @staticmethod
86     def _get_wiki_content(lang):
87         """
88             Request and return the wiki page's content
89             corresponding to special phrases for a given lang.
90             Requested URL Example :
91                 https://wiki.openstreetmap.org/wiki/Special:Export/Nominatim/Special_Phrases/EN
92         """
93         url = 'https://wiki.openstreetmap.org/wiki/Special:Export/Nominatim/Special_Phrases/' + lang.upper() # pylint: disable=line-too-long
94         return get_url(url)
95
96     def _check_sanity(self, lang, phrase_class, phrase_type):
97         """
98             Check sanity of given inputs in case somebody added garbage in the wiki.
99             If a bad class/type is detected the system will exit with an error.
100         """
101         type_matchs = self.sanity_check_pattern.findall(phrase_type)
102         class_matchs = self.sanity_check_pattern.findall(phrase_class)
103
104         if len(class_matchs) < 1 or len(type_matchs) < 1:
105             raise UsageError("Bad class/type for language {}: {}={}".format(
106                 lang, phrase_class, phrase_type))
107
108     def _process_xml_content(self, xml_content, lang):
109         """
110             Process given xml content by extracting matching patterns.
111             Matching patterns are processed there and returned in a
112             set of class/type pairs.
113         """
114         #One match will be of format [label, class, type, operator, plural]
115         matches = self.occurence_pattern.findall(xml_content)
116         #Store pairs of class/type for further processing
117         class_type_pairs = set()
118
119         for match in matches:
120             phrase_label = match[0].strip()
121             normalized_label = self.transliterator.transliterate(phrase_label)
122             phrase_class = match[1].strip()
123             phrase_type = match[2].strip()
124             phrase_operator = match[3].strip()
125             #hack around a bug where building=yes was imported with quotes into the wiki
126             phrase_type = re.sub(r'\"|&quot;', '', phrase_type)
127
128             #sanity check, in case somebody added garbage in the wiki
129             self._check_sanity(lang, phrase_class, phrase_type)
130
131             #blacklisting: disallow certain class/type combinations
132             if (
133                     phrase_class in self.black_list.keys() and
134                     phrase_type in self.black_list[phrase_class]
135             ):
136                 continue
137             #whitelisting: if class is in whitelist, allow only tags in the list
138             if (
139                     phrase_class in self.white_list.keys() and
140                     phrase_type not in self.white_list[phrase_class]
141             ):
142                 continue
143
144             #add class/type to the pairs dict
145             class_type_pairs.add((phrase_class, phrase_type))
146
147             self._process_amenity(
148                 phrase_label, normalized_label, phrase_class,
149                 phrase_type, phrase_operator
150             )
151
152         return class_type_pairs
153
154     def _process_amenity(self, phrase_label, normalized_label,
155                          phrase_class, phrase_type, phrase_operator):
156         # pylint: disable-msg=too-many-arguments
157         """
158             Add phrase lookup and corresponding class and
159             type to the word table based on the operator.
160         """
161         with self.db_connection.cursor() as db_cursor:
162             if phrase_operator == 'near':
163                 db_cursor.execute("""SELECT getorcreate_amenityoperator(
164                                   make_standard_name(%s), %s, %s, %s, 'near')""",
165                                   (phrase_label, normalized_label, phrase_class, phrase_type))
166             elif phrase_operator == 'in':
167                 db_cursor.execute("""SELECT getorcreate_amenityoperator(
168                                   make_standard_name(%s), %s, %s, %s, 'in')""",
169                                   (phrase_label, normalized_label, phrase_class, phrase_type))
170             else:
171                 db_cursor.execute("""SELECT getorcreate_amenity(
172                                   make_standard_name(%s), %s, %s, %s)""",
173                                   (phrase_label, normalized_label, phrase_class, phrase_type))
174
175
176     def _create_place_classtype_table_and_indexes(self, class_type_pairs):
177         """
178             Create table place_classtype for each given pair.
179             Also create indexes on place_id and centroid.
180         """
181         LOG.warning('Create tables and indexes...')
182
183         sql_tablespace = self.config.TABLESPACE_AUX_DATA
184         if sql_tablespace:
185             sql_tablespace = ' TABLESPACE '+sql_tablespace
186
187         with self.db_connection.cursor() as db_cursor:
188             db_cursor.execute("CREATE INDEX idx_placex_classtype ON placex (class, type)")
189
190         for pair in class_type_pairs:
191             phrase_class = pair[0]
192             phrase_type = pair[1]
193
194             #Table creation
195             self._create_place_classtype_table(sql_tablespace, phrase_class, phrase_type)
196
197             #Indexes creation
198             self._create_place_classtype_indexes(sql_tablespace, phrase_class, phrase_type)
199
200             #Grant access on read to the web user.
201             self._grant_access_to_webuser(phrase_class, phrase_type)
202
203         with self.db_connection.cursor() as db_cursor:
204             db_cursor.execute("DROP INDEX idx_placex_classtype")
205
206
207     def _create_place_classtype_table(self, sql_tablespace, phrase_class, phrase_type):
208         """
209             Create table place_classtype of the given phrase_class/phrase_type if doesn't exit.
210         """
211         table_name = 'place_classtype_{}_{}'.format(phrase_class, phrase_type)
212         with self.db_connection.cursor() as db_cursor:
213             db_cursor.execute(SQL("""
214                     CREATE TABLE IF NOT EXISTS {{}} {} 
215                     AS SELECT place_id AS place_id,st_centroid(geometry) AS centroid FROM placex 
216                     WHERE class = {{}} AND type = {{}}""".format(sql_tablespace))
217                               .format(Identifier(table_name), Literal(phrase_class),
218                                       Literal(phrase_type)))
219
220
221     def _create_place_classtype_indexes(self, sql_tablespace, phrase_class, phrase_type):
222         """
223             Create indexes on centroid and place_id for the place_classtype table.
224         """
225         index_prefix = 'idx_place_classtype_{}_{}_'.format(phrase_class, phrase_type)
226         base_table = 'place_classtype_{}_{}'.format(phrase_class, phrase_type)
227         #Index on centroid
228         if not self.db_connection.index_exists(index_prefix + 'centroid'):
229             with self.db_connection.cursor() as db_cursor:
230                 db_cursor.execute(SQL("""
231                     CREATE INDEX {{}} ON {{}} USING GIST (centroid) {}""".format(sql_tablespace))
232                                   .format(Identifier(index_prefix + 'centroid'),
233                                           Identifier(base_table)), sql_tablespace)
234
235         #Index on place_id
236         if not self.db_connection.index_exists(index_prefix + 'place_id'):
237             with self.db_connection.cursor() as db_cursor:
238                 db_cursor.execute(SQL(
239                     """CREATE INDEX {{}} ON {{}} USING btree(place_id) {}""".format(sql_tablespace))
240                                   .format(Identifier(index_prefix + 'place_id'),
241                                           Identifier(base_table)))
242
243
244     def _grant_access_to_webuser(self, phrase_class, phrase_type):
245         """
246             Grant access on read to the table place_classtype for the webuser.
247         """
248         table_name = 'place_classtype_{}_{}'.format(phrase_class, phrase_type)
249         with self.db_connection.cursor() as db_cursor:
250             db_cursor.execute(SQL("""GRANT SELECT ON {} TO {}""")
251                               .format(Identifier(table_name),
252                                       Identifier(self.config.DATABASE_WEBUSER)))
253
254     def _convert_php_settings_if_needed(self, file_path):
255         """
256             Convert php settings file of special phrases to json file if it is still in php format.
257         """
258         if not isfile(file_path):
259             raise UsageError(str(file_path) + ' is not a valid file.')
260
261         file, extension = os.path.splitext(file_path)
262         json_file_path = Path(file + '.json').resolve()
263
264         if extension not in('.php', '.json'):
265             raise UsageError('The custom NOMINATIM_PHRASE_CONFIG file has not a valid extension.')
266
267         if extension == '.php' and not isfile(json_file_path):
268             try:
269                 subprocess.run(['/usr/bin/env', 'php', '-Cq',
270                                 (self.phplib_dir / 'migration/PhraseSettingsToJson.php').resolve(),
271                                 file_path], check=True)
272                 LOG.warning('special_phrase configuration file has been converted to json.')
273                 return json_file_path
274             except subprocess.CalledProcessError:
275                 LOG.error('Error while converting %s to json.', file_path)
276                 raise
277         else:
278             return json_file_path