def additional_housenumbers_view_result(ctx: context.Context, relations: areas.Relations, request_uri: str) -> yattag.doc.Doc: """Expected request_uri: e.g. /osm/additional-housenumbers/budapest_11/view-result.""" tokens = request_uri.split("/") relation_name = tokens[-2] relation = relations.get_relation(relation_name) doc = yattag.doc.Doc() relation = relations.get_relation(relation_name) prefix = ctx.get_ini().get_uri_prefix() if not ctx.get_file_system().path_exists( relation.get_files().get_osm_streets_path()): doc.asis( webframe.handle_no_osm_streets(prefix, relation_name).getvalue()) elif not ctx.get_file_system().path_exists( relation.get_files().get_osm_housenumbers_path()): doc.asis( webframe.handle_no_osm_housenumbers(prefix, relation_name).getvalue()) elif not ctx.get_file_system().path_exists( relation.get_files().get_ref_housenumbers_path()): doc.asis( webframe.handle_no_ref_housenumbers(prefix, relation_name).getvalue()) else: doc = cache.get_additional_housenumbers_html(ctx, relation) return doc
def handle_main_filters_refmegye(relations: areas.Relations, refmegye_id: str, refmegye: str) -> yattag.doc.Doc: """Handles one refmegye in the filter part of the main wsgi page.""" doc = yattag.doc.Doc() name = relations.refmegye_get_name(refmegye) if not name: return doc with doc.tag("a", href="/osm/filter-for/refmegye/" + refmegye): doc.text(name) if refmegye_id and refmegye == refmegye_id: reftelepules_ids = relations.refmegye_get_reftelepules_ids(refmegye_id) if reftelepules_ids: names: List[yattag.doc.Doc] = [] for reftelepules_id in reftelepules_ids: name = relations.reftelepules_get_name(refmegye_id, reftelepules_id) name_doc = yattag.doc.Doc() href_format = "/osm/filter-for/refmegye/{}/reftelepules/{}" with name_doc.tag("a", href=href_format.format(refmegye, reftelepules_id)): name_doc.text(name) names.append(name_doc) doc.text(" (") for index, item in enumerate(names): if index: doc.text(", ") doc.asis(item.getvalue()) doc.text(")") return doc
def handle_main_filters_refcounty(relations: areas.Relations, refcounty_id: str, refcounty: str) -> yattag.doc.Doc: """Handles one refcounty in the filter part of the main wsgi page.""" doc = yattag.doc.Doc() name = relations.refcounty_get_name(refcounty) if not name: return doc prefix = config.Config.get_uri_prefix() with doc.tag("a", href=prefix + "/filter-for/refcounty/" + refcounty): doc.text(name) if refcounty_id and refcounty == refcounty_id: refsettlement_ids = relations.refcounty_get_refsettlement_ids( refcounty_id) if refsettlement_ids: names: List[yattag.doc.Doc] = [] for refsettlement_id in refsettlement_ids: name = relations.refsettlement_get_name( refcounty_id, refsettlement_id) name_doc = yattag.doc.Doc() href_format = prefix + "/filter-for/refcounty/{}/refsettlement/{}" with name_doc.tag("a", href=href_format.format( refcounty, refsettlement_id)): name_doc.text(name) names.append(name_doc) doc.text(" (") for index, item in enumerate(names): if index: doc.text(", ") doc.asis(item.getvalue()) doc.text(")") return doc
def update_missing_streets(relations: areas.Relations) -> None: """Update the relation's street coverage stats.""" logging.info("update_missing_streets: start") for relation_name in relations.get_active_names(): relation = relations.get_relation(relation_name) streets = relation.get_config().should_check_missing_streets() if streets == "no": continue relation.write_missing_streets() logging.info("update_missing_streets: end")
def update_ref_streets(relations: areas.Relations, config: configparser.ConfigParser) -> None: """Update the reference street list of all relations.""" for relation_name in relations.get_active_names(): logging.info("update_ref_housenumbers: start: %s", relation_name) relation = relations.get_relation(relation_name) reference = config.get('wsgi', 'reference_street').strip() streets = relation.get_config().should_check_missing_streets() if streets == "no": continue relation.write_ref_streets(reference) logging.info("update_ref_housenumbers: end: %s", relation_name)
def update_ref_streets(relations: areas.Relations) -> None: """Update the reference street list of all relations.""" for relation_name in relations.get_active_names(): logging.info("update_ref_streets: start: %s", relation_name) relation = relations.get_relation(relation_name) reference = util.Config.get_reference_street_path() streets = relation.get_config().should_check_missing_streets() if streets == "no": continue relation.write_ref_streets(reference) logging.info("update_ref_streets: end: %s", relation_name)
def is_complete_relation(relations: areas.Relations, relation_name: str) -> bool: """Does this relation have 100% house number coverage?""" assert relation_name in relations.get_names() relation = relations.get_relation(relation_name) if not os.path.exists( relation.get_files().get_housenumbers_percent_path()): return False percent = util.get_content( relation.get_files().get_housenumbers_percent_path()).decode("utf-8") return percent == "100.00"
def update_missing_streets(relations: areas.Relations, update: bool) -> None: """Update the relation's street coverage stats.""" info("update_missing_streets: start") for relation_name in relations.get_active_names(): relation = relations.get_relation(relation_name) if not update and os.path.exists(relation.get_files().get_streets_percent_path()): continue streets = relation.get_config().should_check_missing_streets() if streets == "no": continue relation.write_missing_streets() info("update_missing_streets: end")
def update_ref_streets(relations: areas.Relations, update: bool) -> None: """Update the reference street list of all relations.""" for relation_name in relations.get_active_names(): relation = relations.get_relation(relation_name) if not update and os.path.exists(relation.get_files().get_ref_streets_path()): continue reference = config.Config.get_reference_street_path() streets = relation.get_config().should_check_missing_streets() if streets == "no": continue info("update_ref_streets: start: %s", relation_name) relation.write_ref_streets(reference) info("update_ref_streets: end: %s", relation_name)
def missing_housenumbers_view_txt(relations: areas.Relations, request_uri: str) -> str: """Expected request_uri: e.g. /osm/missing-housenumbers/ormezo/view-result.txt.""" tokens = request_uri.split("/") relation_name = tokens[-2] relation = relations.get_relation(relation_name) relation.get_config().set_letter_suffix_style(util.LetterSuffixStyle.LOWER) output = "" if not os.path.exists(relation.get_files().get_osm_streets_path()): output += _("No existing streets") elif not os.path.exists(relation.get_files().get_osm_housenumbers_path()): output += _("No existing house numbers") elif not os.path.exists(relation.get_files().get_ref_housenumbers_path()): output += _("No reference house numbers") else: ongoing_streets, _ignore = relation.get_missing_housenumbers() table = [] for result in ongoing_streets: range_list = util.get_housenumber_ranges(result[1]) range_strings = [i.get_number() for i in range_list] # Street name, only_in_reference items. if not relation.get_config().get_street_is_even_odd(result[0]): result_sorted = sorted(range_strings, key=util.split_house_number) row = result[0] + "\t[" + ", ".join(result_sorted) + "]" else: elements = util.format_even_odd(range_list, doc=None) row = result[0] + "\t[" + "], [".join(elements) + "]" table.append(row) table.sort(key=locale.strxfrm) output += "\n".join(table) return output
def missing_streets_view_result(relations: areas.Relations, request_uri: str) -> yattag.doc.Doc: """Expected request_uri: e.g. /osm/missing-streets/budapest_11/view-result.""" tokens = request_uri.split("/") relation_name = tokens[-2] relation = relations.get_relation(relation_name) doc = yattag.doc.Doc() if not os.path.exists(relation.get_files().get_osm_streets_path()): with doc.tag("div", id="no-osm-streets"): doc.text(_("No existing streets: ")) with doc.tag("a", href="/osm/streets/" + relation_name + "/update-result"): doc.text(_("Call Overpass to create")) elif not os.path.exists(relation.get_files().get_ref_streets_path()): with doc.tag("div", id="no-ref-streets"): doc.text(_("No street list: ")) with doc.tag("a", href="/osm/missing-streets/" + relation_name + "/update-result"): doc.text(_("Create from reference")) else: ret = relation.write_missing_streets() todo_count, done_count, percent, streets = ret streets.sort(key=locale.strxfrm) table = [[util.html_escape(_("Street name"))]] for street in streets: table.append([util.html_escape(street)]) with doc.tag("p"): doc.text(_("OpenStreetMap is possibly missing the below {0} streets.").format(str(todo_count))) doc.text(_(" (existing: {0}, ready: {1}%).").format(str(done_count), str(percent))) doc.asis(util.html_table_from_list(table).getvalue()) return doc
def update_ref_housenumbers(ctx: context.Context, relations: areas.Relations, update: bool) -> None: """Update the reference housenumber list of all relations.""" for relation_name in relations.get_active_names(): relation = relations.get_relation(relation_name) if not update and os.path.exists( relation.get_files().get_ref_housenumbers_path()): continue references = ctx.get_ini().get_reference_housenumber_paths() streets = relation.get_config().should_check_missing_streets() if streets == "only": continue info("update_ref_housenumbers: start: %s", relation_name) relation.write_ref_housenumbers(references) info("update_ref_housenumbers: end: %s", relation_name)
def handle_invalid_refstreets(ctx: context.Context, relations: areas.Relations) -> yattag.doc.Doc: """Expected request_uri: e.g. /osm/housenumber-stats/hungary/invalid-relations.""" doc = yattag.doc.Doc() doc.asis(get_toolbar(ctx, relations).getvalue()) prefix = ctx.get_ini().get_uri_prefix() for relation in relations.get_relations(): if not ctx.get_file_system().path_exists( relation.get_files().get_osm_streets_path()): continue invalid_refstreets = relation.get_invalid_refstreets() osm_invalids, ref_invalids = invalid_refstreets key_invalids = relation.get_invalid_filter_keys() if not osm_invalids and not ref_invalids and not key_invalids: continue with doc.tag("h1"): relation_name = relation.get_name() with doc.tag("a", href=prefix + "/streets/" + relation_name + "/view-result"): doc.text(relation_name) doc.asis( util.invalid_refstreets_to_html(invalid_refstreets).getvalue()) doc.asis(util.invalid_filter_keys_to_html(key_invalids).getvalue()) doc.asis(get_footer().getvalue()) return doc
def get_request_uri(environ: Dict[str, Any], relations: areas.Relations) -> str: """Finds out the request URI.""" request_uri = cast(str, environ.get("PATH_INFO")) prefix = config.Config.get_uri_prefix() if request_uri: # Compatibility. if request_uri.startswith(prefix + "/suspicious-streets/"): request_uri = request_uri.replace('suspicious-streets', 'missing-housenumbers') elif request_uri.startswith(prefix + "/suspicious-relations/"): request_uri = request_uri.replace('suspicious-relations', 'missing-streets') # Performance: don't bother with relation aliases for non-relation requests. if not request_uri.startswith(prefix + "/streets/") \ and not request_uri.startswith(prefix + "/missing-streets/") \ and not request_uri.startswith(prefix + "/street-housenumbers/") \ and not request_uri.startswith(prefix + "/missing-housenumbers/"): return request_uri # Relation aliases. aliases = relations.get_aliases() tokens = request_uri.split("/") relation_name = tokens[-2] if relation_name in aliases: request_uri = request_uri.replace(relation_name, aliases[relation_name]) return request_uri
def handle_main_filters(relations: areas.Relations, refcounty_id: str) -> yattag.doc.Doc: """Handlers the filter part of the main wsgi page.""" items: List[yattag.doc.Doc] = [] doc = yattag.doc.Doc() prefix = config.Config.get_uri_prefix() with doc.tag("a", href=prefix + "/filter-for/incomplete"): doc.text(_("Hide complete areas")) items.append(doc) # Sorted set of refcounty values of all relations. for refcounty in sorted({ relation.get_config().get_refcounty() for relation in relations.get_relations() }): items.append( handle_main_filters_refcounty(relations, refcounty_id, refcounty)) doc = yattag.doc.Doc() with doc.tag("h1"): doc.text(_("Where to map?")) with doc.tag("p"): doc.text(_("Filters:") + " ") for index, item in enumerate(items): if index: doc.text(" ¦ ") doc.asis(item.getvalue()) return doc
def handle_missing_streets(relations: areas.Relations, request_uri: str) -> yattag.doc.Doc: """Expected request_uri: e.g. /osm/missing-streets/ujbuda/view-[result|query].""" tokens = request_uri.split("/") relation_name = tokens[-2] action = tokens[-1] relation = relations.get_relation(relation_name) osmrelation = relation.get_config().get_osmrelation() doc = yattag.doc.Doc() doc.asis( webframe.get_toolbar(relations, "missing-streets", relation_name, osmrelation).getvalue()) if action == "view-turbo": doc.asis(missing_streets_view_turbo(relations, request_uri).getvalue()) elif action == "view-query": with doc.tag("pre"): with relation.get_files().get_ref_streets_stream("r") as sock: doc.text(sock.read()) elif action == "update-result": doc.asis(missing_streets_update(relations, relation_name).getvalue()) else: # assume view-result doc.asis( missing_streets_view_result(relations, request_uri).getvalue()) date = ref_streets_last_modified(relation) doc.asis(webframe.get_footer(date).getvalue()) return doc
def additional_streets_view_txt(ctx: context.Context, relations: areas.Relations, request_uri: str, chkl: bool) -> Tuple[str, str]: """Expected request_uri: e.g. /osm/additional-streets/ujbuda/view-result.txt.""" tokens = request_uri.split("/") relation_name = tokens[-2] relation = relations.get_relation(relation_name) output = "" if not ctx.get_file_system().path_exists( relation.get_files().get_osm_streets_path()): output += tr("No existing streets") elif not ctx.get_file_system().path_exists( relation.get_files().get_ref_streets_path()): output += tr("No reference streets") else: streets = relation.get_additional_streets() lexical_sort_key = util.get_lexical_sort_key() streets.sort( key=lambda street: lexical_sort_key(street.get_osm_name())) for street in streets: if chkl: output += "[ ] {}\n".format(street.get_osm_name()) else: output += "{}\n".format(street.get_osm_name()) return output, relation_name
def handle_additional_streets(relations: areas.Relations, request_uri: str) -> yattag.doc.Doc: """Expected request_uri: e.g. /osm/additional-streets/ujbuda/view-[result|query].""" tokens = request_uri.split("/") relation_name = tokens[-2] action = tokens[-1] relation = relations.get_relation(relation_name) osmrelation = relation.get_config().get_osmrelation() doc = yattag.doc.Doc() doc.asis( webframe.get_toolbar(relations, "additional-streets", relation_name, osmrelation).getvalue()) if action == "view-turbo": doc.asis( wsgi_additional.additional_streets_view_turbo( relations, request_uri).getvalue()) else: # assume view-result doc.asis( wsgi_additional.additional_streets_view_result( relations, request_uri).getvalue()) date = streets_diff_last_modified(relation) doc.asis(webframe.get_footer(date).getvalue()) return doc
def handle_main(request_uri: str, relations: areas.Relations) -> yattag.doc.Doc: """Handles the main wsgi page. Also handles /osm/filter-for/* which filters for a condition.""" filter_for, refcounty = setup_main_filter_for(request_uri) doc = yattag.doc.Doc() doc.asis(webframe.get_toolbar(relations).getvalue()) doc.asis(handle_main_filters(relations, refcounty).getvalue()) table = [] table.append([ util.html_escape(_("Area")), util.html_escape(_("House number coverage")), util.html_escape(_("Existing house numbers")), util.html_escape(_("Street coverage")), util.html_escape(_("Existing streets")), util.html_escape(_("Area boundary")) ]) for relation_name in relations.get_names(): row = handle_main_relation(relations, filter_for, relation_name) if row: table.append(row) doc.asis(util.html_table_from_list(table).getvalue()) with doc.tag("p"): with doc.tag( "a", href="https://github.com/vmiklos/osm-gimmisn/tree/master/doc"): doc.text(_("Add new area")) doc.asis(webframe.get_footer().getvalue()) return doc
def handle_main_relation(relations: areas.Relations, filter_for: Callable[[bool, areas.Relation], bool], relation_name: str) -> List[yattag.doc.Doc]: """Handles one relation (one table row) on the main page.""" relation = relations.get_relation(relation_name) # If checking both streets and house numbers, then "is complete" refers to the street coverage # for "hide complete" purposes. complete = True streets = relation.get_config().should_check_missing_streets() row = [] # List[yattag.doc.Doc] row.append(util.html_escape(relation_name)) prefix = config.Config.get_uri_prefix() if streets != "only": cell, percent = handle_main_housenr_percent(relation) doc = yattag.doc.Doc() doc.asis(cell.getvalue()) row.append(doc) complete = float(percent) >= 100.0 date = get_housenumbers_last_modified(relation) doc = yattag.doc.Doc() href = prefix + "/street-housenumbers/" + relation_name + "/view-result" with doc.tag("a", href=href, title=_("updated") + " " + date): doc.text(_("existing house numbers")) row.append(doc) else: row.append(yattag.doc.Doc()) row.append(yattag.doc.Doc()) if streets != "no": cell, percent = handle_main_street_percent(relation) row.append(cell) complete = float(percent) >= 100.0 else: row.append(yattag.doc.Doc()) date = get_streets_last_modified(relation) doc = yattag.doc.Doc() with doc.tag("a", href=prefix + "/streets/" + relation_name + "/view-result", title=_("updated") + " " + date): doc.text(_("existing streets")) row.append(doc) doc = yattag.doc.Doc() with doc.tag("a", href="https://www.openstreetmap.org/relation/" + str(relation.get_config().get_osmrelation())): doc.text(_("area boundary")) row.append(doc) if not filter_for(complete, relation): row.clear() return row
def ref_housenumbers_last_modified(relations: areas.Relations, name: str) -> str: """Gets the update date for missing house numbers.""" relation = relations.get_relation(name) t_ref = get_timestamp(relation.get_files().get_ref_housenumbers_path()) t_housenumbers = get_timestamp( relation.get_files().get_osm_housenumbers_path()) return webframe.format_timestamp(max(t_ref, t_housenumbers))
def missing_streets_view_result(relations: areas.Relations, request_uri: str) -> yattag.doc.Doc: """Expected request_uri: e.g. /osm/missing-streets/budapest_11/view-result.""" tokens = request_uri.split("/") relation_name = tokens[-2] relation = relations.get_relation(relation_name) doc = yattag.doc.Doc() prefix = config.Config.get_uri_prefix() if not os.path.exists(relation.get_files().get_osm_streets_path()): doc.asis( webframe.handle_no_osm_streets(prefix, relation_name).getvalue()) return doc if not os.path.exists(relation.get_files().get_ref_streets_path()): doc.asis( webframe.handle_no_ref_streets(prefix, relation_name).getvalue()) return doc ret = relation.write_missing_streets() todo_count, done_count, percent, streets = ret streets.sort(key=locale.strxfrm) table = [[util.html_escape(_("Street name"))]] for street in streets: table.append([util.html_escape(street)]) with doc.tag("p"): doc.text( _("OpenStreetMap is possibly missing the below {0} streets."). format(str(todo_count))) doc.text( _(" (existing: {0}, ready: {1}).").format( str(done_count), util.format_percent(str(percent)))) doc.stag("br") with doc.tag("a", href=prefix + "/missing-streets/{}/view-turbo".format(relation_name)): doc.text( _("Overpass turbo query for streets with questionable names")) doc.stag("br") with doc.tag("a", href=prefix + "/missing-streets/" + relation_name + "/view-result.txt"): doc.text(_("Plain text format")) doc.stag("br") with doc.tag("a", href=prefix + "/missing-streets/" + relation_name + "/view-result.chkl"): doc.text(_("Checklist format")) doc.asis(util.html_table_from_list(table).getvalue()) doc.asis( util.invalid_refstreets_to_html( areas.get_invalid_refstreets(relation)).getvalue()) doc.asis( util.invalid_filter_keys_to_html( areas.get_invalid_filter_keys(relation)).getvalue()) return doc
def missing_streets_update(relations: areas.Relations, relation_name: str) -> yattag.doc.Doc: """Expected request_uri: e.g. /osm/missing-streets/ujbuda/update-result.""" reference = util.get_abspath(webframe.get_config().get('wsgi', 'reference_street').strip()) relation = relations.get_relation(relation_name) relation.write_ref_streets(reference) doc = yattag.doc.Doc() with doc.tag("div", id="update-success"): doc.text(_("Update successful.")) return doc
def missing_streets_update(ctx: context.Context, relations: areas.Relations, relation_name: str) -> yattag.doc.Doc: """Expected request_uri: e.g. /osm/missing-streets/ujbuda/update-result.""" relation = relations.get_relation(relation_name) relation.write_ref_streets(ctx.get_ini().get_reference_street_path()) doc = yattag.doc.Doc() with doc.tag("div", id="update-success"): doc.text(tr("Update successful.")) return doc
def update_osm_housenumbers(relations: areas.Relations) -> None: """Update the OSM housenumber list of all relations.""" for relation_name in relations.get_active_names(): logging.info("update_osm_housenumbers: start: %s", relation_name) retry = 0 while should_retry(retry): if retry > 0: logging.info("update_osm_housenumbers: try #%s", retry) retry += 1 try: overpass_sleep() relation = relations.get_relation(relation_name) query = relation.get_osm_housenumbers_query() relation.get_files().write_osm_housenumbers(overpass_query.overpass_query(query)) break except urllib.error.HTTPError as http_error: logging.info("update_osm_housenumbers: http error: %s", str(http_error)) logging.info("update_osm_housenumbers: end: %s", relation_name)
def missing_housenumbers_view_res(relations: areas.Relations, request_uri: str) -> yattag.doc.Doc: """Expected request_uri: e.g. /osm/missing-housenumbers/ormezo/view-result.""" tokens = request_uri.split("/") relation_name = tokens[-2] doc = yattag.doc.Doc() relation = relations.get_relation(relation_name) prefix = config.Config.get_uri_prefix() if not os.path.exists(relation.get_files().get_osm_streets_path()): with doc.tag("div", id="no-osm-streets"): doc.text(_("No existing streets: ")) link = prefix + "/streets/" + relation_name + "/update-result" doc.asis( util.gen_link(link, _("Call Overpass to create")).getvalue()) elif not os.path.exists(relation.get_files().get_osm_housenumbers_path()): with doc.tag("div", id="no-osm-housenumbers"): doc.text(_("No existing house numbers: ")) link = prefix + "/street-housenumbers/" + relation_name + "/update-result" doc.asis( util.gen_link(link, _("Call Overpass to create")).getvalue()) elif not os.path.exists(relation.get_files().get_ref_housenumbers_path()): with doc.tag("div", id="no-ref-housenumbers"): doc.text(_("No missing house numbers: ")) link = prefix + "/missing-housenumbers/" + relation_name + "/update-result" doc.asis( util.gen_link(link, _("Create from reference")).getvalue()) else: ret = relation.write_missing_housenumbers() todo_street_count, todo_count, done_count, percent, table = ret with doc.tag("p"): doc.text( _("OpenStreetMap is possibly missing the below {0} house numbers for {1} streets." ).format(str(todo_count), str(todo_street_count))) doc.text( _(" (existing: {0}, ready: {1}%).").format( str(done_count), str(percent))) doc.stag("br") with doc.tag( "a", href= "https://github.com/vmiklos/osm-gimmisn/tree/master/doc"): doc.text(_("Filter incorrect information")) doc.text(".") doc.stag("br") with doc.tag( "a", href=prefix + "/missing-housenumbers/{}/view-turbo".format(relation_name) ): doc.text(_("Overpass turbo query for the below streets")) doc.text(".") doc.asis(util.html_table_from_list(table).getvalue()) return doc
def missing_streets_update_result_json(relations: areas.Relations, request_uri: str) -> str: """Expected request_uri: e.g. /osm/missing-streets/ormezo/update-result.json.""" tokens = request_uri.split("/") relation_name = tokens[-2] reference = config.Config.get_reference_street_path() relation = relations.get_relation(relation_name) ret: Dict[str, str] = {} relation.write_ref_streets(reference) ret["error"] = "" return json.dumps(ret)
def missing_housenumbers_update(relations: areas.Relations, relation_name: str) -> yattag.doc.Doc: """Expected request_uri: e.g. /osm/missing-housenumbers/ormezo/update-result.""" reference = webframe.get_config().get('wsgi', 'reference_housenumbers').strip().split(' ') reference = [util.get_abspath(i) for i in reference] relation = relations.get_relation(relation_name) relation.write_ref_housenumbers(reference) doc = yattag.doc.Doc() doc.text(_("Update successful: ")) link = "/osm/missing-housenumbers/" + relation_name + "/view-result" doc.asis(util.gen_link(link, _("View missing house numbers")).getvalue()) return doc
def update_osm_housenumbers(relations: areas.Relations, update: bool) -> None: """Update the OSM housenumber list of all relations.""" for relation_name in relations.get_active_names(): relation = relations.get_relation(relation_name) if not update and os.path.exists(relation.get_files().get_osm_housenumbers_path()): continue info("update_osm_housenumbers: start: %s", relation_name) retry = 0 while should_retry(retry): if retry > 0: info("update_osm_housenumbers: try #%s", retry) retry += 1 try: overpass_sleep() query = relation.get_osm_housenumbers_query() relation.get_files().write_osm_housenumbers(overpass_query.overpass_query(query)) break except urllib.error.HTTPError as http_error: info("update_osm_housenumbers: http error: %s", str(http_error)) info("update_osm_housenumbers: end: %s", relation_name)
def update_missing_housenumbers(relations: areas.Relations, update: bool) -> None: """Update the relation's house number coverage stats.""" info("update_missing_housenumbers: start") for relation_name in relations.get_active_names(): relation = relations.get_relation(relation_name) if not update and os.path.exists( relation.get_files().get_housenumbers_percent_path()): continue streets = relation.get_config().should_check_missing_streets() if streets == "only": continue orig_language = i18n.get_language() relation.write_missing_housenumbers() for language in ["en", "hu"]: i18n.set_language(language) cache.get_missing_housenumbers_html(relation) i18n.set_language(orig_language) info("update_missing_housenumbers: end")