/0/h3_latency: Attempt returning small hexes by default

Author: iakat

src/adsb_api/app.py

@@ -25,8 +25,7 @@
 from adsb_api.utils.api_v2 import router as v2_router
 from adsb_api.utils.dependencies import browser, feederData, provider, redisVRS
 from adsb_api.utils.models import ApiUuidRequest, PrettyJSONResponse
-from adsb_api.utils.settings import (INSECURE, REDIS_HOST, SALT_BEAST,
-                                     SALT_MLAT, SALT_MY)
+from adsb_api.utils.settings import INSECURE, REDIS_HOST, SALT_BEAST, SALT_MLAT, SALT_MY
 
 PROJECT_PATH = pathlib.Path(__file__).parent.parent.parent
 
@@ -161,7 +160,9 @@ async def mlat_receivers(
         return {"error": "not found"}
 
     if server not in provider.mlat_sync_json.keys():
-        print(f"failed mlat_sync host={host}, server={server} (not in {provider.mlat_sync_json.keys()})")
+        print(
+            f"failed mlat_sync host={host}, server={server} (not in {provider.mlat_sync_json.keys()})"
+        )
         return {"error": "not found"}
 
     return provider.mlat_sync_json[server]
@@ -236,8 +237,14 @@ async def api_me(request: Request):
     # If any bad
     return response
 
+
 @app.get("/0/my", tags=["v0"], summary="My Map redirect based on IP")
-@app.get("/api/0/my", tags=["v0"], summary="My Map redirect based on IP", include_in_schema=False)
+@app.get(
+    "/api/0/my",
+    tags=["v0"],
+    summary="My Map redirect based on IP",
+    include_in_schema=False,
+)
 async def api_my(request: Request):
     client_ip = request.client.host
     my_beast_clients = provider.get_clients_per_client_ip(client_ip)
@@ -376,36 +383,44 @@ async def planespotters_net_hex_options():
         },
     )
 
+
 @app.get(
     "/0/h3_latency",
     include_in_schema=False,
     tags=["v0"],
 )
 async def h3_latency():
+    # Start with fine resolution
     _h3 = defaultdict(list)
     for receiverId, lat, lon in provider.beast_receivers:
         for client in provider.beast_clients:
-            if not client["_uuid"].startswith(receiverId) or client.get("ms", -1) < 0:
-                continue
-            _h3[h3.latlng_to_cell(lat, lon, 1)].append(client["ms"])
-    ret = defaultdict(dict)
-    for key, value in _h3.items():
-        # calculate median
-        value.sort()
-        ret[key]["median"] = value[len(value) // 2]
-        # calculate average, limit to 2 decimals
-        ret[key]["average"] = round(sum(value) / len(value), 2)
-        # calculate min
-        ret[key]["min"] = min(value)
-        # calculate max
-        ret[key]["max"] = max(value)
-        # calculate count
-        ret[key]["count"] = len(value)
-    # if count < 2, remove the key
-    ret = {key: value for key, value in ret.items() if value["count"] > 1}
-    # sort by median
-    ret = dict(sorted(ret.items(), key=lambda item: item[1]["median"]))
-    return Response(orjson.dumps(ret), media_type="application/json")
+            if client["_uuid"].startswith(receiverId) and client.get("ms", -1) >= 0:
+                _h3[h3.latlng_to_cell(lat, lon, 6)].append(client["ms"])
+
+    # Group up sparse hexes progressively
+    for res in range(5, 0, -1):
+        for cell, values in list(_h3.items()):
+            if len(values) < 3 and h3.cell_to_res(cell) == res + 1:
+                _h3[h3.cell_to_parent(cell, res)].extend(_h3.pop(cell))
+
+    # Calculate stats and filter
+    ret = {}
+    for key, values in _h3.items():
+        if len(values) > 1:
+            values.sort()
+            ret[key] = {
+                "median": values[len(values) // 2],
+                "average": round(sum(values) / len(values), 2),
+                "min": min(values),
+                "max": max(values),
+                "count": len(values),
+            }
+
+    return Response(
+        orjson.dumps(dict(sorted(ret.items(), key=lambda x: x[1]["median"]))),
+        media_type="application/json",
+    )
+
 
 if __name__ == "__main__":
     print("Run with:")