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

geo_activity_playground/core/datamodel.py

@@ -0,0 +1,257 @@
+import datetime
+import logging
+from typing import Any
+from typing import TypedDict
+
+import numpy as np
+import pandas as pd
+import sqlalchemy
+import sqlalchemy as sa
+from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy import ForeignKey
+from sqlalchemy import String
+from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy.orm import Mapped
+from sqlalchemy.orm import mapped_column
+from sqlalchemy.orm import relationship
+
+from .config import Config
+from .paths import time_series_dir
+
+
+logger = logging.getLogger(__name__)
+
+
+class ActivityMeta(TypedDict):
+    average_speed_elapsed_kmh: float
+    average_speed_moving_kmh: float
+    calories: float
+    commute: bool
+    consider_for_achievements: bool
+    distance_km: float
+    elapsed_time: datetime.timedelta
+    elevation_gain: float
+    end_latitude: float
+    end_longitude: float
+    equipment: str
+    id: int
+    kind: str
+    moving_time: datetime.timedelta
+    name: str
+    path: str
+    start_latitude: float
+    start_longitude: float
+    start: np.datetime64
+    steps: int
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+DB = SQLAlchemy(model_class=Base)
+
+
+class Activity(DB.Model):
+    __tablename__ = "activities"
+
+    # Housekeeping data:
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column(sa.String, nullable=False)
+    distance_km: Mapped[float] = mapped_column(sa.Float, nullable=False)
+
+    # Where it comes from:
+    path: Mapped[str] = mapped_column(sa.String, nullable=True)
+    upstream_id: Mapped[str] = mapped_column(sa.String, nullable=True)
+
+    # Crop data:
+    index_begin: Mapped[int] = mapped_column(sa.Integer, nullable=True)
+    index_end: Mapped[int] = mapped_column(sa.Integer, nullable=True)
+
+    # Temporal data:
+    start: Mapped[datetime.datetime] = mapped_column(sa.DateTime, nullable=True)
+    elapsed_time: Mapped[datetime.timedelta] = mapped_column(sa.Interval, nullable=True)
+    moving_time: Mapped[datetime.timedelta] = mapped_column(sa.Interval, nullable=True)
+
+    # Geographic data:
+    start_latitude: Mapped[float] = mapped_column(sa.Float, nullable=True)
+    start_longitude: Mapped[float] = mapped_column(sa.Float, nullable=True)
+    end_latitude: Mapped[float] = mapped_column(sa.Float, nullable=True)
+    end_longitude: Mapped[float] = mapped_column(sa.Float, nullable=True)
+
+    # Elevation data:
+    elevation_gain: Mapped[float] = mapped_column(sa.Float, nullable=True)
+    start_elevation: Mapped[float] = mapped_column(sa.Float, nullable=True)
+    end_elevation: Mapped[float] = mapped_column(sa.Float, nullable=True)
+
+    # Health data:
+    calories: Mapped[int] = mapped_column(sa.Integer, nullable=True)
+    steps: Mapped[int] = mapped_column(sa.Integer, nullable=True)
+
+    # Tile achievements:
+    num_new_tiles_14: Mapped[int] = mapped_column(sa.Integer, nullable=True)
+    num_new_tiles_17: Mapped[int] = mapped_column(sa.Integer, nullable=True)
+
+    # References to other tables:
+    equipment_id: Mapped[int] = mapped_column(
+        ForeignKey("equipments.id", name="equipment_id"), nullable=True
+    )
+    equipment: Mapped["Equipment"] = relationship(back_populates="activities")
+    kind_id: Mapped[int] = mapped_column(
+        ForeignKey("kinds.id", name="kind_id"), nullable=True
+    )
+    kind: Mapped["Kind"] = relationship(back_populates="activities")
+
+    def __getitem__(self, item) -> Any:
+        return self.to_dict()[item]
+
+    def __str__(self) -> str:
+        return f"{self.start} {self.name}"
+
+    @property
+    def average_speed_moving_kmh(self) -> float:
+        return self.distance_km / (self.moving_time.total_seconds() / 3_600)
+
+    @property
+    def average_speed_elapsed_kmh(self) -> float:
+        return self.distance_km / (self.elapsed_time.total_seconds() / 3_600)
+
+    @property
+    def raw_time_series(self) -> pd.DataFrame:
+        path = time_series_dir() / f"{self.id}.parquet"
+        try:
+            return pd.read_parquet(path)
+        except OSError as e:
+            logger.error(f"Error while reading {path}, deleting cache file …")
+            path.unlink(missing_ok=True)
+            raise
+
+    @property
+    def time_series(self) -> pd.DataFrame:
+        if self.index_begin or self.index_end:
+            return self.raw_time_series.iloc[
+                self.index_begin or 0 : self.index_end or -1
+            ]
+        else:
+            return self.raw_time_series
+
+    def to_dict(self) -> ActivityMeta:
+        equipment = self.equipment.name if self.equipment is not None else "Unknown"
+        kind = self.kind.name if self.kind is not None else "Unknown"
+        consider_for_achievements = (
+            self.kind.consider_for_achievements if self.kind is not None else True
+        )
+        return ActivityMeta(
+            id=self.id,
+            name=self.name,
+            path=self.path,
+            distance_km=self.distance_km,
+            start=self.start,
+            elapsed_time=self.elapsed_time,
+            moving_time=self.moving_time,
+            start_latitude=self.start_latitude,
+            start_longitude=self.start_longitude,
+            end_latitude=self.end_latitude,
+            end_longitude=self.end_longitude,
+            elevation_gain=self.elevation_gain,
+            start_elevation=self.start_elevation,
+            end_elevation=self.end_elevation,
+            calories=self.calories,
+            steps=self.steps,
+            num_new_tiles_14=self.num_new_tiles_14,
+            num_new_tiles_17=self.num_new_tiles_17,
+            equipment=equipment,
+            kind=kind,
+            average_speed_moving_kmh=self.average_speed_moving_kmh,
+            average_speed_elapsed_kmh=self.average_speed_elapsed_kmh,
+            consider_for_achievements=consider_for_achievements,
+        )
+
+
+class Equipment(DB.Model):
+    __tablename__ = "equipments"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+    name: Mapped[str] = mapped_column(String)
+    offset_km: Mapped[int] = mapped_column(sa.Integer, nullable=False, default=0)
+
+    activities: Mapped[list["Activity"]] = relationship(
+        back_populates="equipment", cascade="all, delete-orphan"
+    )
+    default_for_kinds: Mapped[list["Kind"]] = relationship(
+        back_populates="default_equipment", cascade="all, delete-orphan"
+    )
+
+    def __str__(self) -> str:
+        return f"{self.name} ({self.offset_km} km)"
+
+    __table_args__ = (sa.UniqueConstraint("name", name="equipments_name"),)
+
+
+class Kind(DB.Model):
+    __tablename__ = "kinds"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+    name: Mapped[str] = mapped_column(String)
+    consider_for_achievements: Mapped[bool] = mapped_column(
+        sa.Boolean, default=True, nullable=False
+    )
+
+    activities: Mapped[list["Activity"]] = relationship(
+        back_populates="kind", cascade="all, delete-orphan"
+    )
+    default_equipment_id: Mapped[int] = mapped_column(
+        ForeignKey("equipments.id", name="default_equipment_id"), nullable=True
+    )
+    default_equipment: Mapped["Equipment"] = relationship(
+        back_populates="default_for_kinds"
+    )
+
+    __table_args__ = (sa.UniqueConstraint("name", name="kinds_name"),)
+
+
+class SquarePlannerBookmark(DB.Model):
+    __tablename__ = "square_planner_bookmarks"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+    zoom: Mapped[int] = mapped_column(sa.Integer, nullable=False)
+    x: Mapped[int] = mapped_column(sa.Integer, nullable=False)
+    y: Mapped[int] = mapped_column(sa.Integer, nullable=False)
+    size: Mapped[int] = mapped_column(sa.Integer, nullable=False)
+    name: Mapped[str] = mapped_column(sa.String, nullable=False)
+
+    __table_args__ = (sa.UniqueConstraint("zoom", "x", "y", "size", name="kinds_name"),)
+
+
+def get_or_make_kind(name: str, config: Config) -> Kind:
+    kinds = DB.session.scalars(sqlalchemy.select(Kind).where(Kind.name == name)).all()
+    if kinds:
+        assert len(kinds) == 1, f"There must be only one kind with name '{name}'."
+        return kinds[0]
+    else:
+        kind = Kind(
+            name=name,
+            consider_for_achievements=config.kinds_without_achievements.get(name, True),
+        )
+        DB.session.add(kind)
+        return kind
+
+
+def get_or_make_equipment(name: str, config: Config) -> Equipment:
+    equipments = DB.session.scalars(
+        sqlalchemy.select(Equipment).where(Equipment.name == name)
+    ).all()
+    if equipments:
+        assert (
+            len(equipments) == 1
+        ), f"There must be only one equipment with name '{name}'."
+        return equipments[0]
+    else:
+        equipment = Equipment(
+            name=name, offset_km=config.equipment_offsets.get(name, 0)
+        )
+        DB.session.add(equipment)
+        return equipment

geo_activity_playground/core/enrichment.py

@@ -1,128 +1,126 @@
 import datetime
 import logging
 import pickle
-from typing import Any
 from typing import Optional
 
 import numpy as np
 import pandas as pd
+import sqlalchemy
 from tqdm import tqdm
 
-from geo_activity_playground.core.activities import ActivityMeta
-from geo_activity_playground.core.activities import make_activity_meta
-from geo_activity_playground.core.config import Config
-from geo_activity_playground.core.coordinates import get_distance
-from geo_activity_playground.core.paths import activity_enriched_meta_dir
-from geo_activity_playground.core.paths import activity_enriched_time_series_dir
-from geo_activity_playground.core.paths import activity_extracted_meta_dir
-from geo_activity_playground.core.paths import activity_extracted_time_series_dir
-from geo_activity_playground.core.tiles import compute_tile_float
-from geo_activity_playground.core.time_conversion import convert_to_datetime_ns
+from .config import Config
+from .coordinates import get_distance
+from .datamodel import Activity
+from .datamodel import ActivityMeta
+from .datamodel import DB
+from .datamodel import get_or_make_equipment
+from .datamodel import get_or_make_kind
+from .paths import activity_extracted_meta_dir
+from .paths import activity_extracted_time_series_dir
+from .paths import time_series_dir
+from .tiles import compute_tile_float
+from .time_conversion import convert_to_datetime_ns
 
 logger = logging.getLogger(__name__)
 
 
-def enrich_activities(config: Config) -> None:
-    # Delete removed activities.
-    for enriched_metadata_path in activity_enriched_meta_dir().glob("*.pickle"):
-        if not (activity_extracted_meta_dir() / enriched_metadata_path.name).exists():
-            logger.warning(f"Deleting {enriched_metadata_path}")
-            enriched_metadata_path.unlink()
-    for enriched_time_series_path in activity_enriched_time_series_dir().glob(
-        "*.parquet"
-    ):
-        if not (
-            activity_extracted_time_series_dir() / enriched_time_series_path.name
-        ).exists():
-            logger.warning(f"Deleting {enriched_time_series_path}")
-            enriched_time_series_path.unlink()
-
-    # Get new metadata paths.
-    new_extracted_metadata_paths = []
-    for extracted_metadata_path in activity_extracted_meta_dir().glob("*.pickle"):
-        enriched_metadata_path = (
-            activity_enriched_meta_dir() / extracted_metadata_path.name
+def populate_database_from_extracted(config: Config) -> None:
+    available_ids = {
+        int(path.stem) for path in activity_extracted_meta_dir().glob("*.pickle")
+    }
+    present_ids = {
+        int(elem)
+        for elem in DB.session.scalars(sqlalchemy.select(Activity.upstream_id)).all()
+        if elem
+    }
+    new_ids = available_ids - present_ids
+
+    for upstream_id in tqdm(new_ids, desc="Importing new activities into database"):
+        extracted_metadata_path = (
+            activity_extracted_meta_dir() / f"{upstream_id}.pickle"
         )
-        if (
-            not enriched_metadata_path.exists()
-            or enriched_metadata_path.stat().st_mtime
-            < extracted_metadata_path.stat().st_mtime
-        ):
-            extracted_time_series_path = (
-                activity_extracted_time_series_dir()
-                / f"{extracted_metadata_path.stem}.parquet"
-            )
-            if extracted_time_series_path.exists():
-                new_extracted_metadata_paths.append(extracted_metadata_path)
-            else:
-                logger.error(
-                    f"Extracted activity metadata {extracted_metadata_path} is lacking the corresponding time series path {extracted_time_series_path}. Likely that is an activity without location data. Deleting this."
-                )
-                extracted_metadata_path.unlink()
-
-    for extracted_metadata_path in tqdm(
-        new_extracted_metadata_paths, desc="Enrich new activity data"
-    ):
-        # Read extracted data.
-        activity_id = extracted_metadata_path.stem
+        with open(extracted_metadata_path, "rb") as f:
+            extracted_metadata: ActivityMeta = pickle.load(f)
+
         extracted_time_series_path = (
-            activity_extracted_time_series_dir() / f"{activity_id}.parquet"
+            activity_extracted_time_series_dir() / f"{upstream_id}.parquet"
         )
         time_series = pd.read_parquet(extracted_time_series_path)
-        with open(extracted_metadata_path, "rb") as f:
-            extracted_metadata = pickle.load(f)
-
-        metadata = make_activity_meta()
-        metadata.update(extracted_metadata)
 
         # Skip activities that don't have geo information attached to them. This shouldn't happen, though.
         if "latitude" not in time_series.columns:
             logger.warning(
-                f"Activity {metadata} doesn't have latitude/longitude information. Ignoring this one."
+                f"Activity {upstream_id} doesn't have latitude/longitude information. Ignoring this one."
             )
             continue
 
-        # Rename kinds if needed.
-        if metadata["kind"] in config.kind_renames:
-            metadata["kind"] = config.kind_renames[metadata["kind"]]
-
-        # Enrich time series.
-        if metadata["kind"] in config.kinds_without_achievements:
-            metadata["consider_for_achievements"] = False
         time_series = _embellish_single_time_series(
-            time_series, metadata.get("start", None), config.time_diff_threshold_seconds
+            time_series,
+            extracted_metadata.get("start", None),
+            config.time_diff_threshold_seconds,
         )
-        metadata.update(_get_metadata_from_timeseries(time_series))
 
-        # Write enriched data.
-        enriched_metadata_path = activity_enriched_meta_dir() / f"{activity_id}.pickle"
-        enriched_time_series_path = (
-            activity_enriched_time_series_dir() / f"{activity_id}.parquet"
+        kind_name = extracted_metadata.get("kind", None)
+        if kind_name:
+            # Rename kinds if needed.
+            if kind_name in config.kind_renames:
+                kind_name = config.kind_renames[kind_name]
+            kind = get_or_make_kind(kind_name, config)
+        else:
+            kind = None
+
+        equipment_name = extracted_metadata.get("equipment", None)
+        if equipment_name:
+            equipment = get_or_make_equipment(equipment_name, config)
+        elif kind:
+            equipment = kind.default_equipment
+        else:
+            equipment = None
+
+        activity = Activity(
+            name=extracted_metadata.get("name", "Name Placeholder"),
+            distance_km=0,
+            equipment=equipment,
+            kind=kind,
+            calories=extracted_metadata.get("calories", None),
+            elevation_gain=extracted_metadata.get("elevation_gain", None),
+            steps=extracted_metadata.get("steps", None),
+            path=extracted_metadata.get("path", None),
+            upstream_id=upstream_id,
         )
-        with open(enriched_metadata_path, "wb") as f:
-            pickle.dump(metadata, f)
-        time_series.to_parquet(enriched_time_series_path)
 
+        update_via_time_series(activity, time_series)
 
-def _get_metadata_from_timeseries(timeseries: pd.DataFrame) -> ActivityMeta:
-    metadata = ActivityMeta()
+        DB.session.add(activity)
+        DB.session.commit()
 
-    # Extract some meta data from the time series.
-    metadata["start"] = timeseries["time"].iloc[0]
-    metadata["elapsed_time"] = timeseries["time"].iloc[-1] - timeseries["time"].iloc[0]
-    metadata["distance_km"] = timeseries["distance_km"].iloc[-1]
-    if "calories" in timeseries.columns:
-        metadata["calories"] = timeseries["calories"].iloc[-1]
-    metadata["moving_time"] = _compute_moving_time(timeseries)
+        enriched_time_series_path = time_series_dir() / f"{activity.id}.parquet"
+        time_series.to_parquet(enriched_time_series_path)
 
-    metadata["start_latitude"] = timeseries["latitude"].iloc[0]
-    metadata["end_latitude"] = timeseries["latitude"].iloc[-1]
-    metadata["start_longitude"] = timeseries["longitude"].iloc[0]
-    metadata["end_longitude"] = timeseries["longitude"].iloc[-1]
-    if "elevation_gain_cum" in timeseries.columns:
-        metadata["elevation_gain"] = timeseries["elevation_gain_cum"].iloc[-1]
 
-    return metadata
+def update_via_time_series(
+    activity: Activity, time_series: pd.DataFrame
+) -> ActivityMeta:
+    activity.start = time_series["time"].iloc[0]
+    activity.elapsed_time = time_series["time"].iloc[-1] - time_series["time"].iloc[0]
+    activity.distance_km = (
+        time_series["distance_km"].iloc[-1] - time_series["distance_km"].iloc[0]
+    )
+    if "calories" in time_series.columns:
+        activity.calories = (
+            time_series["calories"].iloc[-1] - time_series["calories"].iloc[0]
+        )
+    activity.moving_time = _compute_moving_time(time_series)
+
+    activity.start_latitude = time_series["latitude"].iloc[0]
+    activity.end_latitude = time_series["latitude"].iloc[-1]
+    activity.start_longitude = time_series["longitude"].iloc[0]
+    activity.end_longitude = time_series["longitude"].iloc[-1]
+    if "elevation_gain_cum" in time_series.columns:
+        elevation_gain_cum = time_series["elevation_gain_cum"].fillna(0)
+        activity.elevation_gain = (
+            elevation_gain_cum.iloc[-1] - elevation_gain_cum.iloc[0]
+        )
 
 
 def _compute_moving_time(time_series: pd.DataFrame) -> datetime.timedelta:

geo_activity_playground/core/heart_rate.py

@@ -1,10 +1,9 @@
 import datetime
 import math
-from typing import Optional
 
 import pandas as pd
 
-from geo_activity_playground.core.config import Config
+from .config import Config
 
 
 class HeartRateZoneComputer:

geo_activity_playground/core/paths.py

@@ -1,11 +1,12 @@
-"""
-Paths within the playground and cache.
-"""
 import contextlib
 import functools
 import pathlib
 import typing
 
+"""
+Paths within the playground and cache.
+"""
+
 
 def dir_wrapper(path: pathlib.Path) -> typing.Callable[[], pathlib.Path]:
     def wrapper() -> pathlib.Path:
@@ -48,16 +49,13 @@ _tiles_per_time_series = _cache_dir / "Tiles" / "Tiles Per Time Series"
 
 _strava_api_dir = pathlib.Path("Strava API")
 _strava_dynamic_config_path = _strava_api_dir / "strava-client-id.json"
-
 _strava_last_activity_date_path = _cache_dir / "strava-last-activity-date.json"
-
 _new_config_file = pathlib.Path("config.json")
-
 _activity_meta_override_dir = pathlib.Path("Metadata Override")
+_time_series_dir = pathlib.Path("Time Series")
 
 
 cache_dir = dir_wrapper(_cache_dir)
-
 activity_extracted_dir = dir_wrapper(_activity_extracted_dir)
 activity_extracted_meta_dir = dir_wrapper(_activity_extracted_meta_dir)
 activity_extracted_time_series_dir = dir_wrapper(_activity_extracted_time_series_dir)
@@ -66,6 +64,7 @@ activity_enriched_time_series_dir = dir_wrapper(_activity_enriched_time_series_d
 tiles_per_time_series = dir_wrapper(_tiles_per_time_series)
 strava_api_dir = dir_wrapper(_strava_api_dir)
 activity_meta_override_dir = dir_wrapper(_activity_meta_override_dir)
+time_series_dir = dir_wrapper(_time_series_dir)
 
 activities_file = file_wrapper(_activities_file)
 strava_dynamic_config_path = file_wrapper(_strava_dynamic_config_path)

geo_activity_playground/core/raster_map.py

@@ -1,4 +1,4 @@
-import collections
+import abc
 import dataclasses
 import functools
 import logging
@@ -10,9 +10,8 @@ import numpy as np
 import requests
 from PIL import Image
 
-from geo_activity_playground.core.config import Config
-from geo_activity_playground.core.tiles import compute_tile_float
-from geo_activity_playground.core.tiles import get_tile_upper_left_lat_lon
+from .config import Config
+from .tiles import compute_tile_float
 
 
 logger = logging.getLogger(__name__)
@@ -244,3 +243,43 @@ def download_file(url: str, destination: pathlib.Path):
     with open(destination, "wb") as f:
         f.write(r.content)
     time.sleep(0.1)
+
+
+class TileGetter:
+    def __init__(self, map_tile_url: str):
+        self._map_tile_url = map_tile_url
+
+    def get_tile(
+        self,
+        z: int,
+        x: int,
+        y: int,
+    ):
+        return get_tile(z, x, y, self._map_tile_url)
+
+
+class ImageTransform:
+    @abc.abstractmethod
+    def transform_image(self, image: np.ndarray) -> np.ndarray:
+        pass
+
+
+class IdentityImageTransform(ImageTransform):
+    def transform_image(self, image: np.ndarray) -> np.ndarray:
+        return image
+
+
+class GrayscaleImageTransform(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 np.dstack((image, image, image))  # to rgb
+
+
+class PastelImageTransform(ImageTransform):
+    def __init__(self, factor: float = 0.7):
+        self._factor = factor
+
+    def transform_image(self, image: np.ndarray) -> np.ndarray:
+        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

geo_activity_playground/core/similarity.py

@@ -1,5 +1,4 @@
 import pathlib
-import pickle
 
 import imagehash
 import numpy as np
@@ -10,7 +9,7 @@ from tqdm import tqdm
 
 from .activities import ActivityRepository
 from .coordinates import get_distance
-from geo_activity_playground.core.tasks import stored_object
+from .tasks import stored_object
 
 
 fingerprint_path = pathlib.Path("Cache/activity_fingerprints.pickle")

geo_activity_playground/core/tasks.py

@@ -8,8 +8,8 @@ from typing import Generic
 from typing import Sequence
 from typing import TypeVar
 
-from geo_activity_playground.core.paths import atomic_open
-from geo_activity_playground.core.paths import cache_dir
+from .paths import atomic_open
+from .paths import cache_dir
 
 
 T = TypeVar("T")

geo_activity_playground/core/test_meta_search.py

@@ -2,9 +2,9 @@ import datetime
 
 import pandas as pd
 
-from geo_activity_playground.core.meta_search import _make_mask
-from geo_activity_playground.core.meta_search import apply_search_query
-from geo_activity_playground.core.meta_search import SearchQuery
+from .meta_search import _make_mask
+from .meta_search import apply_search_query
+from .meta_search import SearchQuery
 
 
 def test_empty_query() -> None:

geo_activity_playground/core/test_summary_stats.py

@@ -3,7 +3,7 @@ import datetime
 import pandas as pd
 import pytest
 
-from geo_activity_playground.core.summary_stats import get_equipment_use_table
+from .summary_stats import get_equipment_use_table
 
 
 @pytest.fixture

geo_activity_playground/explorer/grid_file.py

@@ -7,8 +7,8 @@ import geojson
 import gpxpy
 import pandas as pd
 
-from geo_activity_playground.core.coordinates import Bounds
-from geo_activity_playground.core.tiles import get_tile_upper_left_lat_lon
+from ..core.coordinates import Bounds
+from ..core.tiles import get_tile_upper_left_lat_lon
 
 
 logger = logging.getLogger(__name__)