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")
