Exemplo n.º 1
0
    def write_missing_housenumbers(
            self) -> Tuple[int, int, int, str, List[List[yattag.doc.Doc]]]:
        """
        Calculate a write stat for the house number coverage of a relation.
        Returns a tuple of: todo street count, todo count, done count, percent and table.
        """
        ongoing_streets, done_streets = self.get_missing_housenumbers()

        todo_count = 0
        table = []
        table.append([
            util.html_escape(_("Street name")),
            util.html_escape(_("Missing count")),
            util.html_escape(_("House numbers"))
        ])
        rows = []
        for result in ongoing_streets:
            # street, only_in_ref
            row = []
            row.append(result[0].to_html())
            number_ranges = util.get_housenumber_ranges(result[1])
            row.append(util.html_escape(str(len(number_ranges))))

            doc = yattag.doc.Doc()
            if not self.get_config().get_street_is_even_odd(
                    result[0].get_osm_name()):
                for index, item in enumerate(
                        sorted(number_ranges,
                               key=util.split_house_number_range)):
                    if index:
                        doc.text(", ")
                    doc.asis(util.color_house_number(item).getvalue())
            else:
                util.format_even_odd(number_ranges, doc)
            row.append(doc)

            todo_count += len(number_ranges)
            rows.append(row)

        # It's possible that get_housenumber_ranges() reduces the # of house numbers, e.g. 2, 4 and
        # 6 may be turned into 2-6, which is just 1 item. Sort by the 2nd col, which is the new
        # number of items.
        table += sorted(rows,
                        reverse=True,
                        key=lambda cells: int(cells[1].getvalue()))

        done_count = 0
        for result in done_streets:
            number_ranges = util.get_housenumber_ranges(result[1])
            done_count += len(number_ranges)
        if done_count > 0 or todo_count > 0:
            percent = "%.2f" % (done_count / (done_count + todo_count) * 100)
        else:
            percent = "100.00"

        # Write the bottom line to a file, so the index page show it fast.
        with self.get_files().get_housenumbers_percent_stream("w") as stream:
            stream.write(percent)

        return len(ongoing_streets), todo_count, done_count, percent, table
Exemplo n.º 2
0
def missing_relations_view_result(relations: helpers.Relations, request_uri: str) -> yattag.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()
    if not os.path.exists(relation.get_files().get_osm_streets_path()):
        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()):
        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
Exemplo n.º 3
0
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
Exemplo n.º 4
0
 def test_happy(self) -> None:
     """Tests the happy path."""
     fro = [[util.html_escape("A1"),
             util.html_escape("B1")],
            [util.html_escape("A2"),
             util.html_escape("B2")]]
     expected = '<table class="sortable">'
     expected += '<tr><th><a href="#">A1</a></th>'
     expected += '<th><a href="#">B1</a></th></tr>'
     expected += '<tr><td>A2</td><td>B2</td></tr></table>'
     ret = util.html_table_from_list(fro).getvalue()
     self.assertEqual(ret, expected)
Exemplo n.º 5
0
    def write_missing_housenumbers(
            self) -> Tuple[int, int, int, str, List[List[yattag.doc.Doc]]]:
        """
        Calculate a write stat for the house number coverage of a relation.
        Returns a tuple of: todo street count, todo count, done count, percent and table.
        """
        ongoing_streets, done_streets = self.get_missing_housenumbers()

        todo_count = 0
        table = []
        table.append([
            util.html_escape(_("Street name")),
            util.html_escape(_("Missing count")),
            util.html_escape(_("House numbers"))
        ])
        for result in ongoing_streets:
            # street_name, only_in_ref
            row = []
            row.append(util.html_escape(result[0]))
            number_ranges = util.get_housenumber_ranges(result[1])
            row.append(util.html_escape(str(len(number_ranges))))
            number_range_strings = [i.get_number() for i in number_ranges]

            doc = yattag.doc.Doc()
            if not self.get_config().get_street_is_even_odd(result[0]):
                for index, item in enumerate(
                        sorted(number_range_strings,
                               key=util.split_house_number)):
                    if index:
                        doc.text(", ")
                    doc.asis(util.color_house_number(item).getvalue())
            else:
                util.format_even_odd(number_ranges, doc)
            row.append(doc)

            todo_count += len(number_ranges)
            table.append(row)
        done_count = 0
        for result in done_streets:
            number_ranges = util.get_housenumber_ranges(result[1])
            done_count += len(number_ranges)
        if done_count > 0 or todo_count > 0:
            percent = "%.2f" % (done_count / (done_count + todo_count) * 100)
        else:
            percent = "100.00"

        # Write the bottom line to a file, so the index page show it fast.
        with self.get_files().get_housenumbers_percent_stream("w") as stream:
            stream.write(percent)

        return len(ongoing_streets), todo_count, done_count, percent, table
Exemplo n.º 6
0
      def __handle_error(self, exception, raw_env_proc):
          env, start_response = raw_env_proc

          err_msg = '<h1>Error occured while processing request: %s</h1>' % (
                    util.html_escape(env.get('PATH_INFO', '/')))

          if self.debug_enabled:
             (e_type, e_value, e_tb) = sys.exc_info()
             err_msg += '<h2>Error:</h2><pre>%s</pre><h2>Traceback:</h2><pre>%s</pre>\n' % (
                        exception,
                        ''.join(traceback.format_exception(e_type, e_value, e_tb))
                        )
             #print exception

          env['wsgi.errors'].write(err_msg)
          headers = [('Content-Type', 'text/html; charset=UTF-8')]

          if isinstance(exception, HttpRequestException):
             status = exception.status
             status_str = "%d %s" % (status, HTTP_STATUS_MAP.get(status))
          else:
             status = 500
             status_str = "%d %s" % (status, HTTP_STATUS_MAP.get(status))
            
          start_response(status_str, headers)
          return [ err_msg ]
Exemplo n.º 7
0
    def game_list(self, games):
        if len(games) == 0:
            return "<p>No games</p>"
        games = sorted(games, key=lambda g: g.created_at, reverse=True)

        rtn = "<ul>"
        for g in games:
            l = "<a href=\"/tournaments/%s/%s\">%s v. %s</a>" % (
                util.url_escape(self.tournament.name), g.id,
                util.html_escape(
                    g.players[0].name), util.html_escape(g.players[1].name))
            if g.status != "*":
                l += " %s-%s %s" % (g.outcomes[0], g.outcomes[1], g.status)
            rtn += "<li>%s</li>" % (l, )
        rtn += "</ul>"
        return rtn
Exemplo n.º 8
0
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
Exemplo n.º 9
0
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(_("Additional 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
Exemplo n.º 10
0
def get_footer(last_updated: str = "") -> yattag.Doc:
    """Produces the end of the page."""
    items = []  # type: List[yattag.Doc]
    doc = yattag.Doc()
    doc.text(_("Version: "))
    doc.asis(util.git_link(version.VERSION, "https://github.com/vmiklos/osm-gimmisn/commit/").getvalue())
    items.append(doc)
    items.append(util.html_escape(_("OSM data © OpenStreetMap contributors.")))
    if last_updated:
        items.append(util.html_escape(_("Last update: ") + last_updated))
    doc = yattag.Doc()
    doc.stag("hr")
    with doc.tag("div"):
        for index, item in enumerate(items):
            if index:
                doc.text(" ¦ ")
            doc.asis(item.getvalue())
    return doc
Exemplo n.º 11
0
def handle_main_relation(
        relations: helpers.Relations,
        filter_for: Callable[[bool, helpers.Relation], bool],
        relation_name: str
) -> List[yattag.Doc]:
    """Handles one relation (one table row) on the main page."""
    relation = relations.get_relation(relation_name)
    complete = True

    streets = relation.get_config().should_check_missing_streets()

    row = []  # List[yattag.Doc]
    row.append(util.html_escape(relation_name))

    if streets != "only":
        cell, percent = handle_main_housenr_percent(relation)
        doc = yattag.Doc()
        doc.asis(cell.getvalue())
        row.append(doc)
        if float(percent) < 100.0:
            complete = False

        date = get_housenumbers_last_modified(relation)
        doc = yattag.Doc()
        href = "/osm/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())

        row.append(yattag.Doc())

    if streets != "no":
        cell, percent = handle_main_street_percent(relation)
        row.append(cell)
        if float(percent) < 100.0:
            complete = False
    else:
        row.append(yattag.Doc())

    date = get_streets_last_modified(relation)
    doc = yattag.Doc()
    with doc.tag("a", href="/osm/streets/" + relation_name + "/view-result", title=_("updated") + " " + date):
        doc.text(_("existing streets"))
    row.append(doc)

    doc = yattag.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
Exemplo n.º 12
0
    def test_happy(self) -> None:
        """Tests the happy path."""
        relations = get_relations()
        relation = relations.get_relation("gazdagret")
        fro = [[util.html_escape("A1"),
                util.html_escape("B1")],
               [util.html_escape("A2"),
                util.html_escape("B2")]]
        ret = helpers.make_turbo_query_for_streets(relation, fro)
        expected = """[out:json][timeout:425];
rel(2713748)->.searchRelation;
area(3602713748)->.searchArea;
(way["name"="A2"](r.searchRelation);
way["name"="A2"](area.searchArea);
);
out body;
>;
out skel qt;"""
        self.assertEqual(ret, expected)
Exemplo n.º 13
0
def handle_github_webhook(environ: Dict[str, Any]) -> yattag.Doc:
    """Handles a GitHub style webhook."""

    body = urllib.parse.parse_qs(environ["wsgi.input"].read().decode('utf-8'))
    payload = body["payload"][0]
    root = json.loads(payload)
    if root["ref"] == "refs/heads/master":
        subprocess.run(["make", "-C", util.get_abspath(""), "deploy-pythonanywhere"], check=True)

    return util.html_escape("")
Exemplo n.º 14
0
    def numbered_streets_to_table(
        self, numbered_streets: util.NumberedStreets
    ) -> Tuple[List[List[yattag.doc.Doc]], int]:
        """Turns a list of numbered streets into a HTML table."""
        todo_count = 0
        table = []
        table.append([
            util.html_escape(tr("Street name")),
            util.html_escape(tr("Missing count")),
            util.html_escape(tr("House numbers"))
        ])
        rows = []
        for result in numbered_streets:
            # street, only_in_ref
            row = []
            row.append(result[0].to_html())
            number_ranges = util.get_housenumber_ranges(result[1])
            row.append(util.html_escape(str(len(number_ranges))))

            doc = yattag.doc.Doc()
            if not self.get_config().get_street_is_even_odd(
                    result[0].get_osm_name()):
                for index, item in enumerate(
                        sorted(number_ranges,
                               key=util.split_house_number_range)):
                    if index:
                        doc.text(", ")
                    doc.asis(util.color_house_number(item).getvalue())
            else:
                util.format_even_odd(number_ranges, doc)
            row.append(doc)

            todo_count += len(number_ranges)
            rows.append(row)

        # It's possible that get_housenumber_ranges() reduces the # of house numbers, e.g. 2, 4 and
        # 6 may be turned into 2-6, which is just 1 item. Sort by the 2nd col, which is the new
        # number of items.
        table += sorted(rows,
                        reverse=True,
                        key=lambda cells: int(cells[1].getvalue()))
        return table, todo_count
Exemplo n.º 15
0
 def standings_table(self):
     standings = self.tournament.get_standings()
     if len(standings) == 0:
         return "<p>No players</p>"
     rtn = "<table border=\"1\"><tr><td><b>Player</b></td><td><b>Games Played</b></td><td><b>Points</b></td></tr>"
     for pname in standings:
         rtn += "<tr><td>%s</td><td>%s</td><td>%s</td></tr>" % (
             util.html_escape(pname), standings[pname]['played'],
             standings[pname]['score'])
     rtn += "</table>"
     return rtn
Exemplo n.º 16
0
def handle_github_webhook(environ: Dict[str, Any]) -> yattag.doc.Doc:
    """Handles a GitHub style webhook."""

    body = urllib.parse.parse_qs(environ["wsgi.input"].read().decode('utf-8'))
    payload = body["payload"][0]
    root = json.loads(payload)
    if root["ref"] == "refs/heads/master":
        my_env = os.environ
        my_env["PATH"] = "osm-gimmisn-env/bin:" + my_env["PATH"]
        subprocess.run(["make", "-C", config.get_abspath(""), "deploy"], check=True, env=my_env)

    return util.html_escape("")
Exemplo n.º 17
0
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
Exemplo n.º 18
0
    def render_GET(self, request):
        request.setHeader("Content-Type", "text/html; charset=utf-8")
        html = """
            <html>
            <head>
            <base href="/static/">
            <title>Play in tournament {tournament_name}</title>
            <link rel="stylesheet" href="/static/css/chessboard-0.3.0.css" />
            </head>
            <body>
            <h2>Play in tournament {tournament_name}</h2>
            <div id="join_div">
            Player name:
            <input type="text" id="player_name"><br>
            <button type="button" onclick="join_tournament();">Join tournament</button><br><br>
            </div>

            <div id="white_name"></div>
            <div id="black_name"></div>
            <div id="board" style="width: 400px"></div>
            <h3><div id="status_div"></div></h3>

            <script src="js/jquery-3.2.1.js"></script>
            <script src="js/chessboard-0.3.0.js"></script>
            <script src="js/game_lib.js"></script>
            <script>
                function join_tournament() {{
                    var status_div = document.getElementById("status_div");
                    var white_name_div = document.getElementById("white_name");
                    var black_name_div = document.getElementById("black_name");
                    var join_div = document.getElementById("join_div");
                    var player_name = document.getElementById("player_name").value;
                    play_games({tournament_name_json}, player_name, join_div, status_div, white_name_div, black_name_div);
                }}
            </script>
            </body>
            </html>
        """.format(tournament_name=util.html_escape(self.tournament.name),
                   tournament_name_json=json.dumps(self.tournament.name))

        # var status_div = document.getElementById("status_div");
        # var white_name_div = document.getElementById("white_name");
        # var black_name_div = document.getElementById("black_name");
        # var pgn_div = document.getElementById("game_pgn");
        # observe_game(board, "{game_id}", status_div, white_name_div, black_name_div, pgn_div);

        return html
Exemplo n.º 19
0
    def render_GET(self, request):
        request.setHeader("Content-Type", "text/html; charset=utf-8")

        html = "<html><head><h1>Tournament %s</h1></head><body>" % (
            util.html_escape(self.tournament.name), )
        html += "<p>Details</p>"
        html += self.details_table()

        html += "<h3><a href=\"/tournaments/%s/play\">Join Tournament</a></32>" % (
            util.url_escape(self.tournament.name), )

        html += "<h2>Standings</h2>"
        html += self.standings_table()
        html += "<h2>Active Games</h2>"
        html += self.game_list(self.tournament.active_games())
        html += "<h2>Completed Games</h2>"
        html += self.game_list(self.tournament.compleated_games())
        html += "</body></html>"
        return html
Exemplo n.º 20
0
def tag(tag, *args, **kw):
    if kw.has_key("c"):
        if args:
            raise TypeError(
                "The special 'c' keyword argument cannot be used in " "conjunction with non-keyword arguments"
            )
        args = kw["c"]
        del kw["c"]
    attrargs = []
    for attr, value in kw.items():
        if value is None:
            continue
        if attr.endswith("_"):
            attr = attr[:-1]
        attrargs.append(' %s="%s"' % (attr, html_escape(value)))
    if not args and tag in empty_tags:
        return "<%s%s />" % (tag, "".join(attrargs))
    else:
        return "<%s%s>%s</%s>" % (tag, "".join(attrargs), "".join(map(strify, args)), tag)
Exemplo n.º 21
0
def tag(tag, *args, **kw):
    if kw.has_key("c"):
        if args:
            raise TypeError(
                "The special 'c' keyword argument cannot be used in "
                "conjunction with non-keyword arguments")
        args = kw["c"]
        del kw["c"]
    attrargs = []
    for attr, value in kw.items():
        if value is None:
            continue
        if attr.endswith('_'):
            attr = attr[:-1]
        attrargs.append(' %s="%s"' % (attr, html_escape(value)))
    if not args and tag in empty_tags:
        return '<%s%s />' % (tag, ''.join(attrargs))
    else:
        return '<%s%s>%s</%s>' % (tag, ''.join(attrargs), ''.join(
            map(strify, args)), tag)
Exemplo n.º 22
0
    def render_GET(self, request):
        request.setHeader("Content-Type", "text/html; charset=utf-8")

        title = "%s (white) vs. (black) %s, game in %s+%s" % (
            self.game.players[0].name, self.game.players[1].name,
            self.game.time_limit, self.game.increment)
        title = util.html_escape(title)

        html = """
            <html>
            <head>
            <base href="/static/">
            <title>{title}</title>
            <link rel="stylesheet" href="/static/css/chessboard-0.3.0.css" />
            </head>
            <body>
            <h2>{title}</h2>
            <div id="white_name"></div>
            <div id="black_name"></div>
            <div id="board" style="width: 400px"></div>
            <h3><div id="status_div">{game_status}</div></h3>
            <pre><div id="game_pgn" style="width: 400px">{game_pgn}</div></pre>
            <script src="js/jquery-3.2.1.js"></script>
            <script src="js/chessboard-0.3.0.js"></script>
            <script src="js/game_lib.js"></script>
            <script>
                window.onload = function() {{
                    var status_div = document.getElementById("status_div");
                    var white_name_div = document.getElementById("white_name");
                    var black_name_div = document.getElementById("black_name");
                    observe_game("{game_id}", status_div, white_name_div, black_name_div);
                }}
            </script>
            </body>
            </html>
        """.format(title=title,
                   game_id=self.game.id,
                   game_pgn=cgi.escape(str(self.game.pgn)),
                   game_status=self.game.outcome_str())

        return html
Exemplo n.º 23
0
    def render_GET(self, request):
        request.setHeader("Content-Type", "text/html; charset=utf-8")

        tournament_html = ""
        if len(self.manager.tournaments):
            tournaments = sorted(self.manager.tournaments.values(), key=lambda t:t.created_at, reverse=True)

            tournament_html = "<ul>"
            for t in tournaments:
                tournament_html += "<li><a href='/tournaments/%s'>%s</a> (%s games,  %s active players)</li>" % (util.url_escape(t.name), util.html_escape(t.name), len(t.all_games()), len(t.players))
            tournament_html += "</ul>"
        else:
            tournament_html = "<p>No Tournaments :(</p>"


        form_html = """
        <form action="/tournaments/new" method="post">
            Tournament name:
            <input type="text" name="name"><br>
            Time limit (seconds):
            <input type="text" name="time_limit"><br>
            Increment (seconds):
            <input type="text" name="increment"><br>
            Games per pairing:
            <input type="text" name="games_per_pair"><br>
            <input type="submit" value="Submit">
        </form>"""

        html = "<html><head><h1>Chess Server</h1></head><body><h2>Tournaments</h2>%s<h2>Create new tournament</h2>%s</body></html>" % (tournament_html, form_html)
        return html
Exemplo n.º 24
0
def additional_streets_view_result(ctx: context.Context,
                                   relations: areas.Relations,
                                   request_uri: str) -> yattag.doc.Doc:
    """Expected request_uri: e.g. /osm/additional-streets/budapest_11/view-result."""
    tokens = request_uri.split("/")
    relation_name = tokens[-2]
    relation = relations.get_relation(relation_name)

    doc = yattag.doc.Doc()
    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_ref_streets_path()):
        doc.asis(
            webframe.handle_no_ref_streets(prefix, relation_name).getvalue())
    else:
        # Get "only in OSM" streets.
        streets = relation.write_additional_streets()
        count = len(streets)
        lexical_sort_key = util.get_lexical_sort_key()
        streets.sort(
            key=lambda street: lexical_sort_key(street.get_osm_name()))
        table = [[
            util.html_escape(tr("Identifier")),
            util.html_escape(tr("Type")),
            util.html_escape(tr("Source")),
            util.html_escape(tr("Street name"))
        ]]
        for street in streets:
            cell = yattag.doc.Doc()
            href = "https://www.openstreetmap.org/{}/{}".format(
                street.get_osm_type(), street.get_osm_id())
            with cell.tag("a", href=href, target="_blank"):
                cell.text(str(street.get_osm_id()))
            cells = [
                cell,
                util.html_escape(street.get_osm_type()),
                util.html_escape(street.get_source()),
                util.html_escape(street.get_osm_name()),
            ]
            table.append(cells)

        with doc.tag("p"):
            doc.text(
                tr("OpenStreetMap additionally has the below {0} streets.").
                format(str(count)))
            doc.stag("br")
            with doc.tag("a",
                         href=prefix + "/additional-streets/" + relation_name +
                         "/view-result.txt"):
                doc.text(tr("Plain text format"))
            doc.stag("br")
            with doc.tag("a",
                         href=prefix + "/additional-streets/" + relation_name +
                         "/view-result.chkl"):
                doc.text(tr("Checklist format"))
            doc.stag("br")
            with doc.tag(
                    "a",
                    href=prefix +
                    "/additional-streets/{}/view-turbo".format(relation_name)):
                doc.text(tr("Overpass turbo query for the below streets"))

        doc.asis(util.html_table_from_list(table).getvalue())
        doc.asis(
            util.invalid_refstreets_to_html(
                relation.get_invalid_refstreets()).getvalue())
    return doc
Exemplo n.º 25
0
 def mock_handler(_environ: Dict[str, BinaryIO]) -> yattag.doc.Doc:
     nonlocal mock_called
     mock_called = True
     return util.html_escape("")
Exemplo n.º 26
0
def handle_stats_cityprogress(relations: areas.Relations) -> yattag.doc.Doc:
    """Expected request_uri: e.g. /osm/housenumber-stats/hungary/cityprogress."""
    doc = yattag.doc.Doc()
    doc.asis(get_toolbar(relations).getvalue())

    ref_citycounts: Dict[str, int] = {}
    with open(config.Config.get_reference_citycounts_path(), "r") as stream:
        first = True
        for line in stream.readlines():
            if first:
                first = False
                continue
            cells = line.strip().split('\t')
            if len(cells) < 2:
                continue
            city = cells[0]
            count = int(cells[1])
            ref_citycounts[city] = count
    today = time.strftime("%Y-%m-%d")
    osm_citycounts: Dict[str, int] = {}
    with open(config.Config.get_workdir() + "/stats/" + today + ".citycount",
              "r") as stream:
        for line in stream.readlines():
            cells = line.strip().split('\t')
            if len(cells) < 2:
                continue
            city = cells[0]
            count = int(cells[1])
            osm_citycounts[city] = count
    cities = util.get_in_both(list(ref_citycounts.keys()),
                              list(osm_citycounts.keys()))
    cities.sort(key=locale.strxfrm)
    table = []
    table.append([
        util.html_escape(_("City name")),
        util.html_escape(_("House number coverage")),
        util.html_escape(_("OSM count")),
        util.html_escape(_("Reference count"))
    ])
    for city in cities:
        percent = "100.00"
        if ref_citycounts[city] > 0 and osm_citycounts[city] < ref_citycounts[
                city]:
            percent = "%.2f" % (osm_citycounts[city] / ref_citycounts[city] *
                                100)
        table.append([
            util.html_escape(city),
            util.html_escape(util.format_percent(percent)),
            util.html_escape(str(osm_citycounts[city])),
            util.html_escape(str(ref_citycounts[city]))
        ])
    doc.asis(util.html_table_from_list(table).getvalue())

    with doc.tag("h2"):
        doc.text(_("Note"))
    with doc.tag("div"):
        doc.text(
            _("""These statistics are estimates, not taking house number filters into account.
Only cities with house numbers in OSM are considered."""))

    doc.asis(get_footer().getvalue())
    return doc
Exemplo n.º 27
0
  pd['source'] = 'http://soe.stanford.edu/research/%s' % prof[0]
  pd['name'] = prof[1]
  #extract the primary deptmartment from within the <b> tags
  if '<b>' in prof[2]:
    pd['department'] = re.findall('<b>(.*?)</b>', prof[2])[0]
  else:
    pd['department'] = util.prep_department(util.remove_tags(prof[2]))
  research = prof[3].replace('&nbsp;', '').strip()
  if len(research) > 0:
    pd['keywords'] = util.split_and_clean(research, ',')
  
  pd['school'] = 'Stanford University'
  personal_page = util.dl_and_prep(pd['lab_website'])
  summary = re.findall('<h3>Research Statement</h3><p>(.*?)</p><h3>Degrees</h3>', personal_page)
  if summary:
    pd['research_summary'] = util.html_escape(summary[0].strip())
  try:
    pd['image'] = 'http://soe.stanford.edu/research/%s' % re.findall('\'(images/photos_faculty_staff/.*?)\'', personal_page)[0]
  except Exception:
    import pdb; pdb.set_trace()
  pd['title'] = re.findall("Title:</td><td class=\"data\">(.*?)</td>", personal_page)[0]  
  personal_website = re.findall("URL:</TD><TD class=\"data\"><a href='(.*?)'", personal_page)
  if personal_website:
    pd['personal_website'] = personal_website[0]
  print pd['name'], pd['department']
  util.validate_professor(pd)
  output.append(pd)

pickle.dump(output, file('prof_dicts/stanford.dat', 'w'))
print 'Done!'
Exemplo n.º 28
0
def escape(text):
	if isinstance(text,NoEscape):
		return str(text.raw_text)
	else:
		text=str(text)
		return html_escape(text)
Exemplo n.º 29
0
def missing_streets_update(relations: helpers.Relations, relation_name: str) -> yattag.Doc:
    """Expected request_uri: e.g. /osm/missing-streets/ujbuda/update-result."""
    reference = util.get_abspath(get_config().get('wsgi', 'reference_street').strip())
    relation = relations.get_relation(relation_name)
    relation.write_ref_streets(reference)
    return util.html_escape(_("Update successful."))