geo-activity-playground 1.3.2__tar.gz → 1.4.0__tar.gz

{geo_activity_playground-1.3.2 → geo_activity_playground-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: geo-activity-playground
-Version: 1.3.2
+Version: 1.4.0
 Summary: Analysis of geo data activities like rides, runs or hikes.
 License: MIT
 Author: Martin Ueding

{geo_activity_playground-1.3.2 → geo_activity_playground-1.4.0}/geo_activity_playground/__main__.py

@@ -4,6 +4,7 @@ import pathlib
 
 import coloredlogs
 
+from .core.photos import main_inspect_photo
 from .explorer.video import explorer_video_main
 from .heatmap_video import main_heatmap_video
 from .importers.strava_checkout import convert_strava_checkout
@@ -73,6 +74,13 @@ def main() -> None:
     subparser.add_argument("--video-height", type=int, default=1080)
     subparser.set_defaults(func=main_heatmap_video)
 
+    subparser = subparsers.add_parser(
+        "inspect-photo",
+        help="Extract EXIF data from the image to see how it would be imported",
+    )
+    subparser.add_argument("path", type=pathlib.Path)
+    subparser.set_defaults(func=main_inspect_photo)
+
     options = parser.parse_args()
     coloredlogs.install(
         fmt="%(asctime)s %(name)s %(levelname)s %(message)s",

geo_activity_playground-1.4.0/geo_activity_playground/core/photos.py

@@ -0,0 +1,39 @@
+import argparse
+import datetime
+import pathlib
+import pprint
+import zoneinfo
+
+import dateutil.parser
+import exifread
+
+
+def ratio_to_decimal(numbers: list[exifread.utils.Ratio]) -> float:
+    deg, min, sec = numbers.values
+    return deg.decimal() + min.decimal() / 60 + sec.decimal() / 3600
+
+
+def get_metadata_from_image(path: pathlib.Path) -> dict:
+    with open(path, "rb") as f:
+        tags = exifread.process_file(f)
+    metadata = {}
+    try:
+        metadata["latitude"] = ratio_to_decimal(tags["GPS GPSLatitude"])
+        metadata["longitude"] = ratio_to_decimal(tags["GPS GPSLongitude"])
+    except KeyError:
+        pass
+    try:
+        metadata["time"] = dateutil.parser.parse(
+            str(tags["EXIF DateTimeOriginal"])
+            + str(tags.get("EXIF OffsetTime", "+00:00"))
+        ).astimezone(zoneinfo.ZoneInfo("UTC"))
+    except KeyError:
+        pass
+
+    return metadata
+
+
+def main_inspect_photo(options: argparse.Namespace) -> None:
+    path: pathlib.Path = options.path
+    metadata = get_metadata_from_image(path)
+    pprint.pprint(metadata)

{geo_activity_playground-1.3.2 → geo_activity_playground-1.4.0}/geo_activity_playground/core/raster_map.py

@@ -283,3 +283,9 @@ class PastelImageTransform(ImageTransform):
         averaged_tile = np.sum(image * [0.2126, 0.7152, 0.0722], axis=2)
         grayscale_tile = np.dstack((averaged_tile, averaged_tile, averaged_tile))
         return self._factor * grayscale_tile + (1 - self._factor) * image
+
+
+class InverseGrayscaleImageTransform(ImageTransform):
+    def transform_image(self, image: np.ndarray) -> np.ndarray:
+        image = np.sum(image * [0.2126, 0.7152, 0.0722], axis=2)  # to grayscale
+        return 1 - np.dstack((image, image, image))  # to rgb

{geo_activity_playground-1.3.2 → geo_activity_playground-1.4.0}/geo_activity_playground/explorer/tile_visits.py

@@ -13,6 +13,8 @@ from tqdm import tqdm
 
 from ..core.activities import ActivityRepository
 from ..core.config import Config
+from ..core.datamodel import Activity
+from ..core.datamodel import DB
 from ..core.paths import atomic_open
 from ..core.tasks import try_load_pickle
 from ..core.tasks import work_tracker_path
@@ -20,10 +22,41 @@ from ..core.tasks import WorkTracker
 from ..core.tiles import adjacent_to
 from ..core.tiles import interpolate_missing_tile
 
+# import sqlalchemy as sa
+
+# from sqlalchemy import Column
+# from sqlalchemy import ForeignKey
+# from sqlalchemy import String
+# from sqlalchemy import Table
+# from sqlalchemy.orm import DeclarativeBase
+# from sqlalchemy.orm import Mapped
+# from sqlalchemy.orm import mapped_column
+# from sqlalchemy.orm import relationship
 
 logger = logging.getLogger(__name__)
 
 
+# class VisitedTile(DB.Model):
+#     __tablename__ = "visited_tiles"
+
+#     zoom: Mapped[int] = mapped_column(primary_key=True)
+#     x: Mapped[int] = mapped_column(primary_key=True)
+#     y: Mapped[int] = mapped_column(primary_key=True)
+
+#     first_activity_id: Mapped[int] = mapped_column(
+#         ForeignKey("Activity.id", name="first_activity_id"), nullable=True
+#     )
+#     first_activity: Mapped[Activity] = relationship(back_populates="activities")
+#     first_visit: Mapped[Optional[datetime.datetime]] = mapped_column(
+#         sa.DateTime, nullable=True
+#     )
+
+#     __table_args__ =  (
+#         sa.PrimaryKeyConstraint(zoom, x, y),
+#         {},
+#     )
+
+
 class TileInfo(TypedDict):
     activity_ids: set[int]
     first_time: datetime.datetime
@@ -58,7 +91,6 @@ class TileState(TypedDict):
     tile_visits: dict[int, dict[tuple[int, int], TileInfo]]
     tile_history: dict[int, pd.DataFrame]
     activities_per_tile: dict[int, dict[tuple[int, int], set[int]]]
-    processed_activities: set[int]
     evolution_state: dict[int, TileEvolutionState]
     version: int
 
@@ -99,7 +131,6 @@ def make_tile_state() -> TileState:
         "tile_visits": collections.defaultdict(make_defaultdict_dict),
         "tile_history": collections.defaultdict(pd.DataFrame),
         "activities_per_tile": collections.defaultdict(make_defaultdict_set),
-        "processed_activities": set(),
         "evolution_state": collections.defaultdict(TileEvolutionState),
         "version": TILE_STATE_VERSION,
     }
@@ -122,6 +153,9 @@ def _consistency_check(
 
     for zoom, tile_visits in tile_visit_accessor.tile_state["tile_visits"].items():
         for tile, meta in tile_visits.items():
+            if not pd.isna(meta["first_time"]) and meta["first_time"].tzinfo is None:
+                logger.info("Tile visits are stored without time zone.")
+                return False
             if meta["first_id"] not in present_activity_ids:
                 logger.info(f"Activity {meta['first_id']} have been deleted.")
                 return False
@@ -143,10 +177,35 @@ def compute_tile_visits_new(
         work_tracker.reset()
 
     for activity_id in tqdm(
-        work_tracker.filter(repository.get_activity_ids()), desc="Tile visits", delay=2
+        work_tracker.filter(repository.get_activity_ids()), desc="Tile visits", delay=1
     ):
         _process_activity(repository, tile_visit_accessor.tile_state, activity_id)
         work_tracker.mark_done(activity_id)
+
+    for zoom in reversed(range(20)):
+        tile_state = tile_visit_accessor.tile_state
+        if not (
+            tile_state["tile_history"][zoom]["time"].diff().dropna()
+            >= datetime.timedelta(seconds=0)
+        ).all():
+            logger.warning(
+                f"The order of the tile history at {zoom=} is not chronological, resetting."
+            )
+            new_tile_history_soa: dict[str, list] = {
+                "activity_id": [],
+                "time": [],
+                "tile_x": [],
+                "tile_y": [],
+            }
+            for tile, visit in tile_state["tile_visits"][zoom].items():
+                new_tile_history_soa["activity_id"].append(visit["first_id"])
+                new_tile_history_soa["time"].append(visit["first_time"])
+                new_tile_history_soa["tile_x"].append(tile[0])
+                new_tile_history_soa["tile_y"].append(tile[1])
+            tile_state["tile_history"][zoom] = pd.DataFrame(new_tile_history_soa)
+            tile_state["tile_history"][zoom].sort_values("time", inplace=True)
+            # Reset the evolution state.
+            tile_state["evolution_state"] = collections.defaultdict(TileEvolutionState)
     tile_visit_accessor.save()
     work_tracker.close()
 
@@ -258,7 +317,7 @@ def _compute_cluster_evolution(
     for index, row in tqdm(
         tiles.iloc[s.cluster_start :].iterrows(),
         desc=f"Cluster evolution for {zoom=}",
-        delay=2,
+        delay=1,
     ):
         new_clusters = False
         # Current tile.
@@ -337,7 +396,7 @@ def _compute_square_history(
     for index, row in tqdm(
         tiles.iloc[s.square_start :].iterrows(),
         desc=f"Square evolution for {zoom=}",
-        delay=2,
+        delay=1,
     ):
         tile = (row["tile_x"], row["tile_y"])
         x, y = tile

{geo_activity_playground-1.3.2 → geo_activity_playground-1.4.0}/geo_activity_playground/importers/strava_checkout.py

@@ -3,6 +3,7 @@ import logging
 import pathlib
 import shutil
 import sys
+import traceback
 import urllib.parse
 import zoneinfo
 from typing import Optional
@@ -22,6 +23,7 @@ from ..core.tasks import get_state
 from ..core.tasks import set_state
 from ..core.tasks import work_tracker_path
 from ..core.tasks import WorkTracker
+from .activity_parsers import ActivityParseError
 from .activity_parsers import read_activity
 from .csv_parser import parse_csv
 
@@ -182,12 +184,12 @@ def import_from_strava_checkout(config: Config) -> None:
     ]
 
     for activity_id in tqdm(activities_ids_to_parse, desc="Import from Strava export"):
-        work_tracker.mark_done(activity_id)
         index = all_activity_ids.index(activity_id)
         row = {column: table[column][index] for column in header}
 
         # Some manually recorded activities have no file name. Pandas reads that as a float. We skip those.
         if not row["Filename"]:
+            work_tracker.mark_done(activity_id)
             continue
 
         start_datetime = dateutil.parser.parse(
@@ -196,7 +198,14 @@ def import_from_strava_checkout(config: Config) -> None:
 
         activity_file = checkout_path / row["Filename"]
 
-        activity, time_series = read_activity(activity_file)
+        try:
+            activity, time_series = read_activity(activity_file)
+        except ActivityParseError as e:
+            logger.error(f"Error while parsing `{activity_file}`:")
+            traceback.print_exc()
+            continue
+
+        work_tracker.mark_done(activity_id)
 
         if not len(time_series):
             continue

{geo_activity_playground-1.3.2 → geo_activity_playground-1.4.0}/geo_activity_playground/webui/app.py

@@ -6,6 +6,7 @@ import os
 import pathlib
 import secrets
 import shutil
+import sys
 import threading
 import urllib.parse
 import uuid
@@ -32,6 +33,7 @@ from ..core.heart_rate import HeartRateZoneComputer
 from ..core.paths import TIME_SERIES_DIR
 from ..core.raster_map import GrayscaleImageTransform
 from ..core.raster_map import IdentityImageTransform
+from ..core.raster_map import InverseGrayscaleImageTransform
 from ..core.raster_map import PastelImageTransform
 from ..core.raster_map import TileGetter
 from ..explorer.tile_visits import TileVisitAccessor
@@ -85,6 +87,7 @@ def importer_thread(
 ) -> None:
     with app.app_context():
         scan_for_activities(repository, tile_visit_accessor, config)
+    logger.info("Importer thread is done.")
 
 
 def web_ui_main(
@@ -182,6 +185,7 @@ def web_ui_main(
         "color": IdentityImageTransform(),
         "grayscale": GrayscaleImageTransform(),
         "pastel": PastelImageTransform(),
+        "inverse_grayscale": InverseGrayscaleImageTransform(),
     }
     flasher = FlaskFlasher()
     heart_rate_zone_computer = HeartRateZoneComputer(config)
@@ -265,6 +269,9 @@ def web_ui_main(
         variables["photo_count"] = DB.session.scalar(
             sqlalchemy.select(sqlalchemy.func.count()).select_from(Photo)
         )
+        variables["python_version"] = (
+            f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+        )
         return variables
 
     app.run(host=host, port=port)

{geo_activity_playground-1.3.2 → geo_activity_playground-1.4.0}/geo_activity_playground/webui/blueprints/explorer_blueprint.py

@@ -26,6 +26,7 @@ from ...core.coordinates import Bounds
 from ...core.datamodel import Activity
 from ...core.datamodel import DB
 from ...core.raster_map import ImageTransform
+from ...core.raster_map import OSM_TILE_SIZE
 from ...core.raster_map import TileGetter
 from ...core.tiles import compute_tile
 from ...core.tiles import get_tile_upper_left_lat_lon
@@ -71,13 +72,14 @@ class MaxClusterColorStrategy(ColorStrategy):
         self, tile_xy: tuple[int, int], grayscale: np.ndarray
     ) -> np.ndarray:
         if tile_xy in self.max_cluster_members:
-            return blend_color(grayscale, np.array([[[55, 126, 184]]]) / 256, 0.3)
+            color = np.array([[[55, 126, 184, 70]]]) / 256
         elif tile_xy in self.evolution_state.memberships:
-            return blend_color(grayscale, np.array([[[77, 175, 74]]]) / 256, 0.3)
+            color = np.array([[[77, 175, 74, 70]]]) / 256
         elif tile_xy in self.tile_visits:
-            return blend_color(grayscale, 0.0, 0.3)
+            color = np.array([[[0, 0, 0, 70]]]) / 256
         else:
-            return grayscale
+            color = np.array([[[0, 0, 0, 0]]]) / 256
+        return np.broadcast_to(color, grayscale.shape)
 
 
 class ColorfulClusterColorStrategy(ColorStrategy):
@@ -98,11 +100,12 @@ class ColorfulClusterColorStrategy(ColorStrategy):
             m = hashlib.sha256()
             m.update(str(cluster_id).encode())
             d = int(m.hexdigest(), base=16) / (256.0**m.digest_size)
-            return blend_color(grayscale, np.array([[self._cmap(d)[:3]]]), 0.3)
+            color = np.array([[self._cmap(d)[:3] + (0.5,)]])
         elif tile_xy in self.tile_visits:
-            return blend_color(grayscale, 0.0, 0.3)
+            color = np.array([[[0, 0, 0, 70]]]) / 256
         else:
-            return grayscale
+            color = np.array([[[0, 0, 0, 0]]]) / 256
+        return np.broadcast_to(color, grayscale.shape)
 
 
 class VisitTimeColorStrategy(ColorStrategy):
@@ -120,11 +123,15 @@ class VisitTimeColorStrategy(ColorStrategy):
             relevant_time = (
                 tile_info["first_time"] if self.use_first else tile_info["last_time"]
             )
-            last_age_days = (today - relevant_time.date()).days
-            color = cmap(max(1 - last_age_days / (2 * 365), 0.0))
-            return blend_color(grayscale, np.array([[color[:3]]]), 0.3)
+            if pd.isna(relevant_time):
+                color = np.array([[[0, 0, 0, 70]]]) / 256
+            else:
+                last_age_days = (today - relevant_time.date()).days
+                color = cmap(max(1 - last_age_days / (2 * 365), 0.0))
+                color = np.array([[color[:3] + (0.5,)]])
         else:
-            return grayscale
+            color = np.array([[[0, 0, 0, 0]]]) / 256
+        return np.broadcast_to(color, grayscale.shape)
 
 
 class NumVisitsColorStrategy(ColorStrategy):
@@ -138,9 +145,10 @@ class NumVisitsColorStrategy(ColorStrategy):
             cmap = matplotlib.colormaps["viridis"]
             tile_info = self.tile_visits[tile_xy]
             color = cmap(min(len(tile_info["activity_ids"]) / 50, 1.0))
-            return blend_color(grayscale, np.array([[color[:3]]]), 0.3)
+            color = np.array([[color[:3] + (0.5,)]])
         else:
-            return grayscale
+            color = np.array([[[0, 0, 0, 0]]]) / 256
+        return np.broadcast_to(color, grayscale.shape)
 
 
 def make_explorer_blueprint(
@@ -159,7 +167,7 @@ def make_explorer_blueprint(
             config_accessor().explorer_zoom_levels.append(zoom)
             config_accessor().explorer_zoom_levels.sort()
             config_accessor.save()
-            compute_tile_evolution(tile_visit_accessor, config_accessor())
+            compute_tile_evolution(tile_visit_accessor.tile_state, config_accessor())
             flash(f"Enabled {zoom=} for explorer tiles.", category="success")
         else:
             flash(f"{zoom=} is not valid, must be between 0 and 19.", category="danger")
@@ -264,10 +272,11 @@ def make_explorer_blueprint(
         tile_visits = tile_visit_accessor.tile_state["tile_visits"][zoom]
         evolution_state = tile_visit_accessor.tile_state["evolution_state"][zoom]
 
-        map_tile = np.array(tile_getter.get_tile(z, x, y)) / 255
-        grayscale = image_transforms["grayscale"].transform_image(map_tile)
+        # map_tile = np.array(tile_getter.get_tile(z, x, y)) / 255
+        # grayscale = image_transforms["grayscale"].transform_image(map_tile)
+        grayscale = np.zeros((OSM_TILE_SIZE, OSM_TILE_SIZE, 4), dtype=np.float32)
         square_line_width = 3
-        square_color = np.array([[[228, 26, 28]]]) / 256
+        square_color = np.array([[[228, 26, 28, 255]]]) / 256
 
         color_strategy_name = request.args.get("color_strategy", "colorful_cluster")
         if color_strategy_name == "default":
@@ -311,9 +320,7 @@ def make_explorer_blueprint(
                         <= tile_y
                         < evolution_state.square_y + evolution_state.max_square_size
                     ):
-                        result[:, 0:square_line_width] = blend_color(
-                            result[:, 0:square_line_width], square_color, 0.5
-                        )
+                        result[:, 0:square_line_width] = square_color
                     if (
                         y % factor == 0
                         and tile_y == evolution_state.square_y
@@ -321,10 +328,7 @@ def make_explorer_blueprint(
                         <= tile_x
                         < evolution_state.square_x + evolution_state.max_square_size
                     ):
-                        result[0:square_line_width, :] = blend_color(
-                            result[0:square_line_width, :], square_color, 0.5
-                        )
-
+                        result[0:square_line_width, :] = square_color
                     if (
                         (x + 1) % factor == 0
                         and (x + 1) // factor
@@ -333,9 +337,7 @@ def make_explorer_blueprint(
                         <= tile_y
                         < evolution_state.square_y + evolution_state.max_square_size
                     ):
-                        result[:, -square_line_width:] = blend_color(
-                            result[:, -square_line_width:], square_color, 0.5
-                        )
+                        result[:, -square_line_width:] = square_color
                     if (
                         (y + 1) % factor == 0
                         and (y + 1) // factor
@@ -344,9 +346,7 @@ def make_explorer_blueprint(
                         <= tile_x
                         < evolution_state.square_x + evolution_state.max_square_size
                     ):
-                        result[-square_line_width:, :] = blend_color(
-                            result[-square_line_width:, :], square_color, 0.5
-                        )
+                        result[-square_line_width:, :] = square_color
         else:
             result = grayscale
             factor = 2 ** (zoom - z)
@@ -381,14 +381,7 @@ def make_explorer_blueprint(
                                 result[
                                     yo * width : (yo + 1) * width,
                                     xo * width : xo * width + square_line_width,
-                                ] = blend_color(
-                                    result[
-                                        yo * width : (yo + 1) * width,
-                                        xo * width : xo * width + square_line_width,
-                                    ],
-                                    square_color,
-                                    0.5,
-                                )
+                                ] = square_color
                             if (
                                 tile_y == evolution_state.square_y
                                 and evolution_state.square_x
@@ -399,14 +392,7 @@ def make_explorer_blueprint(
                                 result[
                                     yo * width : yo * width + square_line_width,
                                     xo * width : (xo + 1) * width,
-                                ] = blend_color(
-                                    result[
-                                        yo * width : yo * width + square_line_width,
-                                        xo * width : (xo + 1) * width,
-                                    ],
-                                    square_color,
-                                    0.5,
-                                )
+                                ] = square_color
 
                             if (
                                 tile_x + 1
@@ -421,15 +407,7 @@ def make_explorer_blueprint(
                                     yo * width : (yo + 1) * width,
                                     (xo + 1) * width
                                     - square_line_width : (xo + 1) * width,
-                                ] = blend_color(
-                                    result[
-                                        yo * width : (yo + 1) * width,
-                                        (xo + 1) * width
-                                        - square_line_width : (xo + 1) * width,
-                                    ],
-                                    square_color,
-                                    0.5,
-                                )
+                                ] = square_color
 
                             if (
                                 tile_y + 1
@@ -444,15 +422,7 @@ def make_explorer_blueprint(
                                     (yo + 1) * width
                                     - square_line_width : (yo + 1) * width,
                                     xo * width : (xo + 1) * width,
-                                ] = blend_color(
-                                    result[
-                                        (yo + 1) * width
-                                        - square_line_width : (yo + 1) * width,
-                                        xo * width : (xo + 1) * width,
-                                    ],
-                                    square_color,
-                                    0.5,
-                                )
+                                ] = square_color
                     if width >= 64:
                         result[yo * width, :, :] = 0.5
                         result[:, xo * width, :] = 0.5

{geo_activity_playground-1.3.2 → geo_activity_playground-1.4.0}/geo_activity_playground/webui/blueprints/hall_of_fame_blueprint.py

@@ -1,4 +1,5 @@
 import collections
+import logging
 
 import pandas as pd
 from flask import Blueprint
@@ -12,6 +13,9 @@ from ..search_util import search_query_from_form
 from ..search_util import SearchQueryHistory
 
 
+logger = logging.getLogger(__name__)
+
+
 def make_hall_of_fame_blueprint(
     repository: ActivityRepository,
     search_query_history: SearchQueryHistory,
@@ -73,7 +77,14 @@ def _nominate_activities_inner(
 
     for variable, title, format_str in ratings:
         if variable in meta.columns and not pd.isna(meta[variable]).all():
-            i = meta[variable].idxmax()
-            value = meta.loc[i, variable]
-            format_applied = format_str.format(value)
-            nominations[i].append(f"{title}{title_suffix}: {format_applied}")
+            try:
+                i = meta[variable].idxmax()
+            except ValueError as e:
+                print(meta[variable].tolist())
+                print(f"{meta[variable].dtype=}")
+                logger.error(f"Trying to work with {variable=}.")
+                logger.error(f"We got a ValueError: {e}")
+            else:
+                value = meta.loc[i, variable]
+                format_applied = format_str.format(value)
+                nominations[i].append(f"{title}{title_suffix}: {format_applied}")

{geo_activity_playground-1.3.2 → geo_activity_playground-1.4.0}/geo_activity_playground/webui/blueprints/heatmap_blueprint.py

@@ -221,13 +221,6 @@ def _render_tile_image(
 
     cmap = pl.get_cmap(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, 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
+    data_color[tile_counts > 0, 3] = 0.8
+    data_color[tile_counts == 0, 3] = 0.0
+    return data_color

{geo_activity_playground-1.3.2 → geo_activity_playground-1.4.0}/geo_activity_playground/webui/blueprints/photo_blueprint.py

@@ -2,8 +2,6 @@ import datetime
 import pathlib
 import uuid
 
-import dateutil.parser
-import exifread
 import geojson
 import sqlalchemy
 from flask import Blueprint
@@ -21,36 +19,13 @@ from ...core.datamodel import Activity
 from ...core.datamodel import DB
 from ...core.datamodel import Photo
 from ...core.paths import PHOTOS_DIR
+from ...core.photos import get_metadata_from_image
 from ..authenticator import Authenticator
 from ..authenticator import needs_authentication
 from ..flasher import Flasher
 from ..flasher import FlashTypes
 
 
-def ratio_to_decimal(numbers: list[exifread.utils.Ratio]) -> float:
-    deg, min, sec = numbers.values
-    return deg.decimal() + min.decimal() / 60 + sec.decimal() / 3600
-
-
-def get_metadata_from_image(path: pathlib.Path) -> dict:
-    with open(path, "rb") as f:
-        tags = exifread.process_file(f)
-    metadata = {}
-    try:
-        metadata["latitude"] = ratio_to_decimal(tags["GPS GPSLatitude"])
-        metadata["longitude"] = ratio_to_decimal(tags["GPS GPSLongitude"])
-    except KeyError:
-        pass
-    try:
-        metadata["time"] = datetime.datetime.strptime(
-            str(tags["EXIF DateTimeOriginal"]), "%Y:%m:%d %H:%M:%S"
-        )
-    except KeyError:
-        pass
-
-    return metadata
-
-
 def make_photo_blueprint(
     config_accessor: ConfigAccessor, authenticator: Authenticator, flasher: Flasher
 ) -> Blueprint: