geo-activity-playground 0.38.2__py3-none-any.whl → 0.39.0__py3-none-any.whl

geo_activity_playground/webui/activity/templates/activity/day.html.j2

@@ -1,80 +0,0 @@
-{% extends "page.html.j2" %}
-
-{% block container %}
-<div class="row mb-3">
-    <div class="col">
-        <h1>{{ date }}</h1>
-    </div>
-</div>
-
-
-<div class="row mb-3">
-    <div class="col-12">
-        <div id="activity-map" style="height: 500px;"></div>
-        <script>
-            var map = L.map('activity-map', {
-                fullscreenControl: true
-            });
-            L.tileLayer('/tile/grayscale/{z}/{x}/{y}.png', {
-                maxZoom: 19,
-                attribution: '{{ map_tile_attribution|safe }}'
-            }).addTo(map);
-
-            let geojson = L.geoJSON({{ geojson| safe }}, {
-                style: function (feature) { return { color: feature.properties.color } }
-            }).addTo(map)
-            map.fitBounds(geojson.getBounds());
-        </script>
-    </div>
-</div>
-
-<div class="row mb-3">
-    <div class="col">
-        <h2>Activities</h2>
-
-        <table class="table table-sort table-arrows">
-            <thead>
-                <tr>
-                    <th>Name</th>
-                    <th>Date</th>
-                    <th>Distance / km</th>
-                    <th>Elapsed time</th>
-                    <th>Speed / km/h</th>
-                    <th>Equipment</th>
-                    <th>Kind</th>
-                </tr>
-            </thead>
-            <tbody>
-                {% for activity in activities %}
-                <tr>
-                    <td><span style="color: {{ activity['color'] }};">█</span> <a
-                            href="{{ url_for('activity.show', id=activity.id) }}">{{
-                            activity.name }}</a></td>
-                    <td>{{ activity.start|dt }}</td>
-                    <td>{{ activity.distance_km | round(1) }}</td>
-                    <td>{{ activity.elapsed_time|td }}</td>
-                    <td>{{ activity.average_speed_moving_kmh|round(1) }}</td>
-                    <td>{{ activity["equipment"] }}</td>
-                    <td>{{ activity["kind"] }}</td>
-                </tr>
-                {% endfor %}
-                {% if activities|length > 1 %}
-                <tr>
-                    <td><b>Total</b></td>
-                    <td></td>
-                    <td><b>{{ total_distance | round(1) }}</b></td>
-                    <td><b>{{ total_elapsed_time|td }}</b></td>
-                    <td></td>
-                    <td></td>
-                </tr>
-                {% endif %}
-            </tbody>
-        </table>
-    </div>
-</div>
-
-<h2>Share picture</h2>
-
-<p><img class="img-fluid" src="{{ url_for('.day_sharepic', year=year, month=month, day=day) }}" /></p>
-
-{% endblock %}

geo_activity_playground/webui/activity/templates/activity/edit.html.j2

@@ -1,42 +0,0 @@
-{% extends "page.html.j2" %}
-
-{% block container %}
-
-<h1 class="mb-3">Edit Activity</h1>
-
-<form method="POST">
-    <div class="mb-3">
-        <label for="name" class="form-label">Name</label>
-        <input type="text" class="form-control" id="name" name="name" value="{{ override['name'] }}" />
-    </div>
-
-    <div class="mb-3">
-        <label for="kind" class="form-label">Kind</label>
-        <input type="text" class="form-control" id="kind" name="kind" value="{{ override['kind'] }}" />
-    </div>
-
-    <div class="mb-3">
-        <label for="equipment" class="form-label">Equipment</label>
-        <input type="text" class="form-control" id="equipment" name="equipment" value="{{ override['equipment'] }}" />
-    </div>
-
-    <div class="mb-3">
-        <div class="form-check">
-            <input type="checkbox" class="form-check-input" id="commute" name="commute" {% if override['commute'] %}
-                checked {% endif %} />
-            <label for="commute" class="form-check-label">Commute</label>
-        </div>
-    </div>
-
-    <div class="mb-3">
-        <div class="form-check">
-            <input type="checkbox" class="form-check-input" id="consider_for_achievements"
-                name="consider_for_achievements" {% if override['consider_for_achievements'] %} checked {% endif %} />
-            <label for="consider_for_achievements" class="form-check-label">Consider for achievements</label>
-        </div>
-    </div>
-
-    <button type="submit" class="btn btn-primary">Save</button>
-</form>
-
-{% endblock %}

geo_activity_playground/webui/calendar/blueprint.py

@@ -1,23 +0,0 @@
-from flask import Blueprint
-from flask import render_template
-
-from geo_activity_playground.webui.calendar.controller import CalendarController
-
-
-def make_calendar_blueprint(calendar_controller: CalendarController) -> Blueprint:
-    blueprint = Blueprint("calendar", __name__, template_folder="templates")
-
-    @blueprint.route("/")
-    def index():
-        return render_template(
-            "calendar/index.html.j2", **calendar_controller.render_overview()
-        )
-
-    @blueprint.route("/<year>/<month>")
-    def month(year: str, month: str):
-        return render_template(
-            "calendar/month.html.j2",
-            **calendar_controller.render_month(int(year), int(month))
-        )
-
-    return blueprint

geo_activity_playground/webui/calendar/templates/calendar/index.html.j2

@@ -1,46 +0,0 @@
-{% extends "page.html.j2" %}
-
-{% block container %}
-<div class="row mb-1">
-    <div class="col">
-        <h1>Calendar</h1>
-    </div>
-</div>
-
-<div class="row mb-1">
-    <div class="col">
-        <table class="table">
-            <thead>
-                <tr>
-                    <th>Year</th>
-                    {% for i in range(1, 13) %}
-                    <th style="text-align: right;">{{ i }}</th>
-                    {% endfor %}
-                    <th style="text-align: right;">Total</th>
-                </tr>
-            </thead>
-            <tbody>
-                {% for year, month_data in monthly_distances.items() %}
-                {% set year_int = year|round(0)|int %}
-                <tr>
-                    <td>{{ year_int }}</td>
-                    {% for month in range(1, 13) %}
-                    <td align="right">
-                        {% set distance = month_data[month] %}
-                        {% if distance %}
-                        <a href="{{ url_for(".month", year=year_int, month=month) }}">{{ distance|int() }} km</a>
-                        {% else %}
-                        0 km
-                        {% endif %}
-                    </td>
-                    {% endfor %}
-                    <td align="right">{{ yearly_distances[year]|int() }} km</td>
-                </tr>
-                {% endfor %}
-            </tbody>
-        </table>
-    </div>
-</div>
-
-
-{% endblock %}

geo_activity_playground/webui/calendar/templates/calendar/month.html.j2

@@ -1,55 +0,0 @@
-{% extends "page.html.j2" %}
-
-{% block container %}
-<div class="row mb-1">
-    <div class="col">
-        <h1>Calendar {{ year }}-{{ "{0:02d}".format(month) }}</h1>
-    </div>
-</div>
-
-<div class="row mb-1">
-    <div class="col">
-        <table class="table">
-            <thead>
-                <tr>
-                    <th>Week</th>
-                    <th>Monday</th>
-                    <th>Tuesday</th>
-                    <th>Wednesday</th>
-                    <th>Thursday</th>
-                    <th>Friday</th>
-                    <th>Saturday</th>
-                    <th>Sunday</th>
-                </tr>
-            </thead>
-            <tbody>
-                {% for week, week_data in weeks.items() %}
-                <tr>
-                    <td>{{ week }}</td>
-                    {% for day in range(1, 8) %}
-                    <td>
-                        {% if weeks[week][day] %}
-                        <a href="{{ url_for('activity.day', year=year, month=month, day=day_of_month[week][day]) }}"><b>{{
-                                day_of_month[week][day] }}.</b></a>
-                        {% elif day_of_month[week][day] %}
-                        <b>{{ day_of_month[week][day] }}.</b>
-                        {% endif %}
-
-                        {% if weeks[week][day] %}
-                        <ul>
-                            {% for activity in weeks[week][day] %}
-                            <li><a href="{{ url_for('activity.show', id=activity.id) }}">{{ activity.name }}</a></li>
-                            {% endfor %}
-                        </ul>
-                        {% endif %}
-                    </td>
-                    {% endfor %}
-                </tr>
-                {% endfor %}
-            </tbody>
-        </table>
-    </div>
-</div>
-
-
-{% endblock %}

geo_activity_playground/webui/entry_controller.py

@@ -1,63 +0,0 @@
-import datetime
-import itertools
-
-import altair as alt
-import pandas as pd
-
-from geo_activity_playground.core.activities import ActivityRepository
-from geo_activity_playground.core.activities import make_geojson_from_time_series
-from geo_activity_playground.core.config import Config
-from geo_activity_playground.webui.plot_util import make_kind_scale
-
-
-class EntryController:
-    def __init__(self, repository: ActivityRepository, config: Config) -> None:
-        self._repository = repository
-        self._config = config
-
-    def render(self) -> dict:
-        result = {"latest_activities": []}
-
-        if len(self._repository):
-            kind_scale = make_kind_scale(self._repository.meta, self._config)
-            result["distance_last_30_days_plot"] = distance_last_30_days_meta_plot(
-                self._repository.meta, kind_scale
-            )
-
-        for activity in itertools.islice(
-            self._repository.iter_activities(dropna=True), 15
-        ):
-            time_series = self._repository.get_time_series(activity["id"])
-            result["latest_activities"].append(
-                {
-                    "line_geojson": make_geojson_from_time_series(time_series),
-                    "activity": activity,
-                }
-            )
-        return result
-
-
-def distance_last_30_days_meta_plot(meta: pd.DataFrame, kind_scale: alt.Scale) -> str:
-    before_30_days = pd.to_datetime(
-        datetime.datetime.now() - datetime.timedelta(days=31)
-    )
-    return (
-        alt.Chart(
-            meta.loc[meta["start"] > before_30_days],
-            width=700,
-            height=200,
-            title="Distance per day",
-        )
-        .mark_bar()
-        .encode(
-            alt.X("yearmonthdate(start)", title="Date"),
-            alt.Y("sum(distance_km)", title="Distance / km"),
-            alt.Color("kind", scale=kind_scale, title="Kind"),
-            [
-                alt.Tooltip("yearmonthdate(start)", title="Date"),
-                alt.Tooltip("kind", title="Kind"),
-                alt.Tooltip("sum(distance_km)", format=".1f", title="Distance / km"),
-            ],
-        )
-        .to_json(format="vega")
-    )

geo_activity_playground/webui/explorer/blueprint.py

@@ -1,62 +0,0 @@
-from flask import Blueprint
-from flask import redirect
-from flask import render_template
-from flask import Response
-from flask import url_for
-
-from geo_activity_playground.webui.authenticator import Authenticator
-from geo_activity_playground.webui.authenticator import needs_authentication
-from geo_activity_playground.webui.explorer.controller import ExplorerController
-
-
-def make_explorer_blueprint(
-    explorer_controller: ExplorerController,
-    authenticator: Authenticator,
-) -> Blueprint:
-    blueprint = Blueprint("explorer", __name__, template_folder="templates")
-
-    @blueprint.route("/<zoom>")
-    def map(zoom: str):
-        return render_template(
-            "explorer/index.html.j2", **explorer_controller.render(int(zoom))
-        )
-
-    @blueprint.route("/enable-zoom-level/<zoom>")
-    @needs_authentication(authenticator)
-    def enable_zoom_level(zoom: str):
-        explorer_controller.enable_zoom_level(int(zoom))
-        return redirect(url_for(".map", zoom=zoom))
-
-    @blueprint.route("/<zoom>/<north>/<east>/<south>/<west>/explored.<suffix>")
-    def download(zoom: str, north: str, east: str, south: str, west: str, suffix: str):
-        mimetypes = {"geojson": "application/json", "gpx": "application/xml"}
-        return Response(
-            explorer_controller.export_explored_tiles(
-                int(zoom),
-                float(north),
-                float(east),
-                float(south),
-                float(west),
-                suffix,
-            ),
-            mimetype=mimetypes[suffix],
-            headers={"Content-disposition": "attachment"},
-        )
-
-    @blueprint.route("/<zoom>/<north>/<east>/<south>/<west>/missing.<suffix>")
-    def missing(zoom: str, north: str, east: str, south: str, west: str, suffix: str):
-        mimetypes = {"geojson": "application/json", "gpx": "application/xml"}
-        return Response(
-            explorer_controller.export_missing_tiles(
-                int(zoom),
-                float(north),
-                float(east),
-                float(south),
-                float(west),
-                suffix,
-            ),
-            mimetype=mimetypes[suffix],
-            headers={"Content-disposition": "attachment"},
-        )
-
-    return blueprint

geo_activity_playground/webui/heatmap/blueprint.py

@@ -1,51 +0,0 @@
-import dateutil.parser
-from flask import Blueprint
-from flask import render_template
-from flask import request
-from flask import Response
-
-from geo_activity_playground.core.activities import ActivityRepository
-from geo_activity_playground.core.config import Config
-from geo_activity_playground.explorer.tile_visits import TileVisitAccessor
-from geo_activity_playground.webui.heatmap.heatmap_controller import HeatmapController
-from geo_activity_playground.webui.search_util import search_query_from_form
-from geo_activity_playground.webui.search_util import SearchQueryHistory
-
-
-def make_heatmap_blueprint(
-    repository: ActivityRepository,
-    tile_visit_accessor: TileVisitAccessor,
-    config: Config,
-    search_query_history: SearchQueryHistory,
-) -> Blueprint:
-    heatmap_controller = HeatmapController(repository, tile_visit_accessor, config)
-    blueprint = Blueprint("heatmap", __name__, template_folder="templates")
-
-    @blueprint.route("/")
-    def index():
-        query = search_query_from_form(request.args)
-        search_query_history.register_query(query)
-        return render_template(
-            "heatmap/index.html.j2", **heatmap_controller.render(query)
-        )
-
-    @blueprint.route("/tile/<int:z>/<int:x>/<int:y>.png")
-    def tile(x: int, y: int, z: int):
-        query = search_query_from_form(request.args)
-        return Response(
-            heatmap_controller.render_tile(x, y, z, query),
-            mimetype="image/png",
-        )
-
-    @blueprint.route(
-        "/download/<float:north>/<float:east>/<float:south>/<float:west>/heatmap.png"
-    )
-    def download(north: float, east: float, south: float, west: float):
-        query = search_query_from_form(request.args)
-        return Response(
-            heatmap_controller.download_heatmap(north, east, south, west, query),
-            mimetype="image/png",
-            headers={"Content-disposition": 'attachment; filename="heatmap.png"'},
-        )
-
-    return blueprint

geo_activity_playground/webui/heatmap/heatmap_controller.py

@@ -1,216 +0,0 @@
-import datetime
-import io
-import logging
-import pathlib
-from typing import Optional
-
-import matplotlib.pylab as pl
-import numpy as np
-from PIL import Image
-from PIL import ImageDraw
-
-from geo_activity_playground.core.activities import ActivityRepository
-from geo_activity_playground.core.config import Config
-from geo_activity_playground.core.meta_search import apply_search_query
-from geo_activity_playground.core.meta_search import SearchQuery
-from geo_activity_playground.core.raster_map import convert_to_grayscale
-from geo_activity_playground.core.raster_map import GeoBounds
-from geo_activity_playground.core.raster_map import get_sensible_zoom_level
-from geo_activity_playground.core.raster_map import get_tile
-from geo_activity_playground.core.raster_map import OSM_TILE_SIZE
-from geo_activity_playground.core.raster_map import PixelBounds
-from geo_activity_playground.core.tasks import work_tracker
-from geo_activity_playground.core.tiles import get_tile_upper_left_lat_lon
-from geo_activity_playground.explorer.tile_visits import TileVisitAccessor
-from geo_activity_playground.webui.explorer.controller import (
-    bounding_box_for_biggest_cluster,
-)
-
-
-logger = logging.getLogger(__name__)
-
-
-class HeatmapController:
-    def __init__(
-        self,
-        repository: ActivityRepository,
-        tile_visit_accessor: TileVisitAccessor,
-        config: Config,
-    ) -> None:
-        self._repository = repository
-        self._tile_visit_accessor = tile_visit_accessor
-        self._config = config
-
-        self.tile_histories = self._tile_visit_accessor.tile_state["tile_history"]
-        self.tile_evolution_states = self._tile_visit_accessor.tile_state[
-            "evolution_state"
-        ]
-        self.tile_visits = self._tile_visit_accessor.tile_state["tile_visits"]
-        self.activities_per_tile = self._tile_visit_accessor.tile_state[
-            "activities_per_tile"
-        ]
-
-    def render(self, query: SearchQuery) -> dict:
-        zoom = 14
-        tiles = self.tile_histories[zoom]
-        medians = tiles.median(skipna=True)
-        median_lat, median_lon = get_tile_upper_left_lat_lon(
-            medians["tile_x"], medians["tile_y"], zoom
-        )
-        cluster_state = self.tile_evolution_states[zoom]
-
-        values = {
-            "center": {
-                "latitude": median_lat,
-                "longitude": median_lon,
-                "bbox": (
-                    bounding_box_for_biggest_cluster(
-                        cluster_state.clusters.values(), zoom
-                    )
-                    if len(cluster_state.memberships) > 0
-                    else {}
-                ),
-            },
-            "extra_args": query.to_url_str(),
-            "query": query.to_jinja(),
-        }
-
-        return values
-
-    def _get_counts(
-        self,
-        x: int,
-        y: int,
-        z: int,
-        query: SearchQuery,
-    ) -> np.ndarray:
-        tile_pixels = (OSM_TILE_SIZE, OSM_TILE_SIZE)
-        tile_counts = np.zeros(tile_pixels, dtype=np.int32)
-        if not query.active:
-            tile_count_cache_path = pathlib.Path(f"Cache/Heatmap/{z}/{x}/{y}.npy")
-            if tile_count_cache_path.exists():
-                try:
-                    tile_counts = np.load(tile_count_cache_path)
-                except ValueError:
-                    logger.warning(
-                        f"Heatmap count file {tile_count_cache_path} is corrupted, deleting."
-                    )
-                    tile_count_cache_path.unlink()
-                    tile_counts = np.zeros(tile_pixels, dtype=np.int32)
-            tile_count_cache_path.parent.mkdir(parents=True, exist_ok=True)
-            activity_ids = self.activities_per_tile[z].get((x, y), set())
-
-            with work_tracker(
-                tile_count_cache_path.with_suffix(".json")
-            ) as parsed_activities:
-                if parsed_activities - activity_ids:
-                    logger.warning(
-                        f"Resetting heatmap cache for {x=}/{y=}/{z=} because activities have been removed."
-                    )
-                    tile_counts = np.zeros(tile_pixels, dtype=np.int32)
-                    parsed_activities.clear()
-                for activity_id in activity_ids:
-                    if activity_id in parsed_activities:
-                        continue
-                    parsed_activities.add(activity_id)
-                    time_series = self._repository.get_time_series(activity_id)
-                    for _, group in time_series.groupby("segment_id"):
-                        xy_pixels = (
-                            np.array([group["x"] * 2**z - x, group["y"] * 2**z - y]).T
-                            * OSM_TILE_SIZE
-                        )
-                        im = Image.new("L", tile_pixels)
-                        draw = ImageDraw.Draw(im)
-                        pixels = list(map(int, xy_pixels.flatten()))
-                        draw.line(pixels, fill=1, width=max(3, 6 * (z - 17)))
-                        aim = np.array(im)
-                        tile_counts += aim
-            tmp_path = tile_count_cache_path.with_suffix(".tmp.npy")
-            np.save(tmp_path, tile_counts)
-            tile_count_cache_path.unlink(missing_ok=True)
-            tmp_path.rename(tile_count_cache_path)
-        else:
-            activities = apply_search_query(self._repository.meta, query)
-            activity_ids = self.activities_per_tile[z].get((x, y), set())
-            for activity_id in activity_ids:
-                if activity_id not in activities["id"]:
-                    continue
-                time_series = self._repository.get_time_series(activity_id)
-                for _, group in time_series.groupby("segment_id"):
-                    xy_pixels = (
-                        np.array([group["x"] * 2**z - x, group["y"] * 2**z - y]).T
-                        * OSM_TILE_SIZE
-                    )
-                    im = Image.new("L", tile_pixels)
-                    draw = ImageDraw.Draw(im)
-                    pixels = list(map(int, xy_pixels.flatten()))
-                    draw.line(pixels, fill=1, width=max(3, 6 * (z - 17)))
-                    aim = np.array(im)
-                    tile_counts += aim
-        return tile_counts
-
-    def _render_tile_image(
-        self,
-        x: int,
-        y: int,
-        z: int,
-        query: SearchQuery,
-    ) -> np.ndarray:
-        tile_pixels = (OSM_TILE_SIZE, OSM_TILE_SIZE)
-        tile_counts = np.zeros(tile_pixels)
-        tile_counts += self._get_counts(x, y, z, query)
-
-        tile_counts = np.sqrt(tile_counts) / 5
-        tile_counts[tile_counts > 1.0] = 1.0
-
-        cmap = pl.get_cmap(self._config.color_scheme_for_heatmap)
-        data_color = cmap(tile_counts)
-        data_color[data_color == cmap(0.0)] = 0.0  # remove background color
-
-        map_tile = np.array(get_tile(z, x, y, self._config.map_tile_url)) / 255
-        map_tile = convert_to_grayscale(map_tile)
-        map_tile = 1.0 - map_tile  # invert colors
-        for c in range(3):
-            map_tile[:, :, c] = (1.0 - data_color[:, :, c]) * map_tile[
-                :, :, c
-            ] + data_color[:, :, c]
-        return map_tile
-
-    def render_tile(self, x: int, y: int, z: int, query: SearchQuery) -> bytes:
-        f = io.BytesIO()
-        pl.imsave(
-            f,
-            self._render_tile_image(x, y, z, query),
-            format="png",
-        )
-        return bytes(f.getbuffer())
-
-    def download_heatmap(
-        self, north: float, east: float, south: float, west: float, query: SearchQuery
-    ) -> bytes:
-        geo_bounds = GeoBounds(south, west, north, east)
-        tile_bounds = get_sensible_zoom_level(geo_bounds, (4000, 4000))
-        pixel_bounds = PixelBounds.from_tile_bounds(tile_bounds)
-
-        background = np.zeros((*pixel_bounds.shape, 3))
-        for x in range(tile_bounds.x1, tile_bounds.x2):
-            for y in range(tile_bounds.y1, tile_bounds.y2):
-                tile = (
-                    np.array(
-                        get_tile(tile_bounds.zoom, x, y, self._config.map_tile_url)
-                    )
-                    / 255
-                )
-
-                i = y - tile_bounds.y1
-                j = x - tile_bounds.x1
-
-                background[
-                    i * OSM_TILE_SIZE : (i + 1) * OSM_TILE_SIZE,
-                    j * OSM_TILE_SIZE : (j + 1) * OSM_TILE_SIZE,
-                    :,
-                ] = self._render_tile_image(x, y, tile_bounds.zoom, query)
-
-        f = io.BytesIO()
-        pl.imsave(f, background, format="png")
-        return bytes(f.getbuffer())