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 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 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 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 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_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(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 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_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."""
references = config.Config.get_reference_housenumber_paths()
relation = relations.get_relation(relation_name)
relation.write_ref_housenumbers(references)
doc = yattag.doc.Doc()
doc.text(_("Update successful: "))
prefix = config.Config.get_uri_prefix()
link = prefix + "/missing-housenumbers/" + relation_name + "/view-result"
doc.asis(util.gen_link(link, _("View missing house numbers")).getvalue())
return doc
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_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) -> 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 missing_housenumbers_update_result_json(ctx: context.Context,
relations: areas.Relations,
request_uri: str) -> str:
"""Expected request_uri: e.g. /osm/missing-housenumbers/ormezo/update-result.json."""
tokens = request_uri.split("/")
relation_name = tokens[-2]
references = ctx.get_ini().get_reference_housenumber_paths()
relation = relations.get_relation(relation_name)
ret: Dict[str, str] = {}
relation.write_ref_housenumbers(references)
ret["error"] = ""
return json.dumps(ret)
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_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 street_housenumbers_update_result_json(relations: areas.Relations, request_uri: str) -> str:
"""Expected request_uri: e.g. /osm/street-housenumbers/ormezo/update-result.json."""
tokens = request_uri.split("/")
relation_name = tokens[-2]
relation = relations.get_relation(relation_name)
query = relation.get_osm_housenumbers_query()
ret: Dict[str, str] = {}
try:
relation.get_files().write_osm_housenumbers(overpass_query.overpass_query(query))
ret["error"] = ""
except urllib.error.HTTPError as http_error:
ret["error"] = str(http_error)
return json.dumps(ret)
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 missing_housenumbers_view_turbo(relations: areas.Relations, request_uri: str) -> yattag.doc.Doc:
"""Expected request_uri: e.g. /osm/missing-housenumbers/ormezo/view-turbo."""
tokens = request_uri.split("/")
relation_name = tokens[-2]
doc = yattag.doc.Doc()
relation = relations.get_relation(relation_name)
ret = relation.write_missing_housenumbers()
_todo_street_count, _todo_count, _done_count, _percent, table = ret
query = areas.make_turbo_query_for_streets(relation, table)
with doc.tag("pre"):
doc.text(query)
return doc
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 additional_streets_view_turbo(relations: areas.Relations,
request_uri: str) -> yattag.doc.Doc:
"""Expected request_uri: e.g. /osm/additional-housenumbers/ormezo/view-turbo."""
tokens = request_uri.split("/")
relation_name = tokens[-2]
doc = yattag.doc.Doc()
relation = relations.get_relation(relation_name)
streets = relation.get_additional_streets(sorted_result=False)
query = areas.make_turbo_query_for_street_objs(relation, streets)
with doc.tag("pre"):
doc.text(query)
return doc
def missing_housenumbers_view_chkl(ctx: context.Context,
relations: areas.Relations,
request_uri: str) -> Tuple[str, str]:
"""Expected request_uri: e.g. /osm/missing-housenumbers/ormezo/view-result.chkl."""
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 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_osm_housenumbers_path()):
output += tr("No existing house numbers")
elif not ctx.get_file_system().path_exists(
relation.get_files().get_ref_housenumbers_path()):
output += tr("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])
# Street name, only_in_reference items.
row = "[ ] "
if not relation.get_config().get_street_is_even_odd(
result[0].get_osm_name()):
result_sorted = sorted([i.get_number() for i in range_list],
key=util.split_house_number)
row += result[0].get_osm_name() + " [" + ", ".join(
result_sorted) + "]"
table.append(row)
else:
elements = util.format_even_odd(range_list, doc=None)
if len(elements) > 1 and len(
range_list) > get_chkl_split_limit():
for element in elements:
row = "[ ] " + result[0].get_osm_name(
) + " [" + element + "]"
table.append(row)
else:
row += result[0].get_osm_name() + " [" + "], [".join(
elements) + "]"
table.append(row)
table.sort(key=util.get_lexical_sort_key())
output += "\n".join(table)
return output, relation_name
def handle_main_relation(ctx: context.Context, 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 both street and
# housenr 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))
if streets != "only":
cell, percent = handle_main_housenr_percent(ctx, relation)
doc = yattag.doc.Doc()
doc.asis(cell.getvalue())
row.append(doc)
complete &= float(percent) >= 100.0
row.append(handle_main_housenr_additional_count(ctx, relation))
else:
row.append(yattag.doc.Doc())
row.append(yattag.doc.Doc())
if streets != "no":
cell, percent = handle_main_street_percent(ctx, relation)
row.append(cell)
complete &= float(percent) >= 100.0
else:
row.append(yattag.doc.Doc())
if streets != "no":
row.append(handle_main_street_additional_count(ctx, relation))
else:
row.append(yattag.doc.Doc())
doc = yattag.doc.Doc()
with doc.tag("a",
href="https://www.openstreetmap.org/relation/" +
str(relation.get_config().get_osmrelation())):
doc.text(tr("area boundary"))
row.append(doc)
if not filter_for(complete, relation):
row.clear()
return row
def handle_street_housenumbers(ctx: context.Context,
relations: areas.Relations,
request_uri: str) -> yattag.doc.Doc:
"""Expected request_uri: e.g. /osm/street-housenumbers/ormezo/view-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(ctx, relations, "street-housenumbers",
relation_name, osmrelation).getvalue())
prefix = ctx.get_ini().get_uri_prefix()
if action == "view-query":
with doc.tag("pre"):
doc.text(relation.get_osm_housenumbers_query())
elif action == "update-result":
query = relation.get_osm_housenumbers_query()
buf, err = overpass_query.overpass_query(ctx, query)
if err:
doc.asis(util.handle_overpass_error(ctx, err).getvalue())
else:
relation.get_files().write_osm_housenumbers(ctx, buf)
doc.text(tr("Update successful: "))
link = prefix + "/missing-housenumbers/" + relation_name + "/view-result"
doc.asis(
util.gen_link(link,
tr("View missing house numbers")).getvalue())
else:
# assume view-result
if not ctx.get_file_system().path_exists(
relation.get_files().get_osm_housenumbers_path()):
with doc.tag("div", id="no-osm-housenumbers"):
doc.text(tr("No existing house numbers"))
else:
with relation.get_files().get_osm_housenumbers_csv_stream(
ctx) as sock:
doc.asis(
util.html_table_from_list(
util.tsv_to_list(sock)).getvalue())
date = get_housenumbers_last_modified(relation)
doc.asis(webframe.get_footer(date).getvalue())
return doc
def missing_streets_view_txt(relations: areas.Relations, request_uri: str) -> str:
"""Expected request_uri: e.g. /osm/missing-streets/ujbuda/view-result.txt."""
tokens = request_uri.split("/")
relation_name = tokens[-2]
relation = relations.get_relation(relation_name)
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_ref_streets_path()):
output += _("No reference streets")
else:
todo_streets, _ignore = relation.get_missing_streets()
todo_streets.sort(key=locale.strxfrm)
output += "\n".join(todo_streets)
return output
def street_housenumbers_update_result_json(ctx: context.Context,
relations: areas.Relations,
request_uri: str) -> str:
"""Expected request_uri: e.g. /osm/street-housenumbers/ormezo/update-result.json."""
tokens = request_uri.split("/")
relation_name = tokens[-2]
relation = relations.get_relation(relation_name)
query = relation.get_osm_housenumbers_query()
ret: Dict[str, str] = {}
buf, err = overpass_query.overpass_query(ctx, query)
if err:
ret["error"] = err
else:
relation.get_files().write_osm_housenumbers(ctx, buf)
ret["error"] = ""
return json.dumps(ret)
