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

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

geo_activity_playground/webui/settings/blueprint.py

@@ -1,262 +0,0 @@
-import shutil
-from typing import Optional
-
-from flask import Blueprint
-from flask import flash
-from flask import redirect
-from flask import render_template
-from flask import request
-from flask import url_for
-
-from geo_activity_playground.core.config import ConfigAccessor
-from geo_activity_playground.core.paths import _activity_enriched_dir
-from geo_activity_playground.webui.authenticator import Authenticator
-from geo_activity_playground.webui.authenticator import needs_authentication
-from geo_activity_playground.webui.settings.controller import SettingsController
-
-
-VEGA_COLOR_SCHEMES_CONTINUOUS = [
-    "lightgreyred",
-    "lightgreyteal",
-    "lightmulti",
-    "lightorange",
-    "lighttealblue",
-    "blues",
-    "tealblues",
-    "teals",
-    "greens",
-    "browns",
-    "oranges",
-    "reds",
-    "purples",
-    "warmgreys",
-    "greys",
-]
-
-MATPLOTLIB_COLOR_SCHEMES_CONTINUOUS = [
-    "afmhot",
-    "bone",
-    "cividis",
-    "copper",
-    "gist_gray",
-    "gist_heat",
-    "gnuplot2",
-    "gray",
-    "Greys_r",
-    "hot",
-    "inferno",
-    "magma",
-    "pink",
-    "plasma",
-    "viridis",
-]
-
-
-def int_or_none(s: str) -> Optional[int]:
-    if s:
-        try:
-            return int(s)
-        except ValueError as e:
-            flash(f"Cannot parse integer from {s}: {e}", category="danger")
-    return None
-
-
-def make_settings_blueprint(
-    config_accessor: ConfigAccessor, authenticator: Authenticator
-) -> Blueprint:
-    settings_controller = SettingsController(config_accessor)
-    blueprint = Blueprint("settings", __name__, template_folder="templates")
-
-    @blueprint.route("/")
-    @needs_authentication(authenticator)
-    def index():
-        return render_template("settings/index.html.j2")
-
-    @blueprint.route("/admin-password", methods=["GET", "POST"])
-    @needs_authentication(authenticator)
-    def admin_password():
-        if request.method == "POST":
-            settings_controller.save_admin_password(request.form["password"])
-        return render_template(
-            "settings/admin-password.html.j2",
-            **settings_controller.render_admin_password(),
-        )
-
-    @blueprint.route("/color-schemes", methods=["GET", "POST"])
-    @needs_authentication(authenticator)
-    def color_schemes():
-        if request.method == "POST":
-            config_accessor().color_scheme_for_counts = request.form[
-                "color_scheme_for_counts"
-            ]
-            config_accessor().color_scheme_for_kind = request.form[
-                "color_scheme_for_kind"
-            ]
-            config_accessor().color_scheme_for_heatmap = request.form[
-                "color_scheme_for_heatmap"
-            ]
-            config_accessor.save()
-            flash("Updated color schemes.", category="success")
-
-        return render_template(
-            "settings/color-schemes.html.j2",
-            color_scheme_for_counts=config_accessor().color_scheme_for_counts,
-            color_scheme_for_counts_avail=VEGA_COLOR_SCHEMES_CONTINUOUS,
-            color_scheme_for_kind=config_accessor().color_scheme_for_kind,
-            color_scheme_for_kind_avail=[
-                "accent",
-                "category10",
-                "category20",
-                "category20b",
-                "category20c",
-                "dark2",
-                "paired",
-                "pastel1",
-                "pastel2",
-                "set1",
-                "set2",
-                "set3",
-                "tableau10",
-                "tableau20",
-            ],
-            color_scheme_for_heatmap=config_accessor().color_scheme_for_heatmap,
-            color_scheme_for_heatmap_avail=MATPLOTLIB_COLOR_SCHEMES_CONTINUOUS,
-        )
-
-    @blueprint.route("/equipment-offsets", methods=["GET", "POST"])
-    @needs_authentication(authenticator)
-    def equipment_offsets():
-        if request.method == "POST":
-            equipments = request.form.getlist("equipment")
-            offsets = request.form.getlist("offset")
-            settings_controller.save_equipment_offsets(equipments, offsets)
-        return render_template(
-            "settings/equipment-offsets.html.j2",
-            **settings_controller.render_equipment_offsets(),
-        )
-
-    @blueprint.route("/heart-rate", methods=["GET", "POST"])
-    @needs_authentication(authenticator)
-    def heart_rate():
-        if request.method == "POST":
-            birth_year = int_or_none(request.form["birth_year"])
-            heart_rate_resting = int_or_none(request.form["heart_rate_resting"])
-            if heart_rate_resting is None:
-                heart_rate_resting = 0
-            heart_rate_maximum = int_or_none(request.form["heart_rate_maximum"])
-            settings_controller.save_heart_rate(
-                birth_year, heart_rate_resting, heart_rate_maximum
-            )
-        return render_template(
-            "settings/heart-rate.html.j2", **settings_controller.render_heart_rate()
-        )
-
-    @blueprint.route("/kind-renames", methods=["GET", "POST"])
-    @needs_authentication(authenticator)
-    def kind_renames():
-        if request.method == "POST":
-            rules_str = request.form["rules_str"]
-            rules = {}
-            try:
-                for line in rules_str.strip().split("\n"):
-                    first, second = line.split(" => ")
-                    rules[first.strip()] = second.strip()
-                config_accessor().kind_renames = rules
-                config_accessor.save()
-                flash(f"Kind renames updated.", category="success")
-                shutil.rmtree(_activity_enriched_dir)
-                return redirect(url_for("upload.reload"))
-            except ValueError as e:
-                flash(f"Cannot parse this. Please try again.", category="danger")
-        else:
-            rules_str = "\n".join(
-                f"{key} => {value}"
-                for key, value in config_accessor().kind_renames.items()
-            )
-        return render_template(
-            "settings/kind-renames.html.j2",
-            rules_str=rules_str,
-        )
-
-    @blueprint.route("/kinds-without-achievements", methods=["GET", "POST"])
-    @needs_authentication(authenticator)
-    def kinds_without_achievements():
-        if request.method == "POST":
-            kinds = request.form.getlist("kind")
-            settings_controller.save_kinds_without_achievements(kinds)
-        return render_template(
-            "settings/kinds-without-achievements.html.j2",
-            **settings_controller.render_kinds_without_achievements(),
-        )
-
-    @blueprint.route("/metadata-extraction", methods=["GET", "POST"])
-    @needs_authentication(authenticator)
-    def metadata_extraction():
-        if request.method == "POST":
-            regexes = request.form.getlist("regex")
-            settings_controller.save_metadata_extraction(regexes)
-        return render_template(
-            "settings/metadata-extraction.html.j2",
-            **settings_controller.render_metadata_extraction(),
-        )
-
-    @blueprint.route("/privacy-zones", methods=["GET", "POST"])
-    @needs_authentication(authenticator)
-    def privacy_zones():
-        if request.method == "POST":
-            zone_names = request.form.getlist("zone_name")
-            zone_geojsons = request.form.getlist("zone_geojson")
-            settings_controller.save_privacy_zones(zone_names, zone_geojsons)
-        return render_template(
-            "settings/privacy-zones.html.j2",
-            **settings_controller.render_privacy_zones(),
-        )
-
-    @blueprint.route("/segmentation", methods=["GET", "POST"])
-    @needs_authentication(authenticator)
-    def segmentation():
-        if request.method == "POST":
-            threshold = int(request.form.get("threshold", 0))
-            config_accessor().time_diff_threshold_seconds = threshold
-            config_accessor.save()
-            flash(f"Threshold set to {threshold}.", category="success")
-            shutil.rmtree(_activity_enriched_dir)
-            return redirect(url_for("upload.reload"))
-        return render_template(
-            "settings/segmentation.html.j2",
-            threshold=config_accessor().time_diff_threshold_seconds,
-        )
-
-    @blueprint.route("/sharepic", methods=["GET", "POST"])
-    @needs_authentication(authenticator)
-    def sharepic():
-        if request.method == "POST":
-            names = request.form.getlist("name")
-            settings_controller.save_sharepic(names)
-        return render_template(
-            "settings/sharepic.html.j2",
-            **settings_controller.render_sharepic(),
-        )
-
-    @blueprint.route("/strava", methods=["GET", "POST"])
-    @needs_authentication(authenticator)
-    def strava():
-        if request.method == "POST":
-            strava_client_id = request.form["strava_client_id"]
-            strava_client_secret = request.form["strava_client_secret"]
-            url = settings_controller.save_strava(
-                strava_client_id, strava_client_secret
-            )
-            return redirect(url)
-        return render_template(
-            "settings/strava.html.j2", **settings_controller.render_strava()
-        )
-
-    @blueprint.route("/strava-callback")
-    @needs_authentication(authenticator)
-    def strava_callback():
-        code = request.args.get("code", type=str)
-        settings_controller.save_strava_code(code)
-        return redirect(url_for(".strava"))
-
-    return blueprint