Refactor of caching & data storage part 5 #118

alertproviders/bota.py

@@ -20,7 +20,7 @@ class BOTA(HTTPAlertProvider):
     def _http_response_to_alerts(self, http_response):
         new_alerts = []
         # Find the table of upcoming alerts
-        bs = BeautifulSoup(http_response.content.decode(), features="lxml")
+        bs = BeautifulSoup(http_response.content.decode("utf-8-sig"), features="lxml")
         if not bs.body:
             return new_alerts
         div = bs.body.find('div', attrs={'class': 'view-activations-public'})

alertproviders/ng3k.py

@@ -22,7 +22,7 @@ class NG3K(HTTPAlertProvider):
 
     def _http_response_to_alerts(self, http_response):
         new_alerts = []
-        rss = cast(RSS, Parser.parse(http_response.content.decode()))
+        rss = cast(RSS, Parser.parse(http_response.content.decode("utf-8-sig")))
         # Iterate through source data
         for source_alert in rss.channel.items:
             # Deal with "the format"...

alertproviders/parksnpeaks.py

@@ -22,7 +22,7 @@ class ParksNPeaks(HTTPAlertProvider):
         # Iterate through source data
         for source_alert in http_response.json():
             # Calculate some things
-            sig = source_alert["Class"]
+            sig = source_alert["Class"].upper()
             if " - " in source_alert["Location"]:
                 split = source_alert["Location"].split(" - ")
                 sig_ref = split[0]
@@ -50,7 +50,7 @@ class ParksNPeaks(HTTPAlertProvider):
                           is_dxpedition=False)
 
             # Log a warning for the developer if PnP gives us an unknown programme we've never seen before
-            if sig and sig not in ["POTA", "SOTA", "WWFF", "SiOTA", "ZLOTA", "KRMNPA", "LLOTA", "QRP"]:
+            if sig and sig not in ["POTA", "SOTA", "WWFF", "SIOTA", "ZLOTA", "KRMNPA", "LLOTA", "QRP"]:
                 logging.warning("PNP alert found with sig " + sig + ", developer needs to add support for this!")
 
             # If this is POTA, SOTA or WWFF data we already have it through other means, so ignore. Otherwise, add to

alertproviders/wota.py

@@ -22,7 +22,7 @@ class WOTA(HTTPAlertProvider):
 
     def _http_response_to_alerts(self, http_response):
         new_alerts = []
-        rss = cast(RSS, RSSParser.parse(http_response.content.decode()))
+        rss = cast(RSS, RSSParser.parse(http_response.content.decode("utf-8-sig")))
         # Iterate through source data
         for source_alert in rss.channel.items:
 

config-example.yml

@@ -116,21 +116,30 @@ spot-providers:
   - class: "XOTA"
     # xOTA sources have a "name" property so you can define what programme it is for, since xOTA is generic software
     # for running "something-on-the-air" programmes.
-    name: "39C3 TOTA"
+    name: "C3 TOTA"
     enabled: false
     url: "wss://39c3.totawatch.de/api/spot/live"
-    # Fixed SIG for all spots from a provider & location CSV are currently only a feature for the "XOTA" provider,
-    # the software found at https://github.com/nischu/xOTA/. This is because this is a generic backend for xOTA
-    # programmes and so different URLs provide different programmes.
-    sig: "TOTA"
-    locations-csv: "datafiles/39c3-tota.csv"
+    # For the "XOTA" provider, a SIG must be set menually here because xOTA is a generic backend for xOTA
+    # programmes and so different URLs potentially provide different programmes.
+    sig: "Toilets"
+    # For Toilets on the Air, we prefix the SIG references (T-01 etc) with some characters that define the conference:
+    # C3, EH or HOPE - so we can look up the correct locations in our database, because each conference starts from T-01
+    # but refers to a toilet in a different building (or continent!)
+    sig-ref-prefix: "C3"
 
   - class: "XOTA"
     name: "EH23 TOTA"
     enabled: false
     url: "wss://eh23.totawatch.de/api/spot/live"
-    sig: "TOTA"
-    locations-csv: "datafiles/eh23-tota.csv"
+    sig: "Toilets"
+    sig-ref-prefix: "EH"
+
+  - class: "XOTA"
+    name: "HOPE26 TOTA"
+    enabled: false
+    url: "wss://hope-26.totawatch.de/api/spot/live"
+    sig: "Toilets"
+    sig-ref-prefix: "HOPE"
 
 
 # Alert providers to use. Same setup as the spot providers list above.
@@ -157,6 +166,60 @@ alert-providers:
     enabled: true
 
 
+# SIG reference data providers to use. This allows Spothole to download, for example, the WWFF directory that maps WWFF
+# park IDs to their name and location.
+sig-ref-data-providers:
+  - class: "POTA"
+    enabled: true
+
+  - class: "SOTA"
+    enabled: true
+
+  - class: "WWFF"
+    enabled: true
+
+  - class: "WWBOTA"
+    enabled: true
+
+  - class: "GMA"
+    enabled: true
+
+  - class: "MOTA"
+    enabled: true
+
+  - class: "ILLW"
+    enabled: true
+
+  - class: "ARLHS"
+    enabled: true
+
+  - class: "WCA"
+    enabled: true
+
+  - class: "IOTA"
+    enabled: true
+
+  - class: "WOTA"
+    enabled: true
+
+  - class: "SIOTA"
+    enabled: true
+
+  - class: "ZLOTA"
+    enabled: true
+
+  - class: "LLOTA"
+    enabled: true
+
+  - class: "Towers"
+    enabled: true
+
+  - class: "DME"
+    enabled: true
+
+  - class: "Toilets"
+    enabled: true
+
 # Solar condition providers to use. These poll external APIs for solar propagation data (SFI, A/K indices, band
 # conditions, etc.) and make it available via the /api/v1/solar endpoint.
 solar-condition-providers:

core/config.py

@@ -1,3 +1,4 @@
+import importlib
 import logging
 import os
 
@@ -33,3 +34,35 @@ WEB_UI_OPTIONS["spot-providers-enabled-by-default"] = [p["name"] for p in config
 # one of our proviers. We set that to also be enabled by default.
 if ALLOW_SPOTTING:
     WEB_UI_OPTIONS["spot-providers-enabled-by-default"].append("API")
+
+
+def get_spot_provider_from_config(config_providers_entry):
+    """Utility method to get a spot provider based on the class specified in its config entry."""
+
+    module = importlib.import_module('spotproviders.' + config_providers_entry["class"].lower())
+    provider_class = getattr(module, config_providers_entry["class"])
+    return provider_class(config_providers_entry)
+
+
+def get_alert_provider_from_config(config_providers_entry):
+    """Utility method to get an alert provider based on the class specified in its config entry."""
+
+    module = importlib.import_module('alertproviders.' + config_providers_entry["class"].lower())
+    provider_class = getattr(module, config_providers_entry["class"])
+    return provider_class(config_providers_entry)
+
+
+def get_solar_conditions_provider_from_config(config_providers_entry):
+    """Utility method to get a solar conditions provider based on the class specified in its config entry."""
+
+    module = importlib.import_module('solarconditionsproviders.' + config_providers_entry["class"].lower())
+    provider_class = getattr(module, config_providers_entry["class"])
+    return provider_class(config_providers_entry)
+
+
+def get_sig_ref_data_provider_from_config(config_providers_entry):
+    """Utility method to get a SIG reference data provider based on the class specified in its config entry."""
+
+    module = importlib.import_module('sigrefdataproviders.' + config_providers_entry["class"].lower())
+    provider_class = getattr(module, config_providers_entry["class"])
+    return provider_class(config_providers_entry)

core/constants.py

@@ -19,9 +19,9 @@ SIGS = [
     SIG(name="HEMA", comment_names=["HEMA"], description="HuMPs Excluding Marilyns Award", ref_regex=r"[A-Z0-9]{1,3}\/[A-Z]{3}\-\d{3}"),
     SIG(name="IOTA", comment_names=["IOTA"], description="Islands on the Air", ref_regex=r"[A-Z]{2}\-\d{3}"),
     SIG(name="MOTA", comment_names=["MOTA"], description="Mills on the Air", ref_regex=r"X\d{4,6}"),
-    SIG(name="ARLHS", comment_names=["ARLHS"], description="Amateur Radio Lighthouse Society", ref_regex=r"[A-Z]{3}\-\d{3,4}"),
+    SIG(name="ARLHS", comment_names=["ARLHS"], description="Amateur Radio Lighthouse Society", ref_regex=r"[A-Z]{3}[\- ]\d{3,4}"),
     SIG(name="ILLW", comment_names=["ILLW"], description="International Lighthouse & Lightship Weekend", ref_regex=r"[A-Z]{2}\d{4}"),
-    SIG(name="SiOTA", comment_names=["SIOTA"], description="Silos on the Air", ref_regex=r"[A-Z]{2}\-[A-Z]{3}\d"),
+    SIG(name="SIOTA", comment_names=["SIOTA"], description="Silos on the Air", ref_regex=r"[A-Z]{2}\-[A-Z]{3}\d"),
     SIG(name="WCA", comment_names=["WCA"], description="World Castles Award", ref_regex=r"[A-Z0-9]{1,3}\-\d{5}"),
     SIG(name="ZLOTA", comment_names=["ZLOTA"], description="New Zealand on the Air", ref_regex=r"ZL[A-Z]/[A-Z]{2}\-\d{3,4}"),
     SIG(name="WOTA", comment_names=["WOTA"], description="Wainwrights on the Air", ref_regex=r"[A-Z]{3}-[0-9]{2}"),

core/data_store.py

@@ -1,8 +1,10 @@
+import logging
 from pathlib import Path
 
 import diskcache
 
 from core.config import MAX_SPOT_AGE, MAX_ALERT_AGE
+from core.constants import SIGS
 from core.live_data_cache import LiveDataCache
 from data.solar_conditions import SolarConditions
 
@@ -12,57 +14,66 @@ class DataStore:
     lookup data using different caching strategies for each."""
 
     def __init__(self):
-        cache_dir = "./cache"
-        self.MAX_SPOT_COUNT = 10000
-        self.MAX_ALERT_COUNT = 10000
-        self.SPOT_ALERT_SNAPSHOT_INTERVAL_SEC = 300
-        self.CALLSIGN_DATA_TTL_SEC = 30 * 24 * 60 * 60
+        self._CACHE_DIR = "./cache"
+        self._MAX_SPOT_COUNT = 100000
+        self._MAX_ALERT_COUNT = 100000
+        self._SPOT_ALERT_SNAPSHOT_INTERVAL_SEC = 300
+        self._CALLSIGN_DATA_TTL_SEC = 30 * 24 * 60 * 60
+        self.alerts = None
+        self.spots = None
+        self.callsigns = None
+        self.sigrefs = None
+        self.status_data = None
+        self._status = None
+        self.solar_conditions = None
+        self._solar = None
 
-        Path(cache_dir).mkdir(parents=True, exist_ok=True)
-
-        # Special caches for spots and alerts, which have TTL and write snapshots to disk at an interval
-        self.spots = LiveDataCache(maxsize=self.MAX_SPOT_COUNT, ttl=MAX_SPOT_AGE,
-                                   snapshot_dir=cache_dir + "/spots",
-                                   snapshot_interval_sec=self.SPOT_ALERT_SNAPSHOT_INTERVAL_SEC)
-        self.alerts = LiveDataCache(maxsize=self.MAX_ALERT_COUNT, ttl=MAX_ALERT_AGE,
-                                   snapshot_dir=cache_dir + "/alerts",
-                                    snapshot_interval_sec=self.SPOT_ALERT_SNAPSHOT_INTERVAL_SEC)
+    def setup(self):
+        Path(self._CACHE_DIR).mkdir(parents=True, exist_ok=True)
 
         # Standard disk cache for solar data and status data, but each cache contains only a single object which we
         # expose to the wider application
-        self.solar = diskcache.Cache(cache_dir + "/solar")
-        if "solar_conditions" not in self.solar:
-            self.solar.add("solar_conditions", SolarConditions())
-        self.solar_conditions = self.solar.get("solar_conditions")
-        self.status = diskcache.Cache(cache_dir + "/status")
-        if "status_data" not in self.status:
-            self.status.add("status_data", {})
-        self.status_data = self.status.get("status_data")
+        self._solar = diskcache.Cache(self._CACHE_DIR + "/solar")
+        if "solar_conditions" not in self._solar:
+            self._solar.add("solar_conditions", SolarConditions())
+        self.solar_conditions = self._solar.get("solar_conditions")
+        self._status = diskcache.Cache(self._CACHE_DIR + "/status")
+        if "status_data" not in self._status:
+            self._status.add("status_data", {})
+        self.status_data = self._status.get("status_data")
 
-        # Standard disk caches for SIG ref data. Separate provider threads will repopulate these on a regular basis
-        # but there's no need for a TTL since old data is better than no data.
-        self.sigrefs_wwff = diskcache.Cache(cache_dir + "/sigrefs/wwff")
-        self.sigrefs_siota = diskcache.Cache(cache_dir + "/sigrefs/siota")
-        self.sigrefs_wota = diskcache.Cache(cache_dir + "/sigrefs/wota")
-        self.sigrefs_zlota = diskcache.Cache(cache_dir + "/sigrefs/zlota")
-        self.sigrefs_llota = diskcache.Cache(cache_dir + "/sigrefs/llota")
-        self.sigrefs_dme = diskcache.Cache(cache_dir + "/sigrefs/dme")
+        # Standard disk cache for SIG ref data. Separate provider threads will repopulate theis on a regular basis
+        # but there's no need for a TTL since old data is better than no data. We need to key on both SIG and reference,
+        # and trying to do two layers of dict in diskcache absolutely destroys performance with unpickling huge dicts,
+        # so we have an ugly "SIG:ref" syntax for keys to keep it a single level.
+        self.sigrefs = diskcache.Cache(self._CACHE_DIR + "/sigrefs")
+        logging.info(f"Loaded data for %d SIG references.", len(self.sigrefs))
 
         # Standard disk cache for callsign data. This data does have a TTL to trigger an occasional re-lookup.
         # Old data *is* better than no data, but we can't have a background thread re-looking-up every callsign
         # we've seen, so we rely on them timing out and this triggering another lookup.
-        self.callsigns = diskcache.Cache(cache_dir + "/callsigns")
+        self.callsigns = diskcache.Cache(self._CACHE_DIR + "/callsigns")
+        logging.info(f"Loaded data for %d callsigns.", len(self.callsigns))
+
+        # Special caches for spots and alerts, which have TTL and write snapshots to disk at an interval. We
+        # specifically load these caches *last* so that any sigref and callsign data is already loaded from disk cache
+        # before the spots and alerts are live in the system.
+        self.spots = LiveDataCache(maxsize=self._MAX_SPOT_COUNT, ttl=MAX_SPOT_AGE,
+                                   snapshot_dir=self._CACHE_DIR + "/spots",
+                                   snapshot_interval_sec=self._SPOT_ALERT_SNAPSHOT_INTERVAL_SEC)
+        logging.info(f"Loaded %d spots from a previous run.", len(self.spots.keys()))
+
+        self.alerts = LiveDataCache(maxsize=self._MAX_ALERT_COUNT, ttl=MAX_ALERT_AGE,
+                                    snapshot_dir=self._CACHE_DIR + "/alerts",
+                                    snapshot_interval_sec=self._SPOT_ALERT_SNAPSHOT_INTERVAL_SEC)
+        logging.info(f"Loaded %d alerts from a previous run.", len(self.alerts.keys()))
 
     def close(self):
         self.spots.close()
         self.alerts.close()
-        self.solar.close()
-        self.status.close()
-        self.sigrefs_wwff.close()
-        self.sigrefs_siota.close()
-        self.sigrefs_wota.close()
-        self.sigrefs_zlota.close()
-        self.sigrefs_llota.close()
+        self._solar.close()
+        self._status.close()
+        self.sigrefs.close()
         self.callsigns.close()
 
 # Global object

core/sig_utils.py

@@ -1,19 +1,11 @@
-import csv
 import logging
 
 from pyhamtools.locator import latlong_to_locator, locator_to_latlong
-from requests.exceptions import ConnectionError, ReadTimeout, ConnectTimeout
 
-from core.constants import SIGS, HTTP_HEADERS
+from core.constants import SIGS
 from core.data_store import DATA_STORE
 from core.geo_utils import wab_wai_square_to_lat_lon
-from core.url_data_cache import URL_DATA_CACHE
 
-# Load Spanish municipality data for the DME programme. There's no convenient lookup API for this, so we embed the data
-# file in Spothole and load it on startup.
-with open("datafiles/MUNICIPIOS.csv", encoding="latin-1") as _f:
-    for row in csv.DictReader(_f, delimiter=";"):
-        DATA_STORE.sigrefs_dme.add(row["COD_INE"][:5], row)
 
 def get_ref_regex_for_sig(sig):
     """Utility function to get the regex string for a SIG reference for a named SIG. If no match is found, None will be returned."""
@@ -35,217 +27,31 @@ def get_sig_name_from_comment_name(sig):
 
 
 def populate_sig_ref_info(sig_ref):
-    """Look up details of a SIG reference (e.g. POTA park) such as name, lat/lon, and grid. Takes in a sig_ref object which
-    must at minimum have a "sig" and an "id". The rest of the object will be populated and returned.
+    """Look up details of a SIG reference (e.g. POTA park) such as name, lat/lon, and grid. Takes in a sig_ref object
+    which must at minimum have a "sig" and an "id". The rest of the object will be populated and returned. This makes
+    use of SIG ref data in the data store, live lookups from the web, or just automatic calculation depending on which
+    SIG we are getting data for.
     Note there is currently no support for KRMNPA location lookup, see issue #61."""
 
-    if sig_ref.sig is None or sig_ref.id is None:
-        logging.warning("Failed to look up sig_ref info, sig or id were not set.")
+    if sig_ref.sig is None or sig_ref.sig == "" or sig_ref.id is None or sig_ref.id == "":
+        logging.debug("Failed to look up sig_ref info, sig or id were not set.")
+        return sig_ref
 
-    sig = sig_ref.sig or ""
+    sig = sig_ref.sig
     ref_id = sig_ref.id
+
+    # DME fudge. Our database has leading zeros padding to 5 digits which is the expected format, but not all activators
+    # add leading zeros.
+    if sig.upper() == "DME":
+        ref_id = ref_id.zfill(5)
+
     try:
-        if sig.upper() == "POTA":
-            response = URL_DATA_CACHE.get("https://api.pota.app/park/" + ref_id, headers=HTTP_HEADERS)
-            if response.ok:
-                data = response.json()
-                if data:
-                    fullname = str(data["name"]) if "name" in data else None
-                    if fullname and "parktypeDesc" in data and data["parktypeDesc"] != "":
-                        fullname = fullname + " " + data["parktypeDesc"]
-                    sig_ref.name = fullname
-                    sig_ref.url = "https://pota.app/#/park/" + ref_id
-                    sig_ref.grid = data["grid6"] if "grid6" in data else None
-                    sig_ref.latitude = data["latitude"] if "latitude" in data else None
-                    sig_ref.longitude = data["longitude"] if "longitude" in data else None
-                elif not response.from_cache:
-                    logging.warning("Malformed response looking up %s ref %s", sig, ref_id)
-            elif not response.from_cache:
-                logging.warning("HTTP %d looking up %s ref %s", response.status_code, sig, ref_id)
-
-        elif sig.upper() == "SOTA":
-            response = URL_DATA_CACHE.get("https://api-db2.sota.org.uk/api/summits/" + ref_id,
-                                                      headers=HTTP_HEADERS)
-            if response.ok:
-                data = response.json()
-                if data:
-                    sig_ref.name = data["name"] if "name" in data else None
-                    sig_ref.url = "https://www.sotadata.org.uk/en/summit/" + ref_id
-                    sig_ref.grid = data["locator"] if "locator" in data else None
-                    sig_ref.latitude = data["latitude"] if "latitude" in data else None
-                    sig_ref.longitude = data["longitude"] if "longitude" in data else None
-                    sig_ref.activation_score = data["points"] if "points" in data else None
-                elif not response.from_cache:
-                    logging.warning("Malformed response looking up %s ref %s", sig, ref_id)
-            elif not response.from_cache:
-                logging.warning("HTTP %d looking up %s ref %s", response.status_code, sig, ref_id)
-
-        elif sig.upper() == "WWBOTA":
-            response = URL_DATA_CACHE.get("https://api.wwbota.org/bunkers/" + ref_id,
-                                                      headers=HTTP_HEADERS)
-            if response.ok:
-                data = response.json()
-                if data:
-                    sig_ref.name = data["name"] if "name" in data else None
-                    sig_ref.url = "https://bunkerwiki.org/?s=" + ref_id if ref_id.startswith("B/G") else None
-                    sig_ref.grid = data["locator"] if "locator" in data else None
-                    sig_ref.latitude = data["lat"] if "lat" in data else None
-                    sig_ref.longitude = data["long"] if "long" in data else None
-                elif not response.from_cache:
-                    logging.warning("Malformed response looking up %s ref %s", sig, ref_id)
-            elif not response.from_cache:
-                logging.warning("HTTP %d looking up %s ref %s", response.status_code, sig, ref_id)
-
-        elif sig.upper() == "GMA" or sig.upper() == "ARLHS" or sig.upper() == "ILLW" or sig.upper() == "WCA" or sig.upper() == "MOTA" or sig.upper() == "IOTA":
-            response = URL_DATA_CACHE.get("https://www.cqgma.org/api/ref/?" + ref_id,
-                                                      headers=HTTP_HEADERS)
-            if response.ok:
-                data = response.json()
-                if data:
-                    sig_ref.name = data["name"] if "name" in data else None
-                    sig_ref.url = "https://www.cqgma.org/zinfo.php?ref=" + ref_id
-                    sig_ref.grid = data["locator"] if "locator" in data else None
-
-                    # For some things (just IOTA?) the GMA actually returns a box where "latitude" and "longitude" are
-                    # the zeroest corner of the box, then "lat2" and "lng2" provide the other corner. We detect this
-                    # and provide a single lat/lon for the centre. Otherwise if we don't have these extra parameters,
-                    # just use the single point we have.
-                    if data.get("latitude") is not None and data.get("longitude") is not None and data.get(
-                            "lat2") is not None and data.get("lng2") is not None:
-                        sig_ref.latitude = (float(data["latitude"]) + float(data["lat2"])) / 2.0
-                        sig_ref.longitude = (float(data["longitude"]) + float(data["lng2"])) / 2.0
-                    else:
-                        sig_ref.latitude = float(data["latitude"]) if data.get("latitude") is not None else None
-                        sig_ref.longitude = float(data["longitude"]) if data.get("longitude") is not None else None
-                elif not response.from_cache:
-                    logging.warning("Malformed response looking up %s ref %s via GMA", sig, ref_id)
-            elif not response.from_cache:
-                logging.warning("HTTP %d looking up %s ref %s", response.status_code, sig, ref_id)
-
-        elif sig.upper() == "WWFF":
-            response = URL_DATA_CACHE.get("https://wwff.co/wwff-data/wwff_directory.csv",
-                                                      headers=HTTP_HEADERS)
-            if response.ok:
-                if not bool(DATA_STORE.sigrefs_wwff) or not response.from_cache:
-                    # New data from WWFF, update our internal map
-                    for row in csv.DictReader(response.content.decode().splitlines()):
-                        DATA_STORE.sigrefs_wwff.add(row["reference"], row)
-                row = DATA_STORE.sigrefs_wwff.get(ref_id)
-                if row:
-                    sig_ref.name = row["name"] if "name" in row else None
-                    sig_ref.url = "https://wwff.co/directory/?showRef=" + ref_id
-                    sig_ref.grid = row["iaruLocator"] if "iaruLocator" in row and row["iaruLocator"] != "-" else None
-                    sig_ref.latitude = float(row["latitude"]) if "latitude" in row and row["latitude"] != "-" else None
-                    sig_ref.longitude = float(row["longitude"]) if "longitude" in row and row[
-                        "longitude"] != "-" else None
-                elif not response.from_cache:
-                    logging.warning("WWFF database did not contain data for ref %s", ref_id)
-            elif not response.from_cache:
-                logging.warning("HTTP %d looking up %s ref %s", response.status_code, sig, ref_id)
-
-        elif sig.upper() == "SIOTA":
-            response = URL_DATA_CACHE.get("https://www.silosontheair.com/data/silos.csv",
-                                                      headers=HTTP_HEADERS)
-            if response.ok:
-                if not bool(DATA_STORE.sigrefs_siota) or not response.from_cache:
-                    # New data from SIOTA, update our internal map
-                    for row in csv.DictReader(response.content.decode().splitlines()):
-                        DATA_STORE.sigrefs_siota.add(row["SILO_CODE"], row)
-                row = DATA_STORE.sigrefs_siota.get(ref_id)
-                if row:
-                    sig_ref.name = row["NAME"] if "NAME" in row else None
-                    sig_ref.grid = row["LOCATOR"] if "LOCATOR" in row else None
-                    sig_ref.latitude = float(row["LAT"]) if "LAT" in row else None
-                    sig_ref.longitude = float(row["LNG"]) if "LNG" in row else None
-                elif not response.from_cache:
-                    logging.warning("SIOTA database did not contain data for ref %s", ref_id)
-            elif not response.from_cache:
-                logging.warning("HTTP %d looking up %s ref %s", response.status_code, sig, ref_id)
-
-        elif sig.upper() == "WOTA":
-            response = URL_DATA_CACHE.get("https://www.wota.org.uk/mapping/data/summits.json",
-                                                      headers=HTTP_HEADERS)
-            if response.ok:
-                data = response.json()
-                if data:
-                    if not bool(DATA_STORE.sigrefs_wota) or not response.from_cache:
-                        # New data from WOTA, update our internal map
-                        for feature in data.get("features", []):
-                            DATA_STORE.sigrefs_wota.add(feature["properties"]["wotaId"], feature)
-                    feature = DATA_STORE.sigrefs_wota.get(ref_id)
-                    if feature:
-                        sig_ref.name = feature["properties"]["title"]
-                        # Fudge WOTA URLs. Outlying fell (LDO) URLs don't match their ID numbers but require 214 to be
-                        # added to them
-                        sig_ref.url = "https://www.wota.org.uk/MM_" + ref_id
-                        if ref_id.upper().startswith("LDO-"):
-                            number = int(ref_id.upper().replace("LDO-", ""))
-                            sig_ref.url = "https://www.wota.org.uk/MM_LDO-" + str(number + 214)
-                        sig_ref.grid = feature["properties"]["qthLocator"]
-                        sig_ref.latitude = feature["geometry"]["coordinates"][1]
-                        sig_ref.longitude = feature["geometry"]["coordinates"][0]
-                elif not response.from_cache:
-                    logging.warning("Malformed response looking up %s ref %s", sig, ref_id)
-            elif not response.from_cache:
-                logging.warning("HTTP %d looking up %s ref %s", response.status_code, sig, ref_id)
-
-        elif sig.upper() == "ZLOTA":
-            response = URL_DATA_CACHE.get("https://ontheair.nz/assets/assets.json", headers=HTTP_HEADERS)
-            if response.ok:
-                data = response.json()
-                if isinstance(data, list):
-                    if not bool(DATA_STORE.sigrefs_zlota) or not response.from_cache:
-                        # New data from ZLOTA, update our internal map
-                        for ref in data:
-                            DATA_STORE.sigrefs_zlota.add(ref["code"], ref)
-                    ref = DATA_STORE.sigrefs_zlota.get(ref_id)
-                    if ref:
-                        sig_ref.name = ref["name"]
-                        sig_ref.url = "https://ontheair.nz/assets/" + ref_id.replace("/", "_")
-                        try:
-                            sig_ref.grid = latlong_to_locator(ref["y"], ref["x"], 6)
-                        except:
-                            logging.debug("Invalid lat/lon received for reference")
-                            sig_ref.latitude = ref["y"]
-                            sig_ref.longitude = ref["x"]
-                elif not response.from_cache:
-                    logging.warning("Malformed response looking up %s ref %s", sig, ref_id)
-            elif not response.from_cache:
-                logging.warning("HTTP %d looking up %s ref %s", response.status_code, sig, ref_id)
-
-        elif sig.upper() == "BOTA":
-            if not sig_ref.name:
-                sig_ref.name = sig_ref.id
-            sig_ref.url = "https://www.beachesontheair.com/beaches/" + sig_ref.name.lower().replace(" ", "-")
-
-        elif sig.upper() == "LLOTA":
-            response = URL_DATA_CACHE.get("https://llota.app/api/public/references",
-                                                      headers=HTTP_HEADERS)
-            if response.ok:
-                data = response.json()
-                if isinstance(data, list):
-                    if not bool(DATA_STORE.sigrefs_llota) or not response.from_cache:
-                        # New data from LLOTA, update our internal map
-                        for ref in data:
-                            DATA_STORE.sigrefs_llota.add(ref["reference_code"], ref)
-                    ref = DATA_STORE.sigrefs_llota.get(ref_id)
-                    if ref:
-                        sig_ref.name = str(ref["name"])
-                        sig_ref.url = "https://llota.app/list/ref/" + ref_id
-                        sig_ref.grid = str(ref["grid_locator"])
-                        ll = locator_to_latlong(sig_ref.grid)
-                        sig_ref.latitude = ll[0]
-                        sig_ref.longitude = ll[1]
-                elif not response.from_cache:
-                    logging.warning("Malformed response looking up %s ref %s", sig, ref_id)
-            elif not response.from_cache:
-                logging.warning("HTTP %d looking up %s ref %s", response.status_code, sig, ref_id)
-
-        elif sig.upper() == "WWTOTA":
-            if not sig_ref.name:
-                sig_ref.name = sig_ref.id
-            sig_ref.url = "https://wwtota.com/seznam/karta_rozhledny.php?ref=" + str(sig_ref.name)
+        # If the SIG is HEMA or KRMNPA, we have no current lookup for this so just skip it.
+        if sig.upper() == "HEMA" or sig.upper() == "KRMNPA":
+            return sig_ref
 
+        # If the SIG is Tiles, WAB, WAI or BOTA (Beaches), we don't have anything to look up from the data store, we can
+        # calculate all the information we are going to get directly. So handle those cases first
         elif sig.upper() == "TILES":
             # Tiles on the Air just uses Maidenhead 6-digit squares, so ID, Name and Grid are all the same
             if not sig_ref.name:
@@ -268,27 +74,26 @@ def populate_sig_ref_info(sig_ref):
                 except:
                     logging.warning("Invalid lat/lon received for WAB/WAI reference")
 
-        elif sig.upper() == "DME":
-            # Zero-pad to 5 digits to match our source data
-            row = DATA_STORE.sigrefs_dme.get(ref_id.zfill(5))
-            if row:
-                sig_ref.name = row["NOMBRE_ACTUAL"] + ", " + row["PROVINCIA"]
-                sig_ref.latitude = float(row["LATITUD_ETRS89_REGCAN95"].replace(",", ".")) if row.get(
-                    "LATITUD_ETRS89_REGCAN95") else None
-                sig_ref.longitude = float(row["LONGITUD_ETRS89_REGCAN95"].replace(",", ".")) if row.get(
-                    "LONGITUD_ETRS89_REGCAN95") else None
-                if sig_ref.latitude and sig_ref.longitude:
-                    try:
-                        sig_ref.grid = latlong_to_locator(sig_ref.latitude, sig_ref.longitude, 6)
-                    except Exception:
-                        logging.warning("Invalid lat/lon received for DME reference")
-            else:
-                logging.warning("DME database did not contain data for ref %s", ref_id)
+        elif sig.upper() == "BOTA":
+            # For BOTA all we can ever generate is the URL, there is no data file or lookup for lat/longs
+            if not sig_ref.name:
+                sig_ref.name = sig_ref.id
+            sig_ref.url = "https://www.beachesontheair.com/beaches/" + sig_ref.name.lower().replace(" ", "-")
+
+        # OK, this is something we have to look up. Now check to see if our data store contains SIG ref information for
+        # this SIG. If so, check for the reference data and use that.
+        elif sig in DATA_STORE.sigrefs:
+            key = sig + ":" + ref_id
+            lookup_data = DATA_STORE.sigrefs.get(key) if key in DATA_STORE.sigrefs else None
+            if lookup_data:
+                # Copy new sig ref data into existing object
+                sig_ref.__dict__.update(lookup_data.__dict__)
+            else:
+                logging.warning("%s database did not contain data for ref %s", sig, ref_id)
+
+        else:
+            logging.warning(f"Tried to look up a SIG called %s but Spothole does not know what that is.", sig)
 
-    except ConnectionError:
-        logging.warning("Connection error when looking up sig_ref info for " + sig + " ref " + ref_id)
-    except (ConnectTimeout, ReadTimeout):
-        logging.warning(f"Timeout when looking up sig_ref info for " + sig + " ref " + ref_id)
     except Exception:
         logging.error("Exception when looking up sig_ref info for " + sig + " ref " + ref_id, exc_info=True)
     return sig_ref

core/status_reporter.py

@@ -14,7 +14,8 @@ from core.prometheus_metrics_handler import memory_use_gauge, spots_gauge, alert
 class StatusReporter:
     """Provides a timed update of the application's status data."""
 
-    def __init__(self, run_interval, web_server,spot_providers, alert_providers, solar_condition_providers):
+    def __init__(self, run_interval, web_server, spot_providers, alert_providers, solar_condition_providers,
+                 sig_ref_data_providers):
         """Constructor"""
 
         self._run_interval = run_interval
@@ -22,6 +23,7 @@ class StatusReporter:
         self._spot_providers = spot_providers
         self._alert_providers = alert_providers
         self._solar_condition_providers = solar_condition_providers
+        self._sig_ref_data_providers = sig_ref_data_providers
         self._thread = None
         self._stop_event = Event()
         self._startup_time = datetime.now(pytz.UTC)
@@ -72,6 +74,12 @@ class StatusReporter:
                        "last_updated": p.last_update_time.replace(
                            tzinfo=pytz.UTC).timestamp() if p.last_update_time.year > 2000 else 0},
             self._solar_condition_providers))
+        DATA_STORE.status_data["sig_ref_data_providers"] = list(
+            map(lambda p: {"sig_name": p.sig_name, "enabled": p.enabled, "status": p.status,
+                           "last_updated": p.last_update_time.replace(
+                               tzinfo=pytz.UTC).timestamp() if p.last_update_time.year > 2000 else 0,
+                           "reference_count": p.reference_count},
+                self._sig_ref_data_providers))
         DATA_STORE.status_data["webserver"] = {"status": self._web_server.web_server_metrics["status"],
                                       "last_api_access": self._web_server.web_server_metrics[
                                           "last_api_access_time"].replace(

data/alert.py

@@ -1,6 +1,7 @@
 import copy
 import hashlib
 import json
+import logging
 from dataclasses import dataclass
 from datetime import datetime, timedelta
 
@@ -64,69 +65,73 @@ class Alert:
     def infer_missing(self, credentials=None):
         """Infer missing parameters where possible"""
 
-        # If we somehow don't have a start time, set it to zero so it sorts off the bottom of any list but
-        # clients can still reliably parse it as a number.
-        if not self.start_time:
-            self.start_time = 0
+        try:
+            # If we somehow don't have a start time, set it to zero so it sorts off the bottom of any list but
+            # clients can still reliably parse it as a number.
+            if not self.start_time:
+                self.start_time = 0
 
-        # If we don't have a received time, this has just been received so set that to "now"
-        if not self.received_time:
-            self.received_time = datetime.now(pytz.UTC).timestamp()
+            # If we don't have a received time, this has just been received so set that to "now"
+            if not self.received_time:
+                self.received_time = datetime.now(pytz.UTC).timestamp()
 
-        # Fill in ISO versions of times, in case the client prefers that
-        if self.start_time and not self.start_time_iso:
-            self.start_time_iso = datetime.fromtimestamp(self.start_time, pytz.UTC).isoformat()
-        if self.end_time and not self.end_time_iso:
-            self.end_time_iso = datetime.fromtimestamp(self.end_time, pytz.UTC).isoformat()
-        if self.received_time and not self.received_time_iso:
-            self.received_time_iso = datetime.fromtimestamp(self.received_time, pytz.UTC).isoformat()
+            # Fill in ISO versions of times, in case the client prefers that
+            if self.start_time and not self.start_time_iso:
+                self.start_time_iso = datetime.fromtimestamp(self.start_time, pytz.UTC).isoformat()
+            if self.end_time and not self.end_time_iso:
+                self.end_time_iso = datetime.fromtimestamp(self.end_time, pytz.UTC).isoformat()
+            if self.received_time and not self.received_time_iso:
+                self.received_time_iso = datetime.fromtimestamp(self.received_time, pytz.UTC).isoformat()
 
-        # DX country, continent, zones etc. from callsign. CQ/ITU zone are better looked up with a location but we don't
-        # have a real location for alerts.
-        if self.dx_calls and self.dx_calls[0] and not self.dx_country:
-            self.dx_country = lookup_helper.infer_country_from_callsign(self.dx_calls[0], credentials)
-        if self.dx_calls and self.dx_calls[0] and not self.dx_continent:
-            self.dx_continent = lookup_helper.infer_continent_from_callsign(self.dx_calls[0], credentials)
-        if self.dx_calls and self.dx_calls[0] and not self.dx_cq_zone:
-            self.dx_cq_zone = lookup_helper.infer_cq_zone_from_callsign(self.dx_calls[0], credentials)
-        if self.dx_calls and self.dx_calls[0] and not self.dx_itu_zone:
-            self.dx_itu_zone = lookup_helper.infer_itu_zone_from_callsign(self.dx_calls[0], credentials)
-        if self.dx_calls and self.dx_calls[0] and not self.dx_dxcc_id:
-            self.dx_dxcc_id = lookup_helper.infer_dxcc_id_from_callsign(self.dx_calls[0], credentials)
-        if self.dx_dxcc_id and not self.dx_flag:
-            self.dx_flag = lookup_helper.get_flag_for_dxcc(self.dx_dxcc_id)
+            # DX country, continent, zones etc. from callsign. CQ/ITU zone are better looked up with a location but we don't
+            # have a real location for alerts.
+            if self.dx_calls and self.dx_calls[0] and not self.dx_country:
+                self.dx_country = lookup_helper.infer_country_from_callsign(self.dx_calls[0], credentials)
+            if self.dx_calls and self.dx_calls[0] and not self.dx_continent:
+                self.dx_continent = lookup_helper.infer_continent_from_callsign(self.dx_calls[0], credentials)
+            if self.dx_calls and self.dx_calls[0] and not self.dx_cq_zone:
+                self.dx_cq_zone = lookup_helper.infer_cq_zone_from_callsign(self.dx_calls[0], credentials)
+            if self.dx_calls and self.dx_calls[0] and not self.dx_itu_zone:
+                self.dx_itu_zone = lookup_helper.infer_itu_zone_from_callsign(self.dx_calls[0], credentials)
+            if self.dx_calls and self.dx_calls[0] and not self.dx_dxcc_id:
+                self.dx_dxcc_id = lookup_helper.infer_dxcc_id_from_callsign(self.dx_calls[0], credentials)
+            if self.dx_dxcc_id and not self.dx_flag:
+                self.dx_flag = lookup_helper.get_flag_for_dxcc(self.dx_dxcc_id)
 
-        # Fetch SIG data. In case a particular API doesn't provide a full set of name, lat, lon & grid for a reference
-        # in its initial call, we use this code to populate the rest of the data. This includes working out grid refs
-        # from WAB and WAI, which count as a SIG even though there's no real lookup, just maths
-        if self.sig_refs and len(self.sig_refs) > 0:
-            for sig_ref in self.sig_refs:
-                populate_sig_ref_info(sig_ref)
+            # Fetch SIG data. In case a particular API doesn't provide a full set of name, lat, lon & grid for a reference
+            # in its initial call, we use this code to populate the rest of the data. This includes working out grid refs
+            # from WAB and WAI, which count as a SIG even though there's no real lookup, just maths
+            if self.sig_refs and len(self.sig_refs) > 0:
+                for sig_ref in self.sig_refs:
+                    populate_sig_ref_info(sig_ref)
 
-        # If the spot itself doesn't have a SIG yet, but we have at least one SIG reference, take that reference's SIG
-        # and apply it to the whole spot.
-        if self.sig_refs and len(self.sig_refs) > 0 and self.sig_refs[0] and not self.sig:
-            self.sig = self.sig_refs[0].sig
+            # If the spot itself doesn't have a SIG yet, but we have at least one SIG reference, take that reference's SIG
+            # and apply it to the whole spot.
+            if self.sig_refs and len(self.sig_refs) > 0 and self.sig_refs[0] and not self.sig:
+                self.sig = self.sig_refs[0].sig
 
-        # Always create an ID based on a hash of every parameter *except* received_time. This is used as the index
-        # to a map, which as a byproduct avoids us having multiple duplicate copies of the object that are identical
-        # apart from that they were retrieved from the API at different times. Note that the simple Python hash()
-        # function includes a seed randomly generated at runtime; this is therefore not consistent between runs. But we
-        # use diskcache to store our data between runs, so we use SHA256 which does not include this random element.
-        # The ID is computed before the online lookups below so that it is stable regardless of whether credentials
-        # are provided, allowing the enriched API response to be matched to the stored alert by ID.
-        if not self.id:
-            self_copy = copy.deepcopy(self)
-            self_copy.received_time = 0
-            self_copy.received_time_iso = ""
-            self.id = hashlib.sha256(str(self_copy).encode("utf-8")).hexdigest()
+            # Always create an ID based on a hash of every parameter *except* received_time. This is used as the index
+            # to a map, which as a byproduct avoids us having multiple duplicate copies of the object that are identical
+            # apart from that they were retrieved from the API at different times. Note that the simple Python hash()
+            # function includes a seed randomly generated at runtime; this is therefore not consistent between runs. But we
+            # use diskcache to store our data between runs, so we use SHA256 which does not include this random element.
+            # The ID is computed before the online lookups below so that it is stable regardless of whether credentials
+            # are provided, allowing the enriched API response to be matched to the stored alert by ID.
+            if not self.id:
+                self_copy = copy.deepcopy(self)
+                self_copy.received_time = 0
+                self_copy.received_time_iso = ""
+                self.id = hashlib.sha256(str(self_copy).encode("utf-8")).hexdigest()
 
-        # DX operator details lookup, using QRZ.com/HamQTH. This should be the last resort compared to taking the data
-        # from the actual alerting service, e.g. we don't want to accidentally use a user's QRZ.com home lat/lon
-        # instead of the one from the park reference they're at.
-        if self.dx_calls and not self.dx_names:
-            self.dx_names = list(
-                map(lambda c: lookup_helper.infer_name_from_callsign_online_lookup(c, credentials), self.dx_calls))
+            # DX operator details lookup, using QRZ.com/HamQTH. This should be the last resort compared to taking the data
+            # from the actual alerting service, e.g. we don't want to accidentally use a user's QRZ.com home lat/lon
+            # instead of the one from the park reference they're at.
+            if self.dx_calls and not self.dx_names:
+                self.dx_names = list(
+                    map(lambda c: lookup_helper.infer_name_from_callsign_online_lookup(c, credentials), self.dx_calls))
+
+        except Exception as e:
+            logging.error("Exception while inferring missing data from spot", e, exc_info=True)
 
     def to_json(self):
         """JSON serialise"""

data/spot.py

@@ -147,295 +147,299 @@ class Spot:
     def infer_missing(self, credentials=None):
         """Infer missing parameters where possible"""
 
-        # If we somehow don't have a spot time, set it to zero so it sorts off the bottom of any list but
-        # clients can still reliably parse it as a number.
-        if not self.time:
-            self.time = 0
+        try:
+            # If we somehow don't have a spot time, set it to zero so it sorts off the bottom of any list but
+            # clients can still reliably parse it as a number.
+            if not self.time:
+                self.time = 0
 
-        # If we don't have a received time, this has just been received so set that to "now"
-        if not self.received_time:
-            self.received_time = datetime.now(pytz.UTC).timestamp()
+            # If we don't have a received time, this has just been received so set that to "now"
+            if not self.received_time:
+                self.received_time = datetime.now(pytz.UTC).timestamp()
 
-        # Fill in ISO versions of times, in case the client prefers that
-        if self.time and not self.time_iso:
-            self.time_iso = datetime.fromtimestamp(self.time, pytz.UTC).isoformat()
-        if self.received_time and not self.received_time_iso:
-            self.received_time_iso = datetime.fromtimestamp(self.received_time, pytz.UTC).isoformat()
+            # Fill in ISO versions of times, in case the client prefers that
+            if self.time and not self.time_iso:
+                self.time_iso = datetime.fromtimestamp(self.time, pytz.UTC).isoformat()
+            if self.received_time and not self.received_time_iso:
+                self.received_time_iso = datetime.fromtimestamp(self.received_time, pytz.UTC).isoformat()
 
-        # Clean up DX call if it has an SSID or -# from RBN
-        if self.dx_call and "-" in self.dx_call:
-            split = self.dx_call.split("-")
-            self.dx_call = split[0]
-            if len(split) > 1 and split[1] != "#":
-                self.dx_ssid = split[1]
+            # Clean up DX call if it has an SSID or -# from RBN
+            if self.dx_call and "-" in self.dx_call:
+                split = self.dx_call.split("-")
+                self.dx_call = split[0]
+                if len(split) > 1 and split[1] != "#":
+                    self.dx_ssid = split[1]
 
-        # DX country, continent etc. from callsign
-        if self.dx_call and not self.dx_country:
-            self.dx_country = lookup_helper.infer_country_from_callsign(self.dx_call, credentials)
-        if self.dx_call and not self.dx_continent:
-            self.dx_continent = lookup_helper.infer_continent_from_callsign(self.dx_call, credentials)
-        if self.dx_call and not self.dx_dxcc_id:
-            self.dx_dxcc_id = lookup_helper.infer_dxcc_id_from_callsign(self.dx_call, credentials)
-        if self.dx_dxcc_id and not self.dx_flag:
-            self.dx_flag = lookup_helper.get_flag_for_dxcc(self.dx_dxcc_id)
+            # DX country, continent etc. from callsign
+            if self.dx_call and not self.dx_country:
+                self.dx_country = lookup_helper.infer_country_from_callsign(self.dx_call, credentials)
+            if self.dx_call and not self.dx_continent:
+                self.dx_continent = lookup_helper.infer_continent_from_callsign(self.dx_call, credentials)
+            if self.dx_call and not self.dx_dxcc_id:
+                self.dx_dxcc_id = lookup_helper.infer_dxcc_id_from_callsign(self.dx_call, credentials)
+            if self.dx_dxcc_id and not self.dx_flag:
+                self.dx_flag = lookup_helper.get_flag_for_dxcc(self.dx_dxcc_id)
 
-        # Clean up spotter call if it has an SSID or -# from RBN
-        if self.de_call and "-" in self.de_call:
-            split = self.de_call.split("-")
-            self.de_call = split[0]
-            if len(split) > 1 and split[1] != "#":
-                self.de_ssid = split[1]
+            # Clean up spotter call if it has an SSID or -# from RBN
+            if self.de_call and "-" in self.de_call:
+                split = self.de_call.split("-")
+                self.de_call = split[0]
+                if len(split) > 1 and split[1] != "#":
+                    self.de_ssid = split[1]
 
-        # If we have a spotter of "RBNHOLE", we should have the actual spotter callsign in the comment, so extract it.
-        # RBNHole posts come from a number of providers, so it's dealt with here in the generic spot handling code.
-        if self.de_call == "RBNHOLE" and self.comment:
-            rbnhole_call_match = re.search(r"\Wat ([a-z0-9/]+)\W", self.comment, re.IGNORECASE)
-            if rbnhole_call_match:
-                self.de_call = rbnhole_call_match.group(1).upper()
+            # If we have a spotter of "RBNHOLE", we should have the actual spotter callsign in the comment, so extract it.
+            # RBNHole posts come from a number of providers, so it's dealt with here in the generic spot handling code.
+            if self.de_call == "RBNHOLE" and self.comment:
+                rbnhole_call_match = re.search(r"\Wat ([a-z0-9/]+)\W", self.comment, re.IGNORECASE)
+                if rbnhole_call_match:
+                    self.de_call = rbnhole_call_match.group(1).upper()
 
-        # If we have a spotter of "SOTAMAT", we might have the actual spotter callsign in the comment, if so extract it.
-        # SOTAMAT can do POTA as well as SOTA, so it's dealt with here in the generic spot handling code.
-        if self.de_call == "SOTAMAT" and self.comment:
-            sotamat_call_match = re.search(r"\Wfrom ([a-z0-9/]+)]", self.comment, re.IGNORECASE)
-            if sotamat_call_match:
-                self.de_call = sotamat_call_match.group(1).upper()
+            # If we have a spotter of "SOTAMAT", we might have the actual spotter callsign in the comment, if so extract it.
+            # SOTAMAT can do POTA as well as SOTA, so it's dealt with here in the generic spot handling code.
+            if self.de_call == "SOTAMAT" and self.comment:
+                sotamat_call_match = re.search(r"\Wfrom ([a-z0-9/]+)]", self.comment, re.IGNORECASE)
+                if sotamat_call_match:
+                    self.de_call = sotamat_call_match.group(1).upper()
 
-        # Spotter country, continent, zones etc. from callsign.
-        # DE call with no digits, or APRS servers starting "T2" are not things we can look up location for
-        if self.de_call and any(char.isdigit() for char in self.de_call) and not (
-                self.de_call.startswith("T2") and self.source == "APRS-IS"):
-            if not self.de_country:
-                self.de_country = lookup_helper.infer_country_from_callsign(self.de_call, credentials)
-            if not self.de_continent:
-                self.de_continent = lookup_helper.infer_continent_from_callsign(self.de_call, credentials)
-            if not self.de_dxcc_id:
-                self.de_dxcc_id = lookup_helper.infer_dxcc_id_from_callsign(self.de_call, credentials)
-            if self.de_dxcc_id and not self.de_flag:
-                self.de_flag = lookup_helper.get_flag_for_dxcc(self.de_dxcc_id)
+            # Spotter country, continent, zones etc. from callsign.
+            # DE call with no digits, or APRS servers starting "T2" are not things we can look up location for
+            if self.de_call and any(char.isdigit() for char in self.de_call) and not (
+                    self.de_call.startswith("T2") and self.source == "APRS-IS"):
+                if not self.de_country:
+                    self.de_country = lookup_helper.infer_country_from_callsign(self.de_call, credentials)
+                if not self.de_continent:
+                    self.de_continent = lookup_helper.infer_continent_from_callsign(self.de_call, credentials)
+                if not self.de_dxcc_id:
+                    self.de_dxcc_id = lookup_helper.infer_dxcc_id_from_callsign(self.de_call, credentials)
+                if self.de_dxcc_id and not self.de_flag:
+                    self.de_flag = lookup_helper.get_flag_for_dxcc(self.de_dxcc_id)
 
-        # Remove NaNs in frequency
-        if self.freq and self.freq == float("nan"):
-            self.freq = None
+            # Remove NaNs in frequency
+            if self.freq and self.freq == float("nan"):
+                self.freq = None
 
-        # Band from frequency
-        if self.freq and not self.band:
-            band = infer_band_from_freq(self.freq)
-            self.band = band.name
+            # Band from frequency
+            if self.freq and not self.band:
+                band = infer_band_from_freq(self.freq)
+                self.band = band.name
 
-        # Mode from comments or bandplan
-        if self.mode:
-            self.mode_source = "SPOT"
-        if self.comment and not self.mode:
-            self.mode = infer_mode_from_comment(self.comment)
-            self.mode_source = "COMMENT"
-        if self.freq and not self.mode:
-            self.mode = infer_mode_from_frequency(self.freq)
-            self.mode_source = "BANDPLAN"
+            # Mode from comments or bandplan
+            if self.mode:
+                self.mode_source = "SPOT"
+            if self.comment and not self.mode:
+                self.mode = infer_mode_from_comment(self.comment)
+                self.mode_source = "COMMENT"
+            if self.freq and not self.mode:
+                self.mode = infer_mode_from_frequency(self.freq)
+                self.mode_source = "BANDPLAN"
 
-        # Normalise mode if necessary.
-        if self.mode in MODE_ALIASES:
-            self.mode = MODE_ALIASES[self.mode]
+            # Normalise mode if necessary.
+            if self.mode in MODE_ALIASES:
+                self.mode = MODE_ALIASES[self.mode]
 
-        # Mode type from mode
-        if self.mode and not self.mode_type:
-            self.mode_type = infer_mode_type_from_mode(self.mode)
+            # Mode type from mode
+            if self.mode and not self.mode_type:
+                self.mode_type = infer_mode_type_from_mode(self.mode)
 
-        # If we have a latitude or grid at this point, it can only have been provided by the spot itself
-        if self.dx_latitude or self.dx_grid:
-            self.dx_location_source = "SPOT"
+            # If we have a latitude or grid at this point, it can only have been provided by the spot itself
+            if self.dx_latitude or self.dx_grid:
+                self.dx_location_source = "SPOT"
 
-        # Set the top-level "SIG" if it is missing but we have at least one SIG ref.
-        if not self.sig and self.sig_refs and len(self.sig_refs) > 0:
-            self.sig = self.sig_refs[0].sig.upper()
+            # Set the top-level "SIG" if it is missing but we have at least one SIG ref.
+            if not self.sig and self.sig_refs and len(self.sig_refs) > 0:
+                self.sig = self.sig_refs[0].sig.upper()
 
-        # See if we already have a SIG reference, but the comment looks like it contains more for the same SIG. This
-        # should catch e.g. POTA comments like "2-fer: GB-0001 GB-0002".
-        if self.comment and self.sig_refs and len(self.sig_refs) > 0 and self.sig_refs[0].sig:
-            sig = self.sig_refs[0].sig.upper()
-            regex = get_ref_regex_for_sig(sig)
-            if regex:
-                all_comment_ref_matches = re.finditer(r"(^|\W)(" + regex + r")(^|\W)", self.comment, re.IGNORECASE)
-                for ref_match in all_comment_ref_matches:
-                    self._append_sig_ref_if_missing(SIGRef(id=ref_match.group(2).upper(), sig=sig))
+            # See if we already have a SIG reference, but the comment looks like it contains more for the same SIG. This
+            # should catch e.g. POTA comments like "2-fer: GB-0001 GB-0002".
+            if self.comment and self.sig_refs and len(self.sig_refs) > 0 and self.sig_refs[0].sig:
+                sig = self.sig_refs[0].sig.upper()
+                regex = get_ref_regex_for_sig(sig)
+                if regex:
+                    all_comment_ref_matches = re.finditer(r"(^|\W)(" + regex + r")(^|\W)", self.comment, re.IGNORECASE)
+                    for ref_match in all_comment_ref_matches:
+                        self._append_sig_ref_if_missing(SIGRef(id=ref_match.group(2).upper(), sig=sig))
 
-        # See if the comment looks like it contains any SIGs (and optionally SIG references) that we can
-        # add to the spot. This should catch cluster spot comments like "POTA GB-0001 WWFF GFF-0001" and e.g. POTA
-        # comments like "also WWFF GFF-0001".
-        if self.comment:
-            sig_matches = re.finditer(r"(^|\W)" + ANY_SIG_REGEX + r"($|\W)", self.comment, re.IGNORECASE)
-            for sig_match in sig_matches:
-                # First of all, if we haven't got a SIG for this spot set yet, now we have. This covers things like cluster
-                # spots where the comment is just "POTA".
-                found_sig = get_sig_name_from_comment_name(sig_match.group(2))
-                if not self.sig:
-                    self.sig = found_sig
+            # See if the comment looks like it contains any SIGs (and optionally SIG references) that we can
+            # add to the spot. This should catch cluster spot comments like "POTA GB-0001 WWFF GFF-0001" and e.g. POTA
+            # comments like "also WWFF GFF-0001".
+            if self.comment:
+                sig_matches = re.finditer(r"(^|\W)" + ANY_SIG_REGEX + r"($|\W)", self.comment, re.IGNORECASE)
+                for sig_match in sig_matches:
+                    # First of all, if we haven't got a SIG for this spot set yet, now we have. This covers things like cluster
+                    # spots where the comment is just "POTA".
+                    found_sig = get_sig_name_from_comment_name(sig_match.group(2))
+                    if not self.sig:
+                        self.sig = found_sig
 
-                # Now look to see if that SIG name was followed by something that looks like a reference ID for that SIG.
-                # If so, add that to the sig_refs list for this spot.
-                ref_regex = get_ref_regex_for_sig(found_sig)
-                if ref_regex:
-                    ref_matches = re.finditer(r"(^|\W)" + found_sig + r"([ -])(" + ref_regex + r")($|\W)", self.comment,
-                                              re.IGNORECASE)
-                    for ref_match in ref_matches:
-                        self._append_sig_ref_if_missing(SIGRef(id=ref_match.group(3).upper(), sig=found_sig))
+                    # Now look to see if that SIG name was followed by something that looks like a reference ID for that SIG.
+                    # If so, add that to the sig_refs list for this spot.
+                    ref_regex = get_ref_regex_for_sig(found_sig)
+                    if ref_regex:
+                        ref_matches = re.finditer(r"(^|\W)" + found_sig + r"([ -])(" + ref_regex + r")($|\W)", self.comment,
+                                                  re.IGNORECASE)
+                        for ref_match in ref_matches:
+                            self._append_sig_ref_if_missing(SIGRef(id=ref_match.group(3).upper(), sig=found_sig))
 
-        # Fetch SIG data. In case a particular API doesn't provide a full set of name, lat, lon & grid for a reference
-        # in its initial call, we use this code to populate the rest of the data. This includes working out grid refs
-        # from WAB and WAI, which count as a SIG even though there's no real lookup, just maths
-        if self.sig_refs and len(self.sig_refs) > 0:
-            for sig_ref in self.sig_refs:
-                sig_ref = populate_sig_ref_info(sig_ref)
-                # If the spot itself doesn't have location yet, but the SIG ref does, extract it
-                if sig_ref.grid and not self.dx_grid:
-                    self.dx_grid = sig_ref.grid
-                if sig_ref.latitude and not self.dx_latitude:
-                    self.dx_latitude = sig_ref.latitude
-                    self.dx_longitude = sig_ref.longitude
-                    if self.sig == "WAB" or self.sig == "WAI":
-                        self.dx_location_source = "WAB/WAI GRID"
-                    else:
-                        self.dx_location_source = "SIG REF LOOKUP"
+            # Fetch SIG data. In case a particular API doesn't provide a full set of name, lat, lon & grid for a reference
+            # in its initial call, we use this code to populate the rest of the data. This includes working out grid refs
+            # from WAB and WAI, which count as a SIG even though there's no real lookup, just maths
+            if self.sig_refs and len(self.sig_refs) > 0:
+                for sig_ref in self.sig_refs:
+                    sig_ref = populate_sig_ref_info(sig_ref)
+                    # If the spot itself doesn't have location yet, but the SIG ref does, extract it
+                    if sig_ref.grid and not self.dx_grid:
+                        self.dx_grid = sig_ref.grid
+                    if sig_ref.latitude and not self.dx_latitude:
+                        self.dx_latitude = sig_ref.latitude
+                        self.dx_longitude = sig_ref.longitude
+                        if self.sig == "WAB" or self.sig == "WAI":
+                            self.dx_location_source = "WAB/WAI GRID"
+                        else:
+                            self.dx_location_source = "SIG REF LOOKUP"
 
-        # If the spot itself doesn't have a SIG yet, but we have at least one SIG reference, take that reference's SIG
-        # and apply it to the whole spot.
-        if self.sig_refs and len(self.sig_refs) > 0 and not self.sig:
-            self.sig = self.sig_refs[0].sig
+            # If the spot itself doesn't have a SIG yet, but we have at least one SIG reference, take that reference's SIG
+            # and apply it to the whole spot.
+            if self.sig_refs and len(self.sig_refs) > 0 and not self.sig:
+                self.sig = self.sig_refs[0].sig
 
-        # Parse "de_grid<prop_mode>dx_grid" structures from the comment, e.g. "JN61ES(ES)JM56XT" or "JO02GQ<>KN17LG".
-        # These are common on cluster spots and can provide grid references in preference to e.g. QRZ lookup, as well as
-        # being the only source we have for propagation mode. Brace for nightmare regex from hell.
-        if self.comment:
-            grid_mode_grid_match = re.search(
-                r'\b([A-Ra-r]{2}\d{2}(?:[A-Xa-x]{2}(?:\d{2})?)?)(?:<([^>]*)>|\(([^)]*)\))([A-Ra-r]{2}\d{2}(?:[A-Xa-x]{2}(?:\d{2})?)?)\b',
-                self.comment)
-            if grid_mode_grid_match:
-                # regex matches, so extract grids:
-                if not self.de_grid:
-                    self.de_grid = grid_mode_grid_match.group(1).upper()
-                if not self.dx_grid:
-                    self.dx_grid = grid_mode_grid_match.group(4).upper()
-                    self.dx_location_source = "SPOT"
+            # Parse "de_grid<prop_mode>dx_grid" structures from the comment, e.g. "JN61ES(ES)JM56XT" or "JO02GQ<>KN17LG".
+            # These are common on cluster spots and can provide grid references in preference to e.g. QRZ lookup, as well as
+            # being the only source we have for propagation mode. Brace for nightmare regex from hell.
+            if self.comment:
+                grid_mode_grid_match = re.search(
+                    r'\b([A-Ra-r]{2}\d{2}(?:[A-Xa-x]{2}(?:\d{2})?)?)(?:<([^>]*)>|\(([^)]*)\))([A-Ra-r]{2}\d{2}(?:[A-Xa-x]{2}(?:\d{2})?)?)\b',
+                    self.comment)
+                if grid_mode_grid_match:
+                    # regex matches, so extract grids:
+                    if not self.de_grid:
+                        self.de_grid = grid_mode_grid_match.group(1).upper()
+                    if not self.dx_grid:
+                        self.dx_grid = grid_mode_grid_match.group(4).upper()
+                        self.dx_location_source = "SPOT"
 
-                # And extract propagation mode (group 2 for <...>, group 3 for (...)):
-                mode_tag = (grid_mode_grid_match.group(2) or grid_mode_grid_match.group(3) or "").upper()
-                if mode_tag and not self.propagation_mode:
-                    if mode_tag in PROPAGATION_MODES:
-                        self.propagation_mode = PROPAGATION_MODES[mode_tag]
-                    else:
-                        self.propagation_mode = mode_tag
-                        logging.info("Seen a new propagation mode tag not yet in the system: %s", mode_tag)
+                    # And extract propagation mode (group 2 for <...>, group 3 for (...)):
+                    mode_tag = (grid_mode_grid_match.group(2) or grid_mode_grid_match.group(3) or "").upper()
+                    if mode_tag and not self.propagation_mode:
+                        if mode_tag in PROPAGATION_MODES:
+                            self.propagation_mode = PROPAGATION_MODES[mode_tag]
+                        else:
+                            self.propagation_mode = mode_tag
+                            logging.info("Seen a new propagation mode tag not yet in the system: %s", mode_tag)
 
-        # DX Grid to lat/lon and vice versa in case one is missing
-        if self.dx_grid and not self.dx_latitude:
-            try:
-                ll = locator_to_latlong(self.dx_grid)
-                self.dx_latitude = ll[0]
-                self.dx_longitude = ll[1]
-            except:
-                logging.debug("Invalid grid received for spot")
-        if self.dx_latitude and self.dx_longitude and not self.dx_grid:
-            try:
-                self.dx_grid = latlong_to_locator(self.dx_latitude, self.dx_longitude, 8)
-            except:
-                logging.debug("Invalid lat/lon received for spot")
+            # DX Grid to lat/lon and vice versa in case one is missing
+            if self.dx_grid and not self.dx_latitude:
+                try:
+                    ll = locator_to_latlong(self.dx_grid)
+                    self.dx_latitude = ll[0]
+                    self.dx_longitude = ll[1]
+                except:
+                    logging.debug("Invalid grid received for spot")
+            if self.dx_latitude and self.dx_longitude and not self.dx_grid:
+                try:
+                    self.dx_grid = latlong_to_locator(self.dx_latitude, self.dx_longitude, 8)
+                except:
+                    logging.debug("Invalid lat/lon received for spot")
 
-        # QRT comment detection
-        if self.comment and not self.qrt:
-            self.qrt = "QRT" in self.comment.upper()
+            # QRT comment detection
+            if self.comment and not self.qrt:
+                self.qrt = "QRT" in self.comment.upper()
 
-        # Always create an ID based on a hash of every parameter *except* received_time. This is used as the index
-        # to a map, which as a byproduct avoids us having multiple duplicate copies of the object that are identical
-        # apart from that they were retrieved from the API at different times. Note that the simple Python hash()
-        # function includes a seed randomly generated at runtime; this is therefore not consistent between runs. But we
-        # use diskcache to store our data between runs, so we use SHA256 which does not include this random element.
-        # The ID is computed before the online lookups below so that it is stable regardless of whether credentials
-        # are provided, allowing the enriched API response to be matched to the stored spot by ID.
-        if not self.id:
-            self_copy = copy.deepcopy(self)
-            self_copy.received_time = 0
-            self_copy.received_time_iso = ""
-            self.id = hashlib.sha256(str(self_copy).encode("utf-8")).hexdigest()
+            # Always create an ID based on a hash of every parameter *except* received_time. This is used as the index
+            # to a map, which as a byproduct avoids us having multiple duplicate copies of the object that are identical
+            # apart from that they were retrieved from the API at different times. Note that the simple Python hash()
+            # function includes a seed randomly generated at runtime; this is therefore not consistent between runs. But we
+            # use diskcache to store our data between runs, so we use SHA256 which does not include this random element.
+            # The ID is computed before the online lookups below so that it is stable regardless of whether credentials
+            # are provided, allowing the enriched API response to be matched to the stored spot by ID.
+            if not self.id:
+                self_copy = copy.deepcopy(self)
+                self_copy.received_time = 0
+                self_copy.received_time_iso = ""
+                self.id = hashlib.sha256(str(self_copy).encode("utf-8")).hexdigest()
 
-        # DX operator details lookup, using QRZ.com/HamQTH. This should be the last resort compared to taking the data
-        # from the actual spotting service, e.g. we don't want to accidentally use a user's QRZ.com home lat/lon
-        # instead of the one from the park reference they're at.
-        if self.dx_call and not self.dx_name:
-            self.dx_name = lookup_helper.infer_name_from_callsign_online_lookup(self.dx_call, credentials)
-        if self.dx_call and not self.dx_latitude:
-            latlon = lookup_helper.infer_latlon_from_callsign_online_lookup(self.dx_call, credentials)
-            if latlon:
-                self.dx_latitude = latlon[0]
-                self.dx_longitude = latlon[1]
-            self.dx_grid = lookup_helper.infer_grid_from_callsign_online_lookup(self.dx_call, credentials)
-            self.dx_location_source = "HOME QTH"
-
-        # Determine a "QTH" string. If we have a SIG ref, pick the first one and turn it into a suitable string,
-        # otherwise see what they have set on an online lookup service.
-        if self.sig_refs and len(self.sig_refs) > 0:
-            qth = self.sig_refs[0].id
-            if self.sig_refs[0].name:
-                qth += " " + self.sig_refs[0].name
-            self.dx_qth = qth
-        else:
-            self.dx_qth = lookup_helper.infer_qth_from_callsign_online_lookup(self.dx_call, credentials)
-
-        # Last resort for getting a DX position, use the DXCC entity.
-        if self.dx_call and not self.dx_latitude:
-            latlon = lookup_helper.infer_latlon_from_callsign_dxcc(self.dx_call)
-            if latlon:
-                self.dx_latitude = latlon[0]
-                self.dx_longitude = latlon[1]
-                self.dx_grid = lookup_helper.infer_grid_from_callsign_dxcc(self.dx_call)
-                self.dx_location_source = "DXCC"
-
-        # It looks like we can sometimes get a string into lat/lon, so try to parse as float, reject if not valid
-        if isinstance(self.dx_latitude, str) or isinstance(self.dx_longitude, str):
-            try:
-                self.dx_latitude = float(str(self.dx_latitude))
-                self.dx_longitude = float(str(self.dx_longitude))
-            except (TypeError, ValueError):
-                logging.warning("Received non-numeric strings in lat/lon (" + str(self.dx_latitude) + ", " + str(
-                    self.dx_longitude) + ") for call " + str(self.dx_call) + ", rejecting it")
-                self.dx_latitude = None
-                self.dx_longitude = None
-
-        # CQ and ITU zone lookup, preferably from location but failing that, from callsign
-        if not self.dx_cq_zone:
-            if self.dx_latitude:
-                self.dx_cq_zone = lat_lon_to_cq_zone(self.dx_latitude, self.dx_longitude)
-            elif self.dx_call:
-                self.dx_cq_zone = lookup_helper.infer_cq_zone_from_callsign(self.dx_call, credentials)
-        if not self.dx_itu_zone:
-            if self.dx_latitude:
-                self.dx_itu_zone = lat_lon_to_itu_zone(self.dx_latitude, self.dx_longitude)
-            elif self.dx_call:
-                self.dx_itu_zone = lookup_helper.infer_itu_zone_from_callsign(self.dx_call, credentials)
-
-        # DX Location is "good" if it is from a spot, or from QRZ if the callsign doesn't contain a slash, so the operator
-        # is likely at home.
-        self.dx_location_good = bool(self.dx_latitude and self.dx_longitude and (
-                self.dx_location_source == "SPOT" or self.dx_location_source == "SIG REF LOOKUP"
-                or self.dx_location_source == "WAB/WAI GRID"
-                or (self.dx_location_source == "HOME QTH" and "/" not in (self.dx_call or ""))))
-
-        # DE with no digits and APRS servers starting "T2" are not things we can look up location for
-        if self.de_call and any(char.isdigit() for char in self.de_call) and not (
-                self.de_call.startswith("T2") and self.source == "APRS-IS"):
-            # DE operator position lookup, using QRZ.com/HamQTH.
-            if not self.de_latitude:
-                latlon = lookup_helper.infer_latlon_from_callsign_online_lookup(self.de_call, credentials)
+            # DX operator details lookup, using QRZ.com/HamQTH. This should be the last resort compared to taking the data
+            # from the actual spotting service, e.g. we don't want to accidentally use a user's QRZ.com home lat/lon
+            # instead of the one from the park reference they're at.
+            if self.dx_call and not self.dx_name:
+                self.dx_name = lookup_helper.infer_name_from_callsign_online_lookup(self.dx_call, credentials)
+            if self.dx_call and not self.dx_latitude:
+                latlon = lookup_helper.infer_latlon_from_callsign_online_lookup(self.dx_call, credentials)
                 if latlon:
-                    self.de_latitude = latlon[0]
-                    self.de_longitude = latlon[1]
-                self.de_grid = lookup_helper.infer_grid_from_callsign_online_lookup(self.de_call, credentials)
+                    self.dx_latitude = latlon[0]
+                    self.dx_longitude = latlon[1]
+                self.dx_grid = lookup_helper.infer_grid_from_callsign_online_lookup(self.dx_call, credentials)
+                self.dx_location_source = "HOME QTH"
 
-            # Last resort for getting a DE position, use the DXCC entity.
-            if not self.de_latitude:
-                latlon = lookup_helper.infer_latlon_from_callsign_dxcc(self.de_call)
+            # Determine a "QTH" string. If we have a SIG ref, pick the first one and turn it into a suitable string,
+            # otherwise see what they have set on an online lookup service.
+            if self.sig_refs and len(self.sig_refs) > 0:
+                qth = self.sig_refs[0].id
+                if self.sig_refs[0].name:
+                    qth += " " + self.sig_refs[0].name
+                self.dx_qth = qth
+            else:
+                self.dx_qth = lookup_helper.infer_qth_from_callsign_online_lookup(self.dx_call, credentials)
+
+            # Last resort for getting a DX position, use the DXCC entity.
+            if self.dx_call and not self.dx_latitude:
+                latlon = lookup_helper.infer_latlon_from_callsign_dxcc(self.dx_call)
                 if latlon:
-                    self.de_latitude = latlon[0]
-                    self.de_longitude = latlon[1]
-                    self.de_grid = lookup_helper.infer_grid_from_callsign_dxcc(self.de_call)
+                    self.dx_latitude = latlon[0]
+                    self.dx_longitude = latlon[1]
+                    self.dx_grid = lookup_helper.infer_grid_from_callsign_dxcc(self.dx_call)
+                    self.dx_location_source = "DXCC"
+
+            # It looks like we can sometimes get a string into lat/lon, so try to parse as float, reject if not valid
+            if isinstance(self.dx_latitude, str) or isinstance(self.dx_longitude, str):
+                try:
+                    self.dx_latitude = float(str(self.dx_latitude))
+                    self.dx_longitude = float(str(self.dx_longitude))
+                except (TypeError, ValueError):
+                    logging.warning("Received non-numeric strings in lat/lon (" + str(self.dx_latitude) + ", " + str(
+                        self.dx_longitude) + ") for call " + str(self.dx_call) + ", rejecting it")
+                    self.dx_latitude = None
+                    self.dx_longitude = None
+
+            # CQ and ITU zone lookup, preferably from location but failing that, from callsign
+            if not self.dx_cq_zone:
+                if self.dx_latitude:
+                    self.dx_cq_zone = lat_lon_to_cq_zone(self.dx_latitude, self.dx_longitude)
+                elif self.dx_call:
+                    self.dx_cq_zone = lookup_helper.infer_cq_zone_from_callsign(self.dx_call, credentials)
+            if not self.dx_itu_zone:
+                if self.dx_latitude:
+                    self.dx_itu_zone = lat_lon_to_itu_zone(self.dx_latitude, self.dx_longitude)
+                elif self.dx_call:
+                    self.dx_itu_zone = lookup_helper.infer_itu_zone_from_callsign(self.dx_call, credentials)
+
+            # DX Location is "good" if it is from a spot, or from QRZ if the callsign doesn't contain a slash, so the operator
+            # is likely at home.
+            self.dx_location_good = bool(self.dx_latitude and self.dx_longitude and (
+                    self.dx_location_source == "SPOT" or self.dx_location_source == "SIG REF LOOKUP"
+                    or self.dx_location_source == "WAB/WAI GRID"
+                    or (self.dx_location_source == "HOME QTH" and "/" not in (self.dx_call or ""))))
+
+            # DE with no digits and APRS servers starting "T2" are not things we can look up location for
+            if self.de_call and any(char.isdigit() for char in self.de_call) and not (
+                    self.de_call.startswith("T2") and self.source == "APRS-IS"):
+                # DE operator position lookup, using QRZ.com/HamQTH.
+                if not self.de_latitude:
+                    latlon = lookup_helper.infer_latlon_from_callsign_online_lookup(self.de_call, credentials)
+                    if latlon:
+                        self.de_latitude = latlon[0]
+                        self.de_longitude = latlon[1]
+                    self.de_grid = lookup_helper.infer_grid_from_callsign_online_lookup(self.de_call, credentials)
+
+                # Last resort for getting a DE position, use the DXCC entity.
+                if not self.de_latitude:
+                    latlon = lookup_helper.infer_latlon_from_callsign_dxcc(self.de_call)
+                    if latlon:
+                        self.de_latitude = latlon[0]
+                        self.de_longitude = latlon[1]
+                        self.de_grid = lookup_helper.infer_grid_from_callsign_dxcc(self.de_call)
+
+        except Exception as e:
+            logging.error("Exception while inferring missing data from spot", e, exc_info=True)
 
     def to_json(self):
         """JSON serialise"""

datafiles/39c3-tota.csv

@@ -1,18 +0,0 @@
-ref,lat,lon
-T-01,53.56278090617755,9.984341869295505
-T-02,53.562383404176416,9.98551893027115
-T-03,53.56170184391514,9.985416035619778
-T-04,53.562026534393176,9.986372919078974
-T-11,53.56284641242506,9.98475590239655
-T-12,53.562431705517035,9.98551675702443
-T-13,53.56223704898424,9.985774520335664
-T-14,53.5617893512591,9.986344302837976
-T-21,53.56284641242506,9.98475590239655
-T-22,53.56245816412497,9.985456089490567
-T-23,53.56199560857136,9.985636761412673
-T-24,53.5617893512591,9.986344302837976
-T-31,53.56247470064887,9.985611427551902
-T-32,53.5617893512591,9.986344302837976
-T-41,53.56245039134992,9.985486136112701
-T-91,53.56147934973529,9.984626806439744
-T-92,53.561396810300735,9.987553052152899

datafiles/eh23-tota.csv

@@ -1,13 +0,0 @@
-ref,lat,lon
-T-01,50.3636495,7.5584857
-T-02,50.3636495,7.5584857
-T-03,50.3636495,7.5584857
-T-11,50.3636495,7.5584857
-T-13,50.3636495,7.5584857
-T-14,50.3636495,7.5584857
-T-21,50.3636495,7.5584857
-T-31,50.3636495,7.5584857
-T-33,50.3636495,7.5584857
-T-34,50.3636495,7.5584857
-T-41,50.3636495,7.5584857
-T-51,50.3636495,7.5584857

datafiles/toilets.csv

@@ -0,0 +1,30 @@
+ref,lat,lon
+C3 T-01,53.56278090617755,9.984341869295505
+C3 T-02,53.562383404176416,9.98551893027115
+C3 T-03,53.56170184391514,9.985416035619778
+C3 T-04,53.562026534393176,9.986372919078974
+C3 T-11,53.56284641242506,9.98475590239655
+C3 T-12,53.562431705517035,9.98551675702443
+C3 T-13,53.56223704898424,9.985774520335664
+C3 T-14,53.5617893512591,9.986344302837976
+C3 T-21,53.56284641242506,9.98475590239655
+C3 T-22,53.56245816412497,9.985456089490567
+C3 T-23,53.56199560857136,9.985636761412673
+C3 T-24,53.5617893512591,9.986344302837976
+C3 T-31,53.56247470064887,9.985611427551902
+C3 T-32,53.5617893512591,9.986344302837976
+C3 T-41,53.56245039134992,9.985486136112701
+C3 T-91,53.56147934973529,9.984626806439744
+C3 T-92,53.561396810300735,9.987553052152899
+EH T-01,50.3636495,7.5584857
+EH T-02,50.3636495,7.5584857
+EH T-03,50.3636495,7.5584857
+EH T-11,50.3636495,7.5584857
+EH T-13,50.3636495,7.5584857
+EH T-14,50.3636495,7.5584857
+EH T-21,50.3636495,7.5584857
+EH T-31,50.3636495,7.5584857
+EH T-33,50.3636495,7.5584857
+EH T-34,50.3636495,7.5584857
+EH T-41,50.3636495,7.5584857
+EH T-51,50.3636495,7.5584857

server/webserver.py

@@ -72,7 +72,8 @@ class WebServer:
              {"sse_spot_broadcaster": self._spot_broadcaster, **handler_opts}),
             (r"/api/v1/alerts/stream", APIAlertsStreamHandler,
              {"sse_alert_broadcaster": self._alert_broadcaster, **handler_opts}),
-            (r"/api/v1/solar", APISolarConditionsHandler, {"solar_conditions": self._data_store.solar, **handler_opts}),
+            (r"/api/v1/solar", APISolarConditionsHandler, {"solar_conditions": self._data_store.solar_conditions,
+                                                           **handler_opts}),
             (r"/api/v1/dxstats", APIDxStatsHandler, {"spots": self._data_store.spots, **handler_opts}),
             (r"/api/v1/options", APIOptionsHandler, {"status_data": self._data_store.status_data, **handler_opts}),
             (r"/api/v1/status", APIStatusHandler, {"status_data": self._data_store.status_data, **handler_opts}),

sigrefdataproviders/arlhs.py

@@ -0,0 +1,30 @@
+import csv
+
+from data.sig_ref import SIGRef
+from sigrefdataproviders.file_download_sig_ref_data_provider import FileDownloadSIGRefDataProvider
+
+
+class ARLHS(FileDownloadSIGRefDataProvider):
+    """SIG ref data provider for Amateur Radio Light House Society"""
+
+    POLL_INTERVAL_DAYS = 30
+    SIG = "ARLHS"
+    DATA_URL = "https://www.gma.rocks/download/lighthouse.csv"
+
+    def __init__(self, provider_config):
+        super().__init__(self.SIG, provider_config, self.DATA_URL, self.POLL_INTERVAL_DAYS)
+
+    def _http_response_to_data(self, http_response):
+        new_data = []
+        for row in csv.DictReader(http_response.content.decode("utf-8-sig").splitlines()[1:]):
+            if "ARLHS" in row and row["ARLHS"] != "":
+                ref_id = row["ARLHS"]
+                new_data.append(SIGRef(sig=self.SIG, id=ref_id, name=row["Name"] if "Name" in row else None,
+                                          url="https://www.cqgma.org/zinfo.php?ref=" + ref_id,
+                                          latitude=float(row["Latitude"]) if "Latitude" in row and row[
+                                              "Latitude"] != "" else None,
+                                          longitude=float(row["Longitude"]) if "Longitude" in row and row[
+                                              "Longitude"] != "" else None,
+                                          grid=row["Maidenhead Locator"]))
+
+        return new_data

sigrefdataproviders/dme.py

@@ -0,0 +1,35 @@
+import csv
+
+from pyhamtools.locator import latlong_to_locator
+
+from data.sig_ref import SIGRef
+from sigrefdataproviders.local_file_sig_ref_data_provider import LocalFileSIGRefDataProvider
+
+
+class DME(LocalFileSIGRefDataProvider):
+    """SIG ref data provider for Diploma Municipios de Espana"""
+
+    SIG = "DME"
+    PATH = "datafiles/MUNICIPIOS.csv"
+
+    def __init__(self, provider_config):
+        super().__init__(self.SIG, provider_config, self.PATH)
+
+    def _file_to_data(self, path):
+        new_data = []
+        with open(path, encoding="latin-1") as _f:
+            for row in csv.DictReader(_f, delimiter=";"):
+                ref_id = row["COD_INE"][:5]
+                latitude = float(row["LATITUD_ETRS89_REGCAN95"].replace(",", ".")) if row.get(
+                    "LATITUD_ETRS89_REGCAN95") else None
+                longitude = float(row["LONGITUD_ETRS89_REGCAN95"].replace(",", ".")) if row.get(
+                    "LONGITUD_ETRS89_REGCAN95") else None
+
+                ref = SIGRef(sig=self.SIG, id=ref_id,
+                                          name=row["NOMBRE_ACTUAL"] + ", " + row["PROVINCIA"],
+                                          latitude=latitude,
+                                          longitude=longitude)
+                if latitude and longitude:
+                    ref.grid = latlong_to_locator(latitude, longitude, 6)
+                new_data.append(ref)
+        return new_data

sigrefdataproviders/file_download_sig_ref_data_provider.py

@@ -0,0 +1,77 @@
+import logging
+from datetime import datetime
+from threading import Thread, Event
+
+import pytz
+from requests import ReadTimeout
+from requests.exceptions import ConnectionError, ConnectTimeout
+
+from core.constants import HTTP_HEADERS
+from core.url_data_cache import URL_DATA_CACHE
+from sigrefdataproviders.sig_ref_data_provider import SIGRefDataProvider
+
+
+class FileDownloadSIGRefDataProvider(SIGRefDataProvider):
+    """Generic SIG ref data provider class for providers that fetch their data from the web by downloading a file."""
+
+    def __init__(self, sig_name, provider_config, url, poll_interval):
+        """ Set up the provider, note poll_interval is in *days*."""
+        super().__init__(sig_name, provider_config)
+        self._url = url
+        self._poll_interval = poll_interval
+        self._thread = None
+        self._stop_event = Event()
+
+    def start(self):
+        # Fire off the polling thread. It will poll immediately on startup, then sleep for poll_interval between
+        # subsequent polls, so start() returns immediately and the application can continue starting.
+        logging.info(
+            "Set up query of " + self.sig_name + " SIG ref data every " + str(self._poll_interval) + " days.")
+        self._thread = Thread(target=self._run, daemon=True)
+        self._thread.start()
+
+    def stop(self):
+        self._stop_event.set()
+
+    def _run(self):
+        while True:
+            self._poll()
+            if self._stop_event.wait(timeout=self._poll_interval * 60 * 60 * 24):
+                break
+
+    def _poll(self):
+        try:
+            # Request data from API. Use the data cache (with a TTL of 1 day) here, not as the main mechanism for
+            # caching, but just so continual restarts of the software during testing don't hammer the servers.
+            logging.debug("Downloading " + self.sig_name + " SIG ref data...")
+            http_response = URL_DATA_CACHE.get(self._url, headers=HTTP_HEADERS)
+            # Check response code was good
+            if http_response.ok:
+                # Pass off to the subclass for processing
+                new_data = self._http_response_to_data(http_response)
+                # Submit the new spots for processing. There might not be any spots for the less popular programs.
+                if new_data:
+                    self._add_data(new_data)
+
+                self.status = "OK"
+                self.last_update_time = datetime.now(pytz.UTC)
+                logging.debug("Received SIG ref data for " + self.sig_name)
+            else:
+                self.status = "Error"
+                logging.warning(f"HTTP {http_response.status_code} when downloading SIG ref data for {self.sig_name}.")
+
+        except ConnectionError:
+            logging.warning(f"Connection error when downloading SIG ref data for {self.sig_name}.")
+        except (ConnectTimeout, ReadTimeout):
+            logging.warning(f"Timeout when downloading SIG ref data for {self.sig_name}.")
+        except Exception:
+            self.status = "Error"
+            logging.exception("Exception in HTTP SIG Ref Data Provider (" + self.sig_name + ")")
+            self._stop_event.wait(timeout=1)
+
+    def _http_response_to_data(self, http_response):
+        """Convert an HTTP response returned by the server into SIG Ref data. The whole response is provided here so the
+        subclass implementations can check for HTTP status codes if necessary, and handle the response as JSON, CSV,
+        whatever the remote file actually is."""
+
+        raise NotImplementedError("Subclasses must implement this method")

sigrefdataproviders/gma.py

@@ -0,0 +1,29 @@
+import csv
+
+from data.sig_ref import SIGRef
+from sigrefdataproviders.file_download_sig_ref_data_provider import FileDownloadSIGRefDataProvider
+
+
+class GMA(FileDownloadSIGRefDataProvider):
+    """SIG ref data provider for Global Mountain Activity"""
+
+    POLL_INTERVAL_DAYS = 30
+    SIG = "GMA"
+    DATA_URL = "https://www.gma.rocks/download/summits.csv"
+
+    def __init__(self, provider_config):
+        super().__init__(self.SIG, provider_config, self.DATA_URL, self.POLL_INTERVAL_DAYS)
+
+    def _http_response_to_data(self, http_response):
+        new_data = []
+        for row in csv.DictReader(http_response.content.decode("utf-8-sig").splitlines()[1:]):
+            ref_id = row["Reference"]
+            new_data.append(SIGRef(sig=self.SIG, id=ref_id, name=row["Name"] if "Name" in row else None,
+                                      url="https://www.cqgma.org/zinfo.php?ref=" + ref_id,
+                                      latitude=float(row["Latitude"]) if "Latitude" in row and row[
+                                          "Latitude"] != "" else None,
+                                      longitude=float(row["Longitude"]) if "Longitude" in row and row[
+                                          "Longitude"] != "" else None,
+                                      grid=row["Maidenhead Locator"]))
+
+        return new_data

sigrefdataproviders/illw.py

@@ -0,0 +1,30 @@
+import csv
+
+from data.sig_ref import SIGRef
+from sigrefdataproviders.file_download_sig_ref_data_provider import FileDownloadSIGRefDataProvider
+
+
+class ILLW(FileDownloadSIGRefDataProvider):
+    """SIG ref data provider for International Lighthouse & Lightship Weekend"""
+
+    POLL_INTERVAL_DAYS = 30
+    SIG = "ILLW"
+    DATA_URL = "https://www.gma.rocks/download/lighthouse.csv"
+
+    def __init__(self, provider_config):
+        super().__init__(self.SIG, provider_config, self.DATA_URL, self.POLL_INTERVAL_DAYS)
+
+    def _http_response_to_data(self, http_response):
+        new_data = []
+        for row in csv.DictReader(http_response.content.decode("utf-8-sig").splitlines()[1:]):
+            if "ILLW" in row and row["ILLW"] != "":
+                ref_id = row["ILLW"]
+                new_data.append(SIGRef(sig=self.SIG, id=ref_id, name=row["Name"] if "Name" in row else None,
+                                          url="https://www.cqgma.org/zinfo.php?ref=" + ref_id,
+                                          latitude=float(row["Latitude"]) if "Latitude" in row and row[
+                                              "Latitude"] != "" else None,
+                                          longitude=float(row["Longitude"]) if "Longitude" in row and row[
+                                              "Longitude"] != "" else None,
+                                          grid=row["Maidenhead Locator"]))
+
+        return new_data

sigrefdataproviders/iota.py

@@ -0,0 +1,36 @@
+import logging
+
+from pyhamtools.locator import latlong_to_locator
+
+from data.sig_ref import SIGRef
+from sigrefdataproviders.file_download_sig_ref_data_provider import FileDownloadSIGRefDataProvider
+
+
+class IOTA(FileDownloadSIGRefDataProvider):
+    """SIG ref data provider for Islands on the Air"""
+
+    POLL_INTERVAL_DAYS = 365
+    SIG = "IOTA"
+    DATA_URL = "https://www.iota-world.org/islands-on-the-air/downloads/download-file.html?path=groups.json"
+
+    def __init__(self, provider_config):
+        super().__init__(self.SIG, provider_config, self.DATA_URL, self.POLL_INTERVAL_DAYS)
+
+    def _http_response_to_data(self, http_response):
+        new_data = []
+        data = http_response.json()
+        if isinstance(data, list):
+            for ref in data:
+                ref_id = ref["refno"]
+                latitude = float(ref["latitude_min"]) + float(ref["latitude_max"]) / 2.0
+                longitude = float(ref["longitude_min"]) + float(ref["longitude_max"]) / 2.0
+                grid = None
+                try:
+                    grid = latlong_to_locator(latitude, longitude, 6)
+                except ValueError:
+                    logging.debug(f"Error converting lat/lon to locator for an IOTA reference %f %f", latitude, longitude)
+
+                new_data.append(SIGRef(sig=self.SIG, id=ref_id, name=ref["name"],
+                                          grid=grid, latitude=latitude, longitude=longitude))
+
+        return new_data

sigrefdataproviders/llota.py

@@ -0,0 +1,32 @@
+from pyhamtools.locator import locator_to_latlong
+
+from data.sig_ref import SIGRef
+from sigrefdataproviders.file_download_sig_ref_data_provider import FileDownloadSIGRefDataProvider
+
+
+class LLOTA(FileDownloadSIGRefDataProvider):
+    """SIG ref data provider for Lagos y Lagunas on the Air"""
+
+    POLL_INTERVAL_DAYS = 7
+    SIG = "LLOTA"
+    DATA_URL = "https://llota.app/api/public/references"
+
+    def __init__(self, provider_config):
+        super().__init__(self.SIG, provider_config, self.DATA_URL, self.POLL_INTERVAL_DAYS)
+
+    def _http_response_to_data(self, http_response):
+        new_data = []
+        data = http_response.json()
+        if isinstance(data, list):
+            for ref in data:
+                ref_id = ref["reference_code"]
+                grid = str(ref["grid_locator"])
+                ll = locator_to_latlong(grid)
+
+                new_data.append(SIGRef(sig=self.SIG, id=ref_id, name=str(ref["name"]),
+                                          url="https://llota.app/list/ref/" + ref_id,
+                                          grid=grid,
+                                          latitude=ll[0],
+                                          longitude=ll[1]))
+
+        return new_data

sigrefdataproviders/local_file_sig_ref_data_provider.py

@@ -0,0 +1,36 @@
+import logging
+from datetime import datetime
+
+import pytz
+
+from sigrefdataproviders.sig_ref_data_provider import SIGRefDataProvider
+
+
+class LocalFileSIGRefDataProvider(SIGRefDataProvider):
+    """Generic SIG ref data provider class for providers that fetch their data from a local file on startup."""
+
+    def __init__(self, sig, provider_config, path):
+        super().__init__(sig, provider_config)
+        self._path = path
+
+    def start(self):
+        logging.debug("Loading " + self.sig_name + " SIG ref data from file.")
+        try:
+            new_data = self._file_to_data(self._path)
+            if new_data:
+                self._add_data(new_data)
+                self.status = "OK"
+                self.last_update_time = datetime.now(pytz.UTC)
+            else:
+                logging.info("No new SIG ref data found for " + self.sig_name)
+        except Exception as e:
+            self.status = "Error"
+            logging.exception("Exception in local file SIG Ref Data Provider (" + self.sig_name + ")")
+
+    def stop(self):
+        pass
+
+    def _file_to_data(self, path):
+        """Load a file on the given path and turn it into SIG Ref data."""
+
+        raise NotImplementedError("Subclasses must implement this method")

sigrefdataproviders/mota.py

@@ -0,0 +1,29 @@
+import csv
+
+from data.sig_ref import SIGRef
+from sigrefdataproviders.file_download_sig_ref_data_provider import FileDownloadSIGRefDataProvider
+
+
+class MOTA(FileDownloadSIGRefDataProvider):
+    """SIG ref data provider for Mills on the Air"""
+
+    POLL_INTERVAL_DAYS = 30
+    SIG = "MOTA"
+    DATA_URL = "https://www.gma.rocks/download/mills.csv"
+
+    def __init__(self, provider_config):
+        super().__init__(self.SIG, provider_config, self.DATA_URL, self.POLL_INTERVAL_DAYS)
+
+    def _http_response_to_data(self, http_response):
+        new_data = []
+        for row in csv.DictReader(http_response.content.decode("utf-8-sig").splitlines()[1:]):
+            ref_id = row["Reference"]
+            new_data.append(SIGRef(sig=self.SIG, id=ref_id, name=row["Name"] if "Name" in row else None,
+                                      url="https://www.cqgma.org/zinfo.php?ref=" + ref_id,
+                                      latitude=float(row["Latitude"]) if "Latitude" in row and row[
+                                          "Latitude"] != "" else None,
+                                      longitude=float(row["Longitude"]) if "Longitude" in row and row[
+                                          "Longitude"] != "" else None,
+                                      grid=row["Maidenhead Locator"]))
+
+        return new_data

sigrefdataproviders/pota.py

@@ -0,0 +1,29 @@
+import csv
+
+from data.sig_ref import SIGRef
+from sigrefdataproviders.file_download_sig_ref_data_provider import FileDownloadSIGRefDataProvider
+
+
+class POTA(FileDownloadSIGRefDataProvider):
+    """SIG ref data provider for Parks on the Air"""
+
+    POLL_INTERVAL_DAYS = 7
+    SIG = "POTA"
+    DATA_URL = "https://pota.app/all_parks_ext.csv"
+
+    def __init__(self, provider_config):
+        super().__init__(self.SIG, provider_config, self.DATA_URL, self.POLL_INTERVAL_DAYS)
+
+    def _http_response_to_data(self, http_response):
+        new_data = []
+        for row in csv.DictReader(http_response.content.decode("utf-8-sig").splitlines()):
+            ref_id = row["reference"]
+            new_data.append(SIGRef(sig=self.SIG, id=ref_id, name=row["name"] if "name" in row else None,
+                                      url="https://pota.app/#/park/" + ref_id,
+                                      grid=row["grid"] if "grid" in row else None,
+                                      latitude=float(row["latitude"]) if "latitude" in row and row[
+                                          "latitude"] != "" else None,
+                                      longitude=float(row["longitude"]) if "longitude" in row and row[
+                                          "longitude"] != "" else None))
+
+        return new_data

sigrefdataproviders/sig_ref_data_provider.py

@@ -1,19 +1,23 @@
+import logging
 from datetime import datetime
 
 import pytz
 
+from core.data_store import DATA_STORE
+
 
 class SIGRefDataProvider:
     """Generic SIG reference data provider class. Subclasses of this query the individual URLs or files for data."""
 
-    def __init__(self, name, provider_config):
+    def __init__(self, sig_name, provider_config):
         """Constructor"""
 
-        self.name = name
+        self.sig_name = sig_name
         self.enabled = provider_config["enabled"]
         self.last_update_time = datetime.min.replace(tzinfo=pytz.UTC)
         self.last_spot_time = datetime.min.replace(tzinfo=pytz.UTC)
         self.status = "Not Started" if self.enabled else "Disabled"
+        self.reference_count = 0
 
 
     def start(self):
@@ -26,3 +30,11 @@ class SIGRefDataProvider:
         """Stop any threads and prepare for application shutdown"""
 
         raise NotImplementedError("Subclasses must implement this method")
+
+    def _add_data(self, new_data):
+        """Add all the provided reference data objects to the data store."""
+
+        for d in new_data:
+            DATA_STORE.sigrefs[self.sig_name + ":" + d.id] = d
+        self.reference_count = len(new_data)
+        logging.info(f"Loaded %d references for %s into the data store.", self.reference_count, self.sig_name)

sigrefdataproviders/siota.py

@@ -0,0 +1,26 @@
+import csv
+
+from data.sig_ref import SIGRef
+from sigrefdataproviders.file_download_sig_ref_data_provider import FileDownloadSIGRefDataProvider
+
+
+class SIOTA(FileDownloadSIGRefDataProvider):
+    """SIG ref data provider for Silos on the Air"""
+
+    POLL_INTERVAL_DAYS = 30
+    SIG = "SIOTA"
+    DATA_URL = "https://www.silosontheair.com/data/silos.csv"
+
+    def __init__(self, provider_config):
+        super().__init__(self.SIG, provider_config, self.DATA_URL, self.POLL_INTERVAL_DAYS)
+
+    def _http_response_to_data(self, http_response):
+        new_data = []
+        for row in csv.DictReader(http_response.content.decode("utf-8-sig").splitlines()):
+            ref_id = row["SILO_CODE"]
+            new_data.append(SIGRef(sig=self.SIG, id=ref_id, name=row["NAME"] if "NAME" in row else None,
+                                      grid=row["LOCATOR"] if "LOCATOR" in row else None,
+                                      latitude=float(row["LAT"]) if "LAT" in row else None,
+                                      longitude=float(row["LNG"]) if "LNG" in row else None))
+
+        return new_data

sigrefdataproviders/sota.py

@@ -0,0 +1,34 @@
+import csv
+
+from pyhamtools.locator import latlong_to_locator
+
+from data.sig_ref import SIGRef
+from sigrefdataproviders.file_download_sig_ref_data_provider import FileDownloadSIGRefDataProvider
+
+
+class SOTA(FileDownloadSIGRefDataProvider):
+    """SIG ref data provider for Summits on the Air"""
+
+    POLL_INTERVAL_DAYS = 30
+    SIG = "SOTA"
+    DATA_URL = "https://storage.sota.org.uk/summitslist.csv"
+
+    def __init__(self, provider_config):
+        super().__init__(self.SIG, provider_config, self.DATA_URL, self.POLL_INTERVAL_DAYS)
+
+    def _http_response_to_data(self, http_response):
+        new_data = []
+        for row in csv.DictReader(http_response.content.decode("utf-8-sig").splitlines()[1:]):
+            ref_id = row["SummitCode"]
+            latitude = float(row["Latitude"]) if "Latitude" in row and row["Latitude"] != "" else None
+            longitude = float(row["Longitude"]) if "Longitude" in row and row["Longitude"] != "" else None
+            ref = SIGRef(sig=self.SIG, id=ref_id, name=row["SummitName"] if "SummitName" in row else None,
+                                      url="https://www.sotadata.org.uk/en/summit/" + ref_id,
+                                      latitude=latitude,
+                                      longitude=longitude,
+                                      activation_score=int(row["Points"]) if "Points" in row else None)
+            if latitude and longitude:
+                ref.grid = latlong_to_locator(latitude, longitude, 6)
+            new_data.append(ref)
+
+        return new_data

sigrefdataproviders/toilets.py

@@ -0,0 +1,24 @@
+import csv
+
+from data.sig_ref import SIGRef
+from sigrefdataproviders.local_file_sig_ref_data_provider import LocalFileSIGRefDataProvider
+
+
+class Toilets(LocalFileSIGRefDataProvider):
+    """SIG ref data provider for Toilets on the Air"""
+
+    SIG = "Toilets"
+    PATH = "datafiles/toilets.csv"
+
+    def __init__(self, provider_config):
+        super().__init__(self.SIG, provider_config, self.PATH)
+
+    def _file_to_data(self, path):
+        new_data = []
+        f = open(path)
+        csv_data = f.read()
+        dr = csv.DictReader(csv_data.splitlines())
+        for row in dr:
+            new_data.append(SIGRef(sig=self.SIG, id=row["ref"], name=row["ref"], latitude=float(row["lat"]),
+                                          longitude=float(row["lon"])))
+        return new_data

sigrefdataproviders/towers.py

@@ -0,0 +1,27 @@
+import csv
+
+from data.sig_ref import SIGRef
+from sigrefdataproviders.file_download_sig_ref_data_provider import FileDownloadSIGRefDataProvider
+
+
+class Towers(FileDownloadSIGRefDataProvider):
+    """SIG ref data provider for Towers on the Air"""
+
+    POLL_INTERVAL_DAYS = 30
+    SIG = "Towers"
+    DATA_URL = "https://wwtota.com/servis/generate_csv.php?ref=&filter=all"
+
+    def __init__(self, provider_config):
+        super().__init__(self.SIG, provider_config, self.DATA_URL, self.POLL_INTERVAL_DAYS)
+
+    def _http_response_to_data(self, http_response):
+        new_data = []
+        for row in csv.DictReader(http_response.content.decode("utf-8-sig").splitlines(), delimiter=";"):
+            ref_id = row["Ref"]
+            new_data.append(SIGRef(sig=self.SIG, id=ref_id, name=row["Nazev"] if "Nazev" in row else None,
+                                      url="https://wwtota.com/seznam/karta_rozhledny.php?ref=" + ref_id,
+                                      grid=row["Lokator"] if "Lokator" in row and row["Lokator"] != "" else None,
+                                      latitude=float(row["Lat"]) if "Lat" in row and row["Lat"] != "" else None,
+                                      longitude=float(row["Lon"]) if "Lon" in row and row["Lon"] != "" else None))
+
+        return new_data

sigrefdataproviders/wca.py

@@ -0,0 +1,44 @@
+import csv
+import logging
+
+from pyhamtools.locator import latlong_to_locator
+
+from data.sig_ref import SIGRef
+from sigrefdataproviders.file_download_sig_ref_data_provider import FileDownloadSIGRefDataProvider
+
+
+class WCA(FileDownloadSIGRefDataProvider):
+    """SIG ref data provider for World Castles Award"""
+
+    POLL_INTERVAL_DAYS = 30
+    SIG = "WCA"
+    DATA_URL = "https://polo.ham2k.com/data/activities/wca/all-castles.csv"
+
+    def __init__(self, provider_config):
+        super().__init__(self.SIG, provider_config, self.DATA_URL, self.POLL_INTERVAL_DAYS)
+
+    def _http_response_to_data(self, http_response):
+        new_data = []
+        for row in csv.DictReader(http_response.content.decode("utf-8-sig").splitlines()):
+            ref_id = row["REF"]
+
+            coordsStr = row["COORDINATES"]
+            latitude = None
+            longitude = None
+            grid = None
+            try:
+                if coordsStr:
+                    split = coordsStr.split(", ")
+                    latitude = float(split[0])
+                    longitude = float(split[1])
+                    grid = latlong_to_locator(latitude, longitude)
+            except ValueError:
+                logging.debug(f"Encountered dodgy formatting in WCA CSV, skipping location data for %s", ref_id)
+
+            new_data.append(SIGRef(sig=self.SIG, id=ref_id, name=row["CLEAN NAME"] if "CLEAN NAME" in row else None,
+                                      url="https://www.cqgma.org/zinfo.php?ref=" + ref_id,
+                                      latitude=latitude,
+                                      longitude=longitude,
+                                      grid=grid))
+
+        return new_data

sigrefdataproviders/wota.py

@@ -0,0 +1,31 @@
+from data.sig_ref import SIGRef
+from sigrefdataproviders.file_download_sig_ref_data_provider import FileDownloadSIGRefDataProvider
+
+
+class WOTA(FileDownloadSIGRefDataProvider):
+    """SIG ref data provider for Wainwrights on the Air"""
+
+    POLL_INTERVAL_DAYS = 365
+    SIG = "WOTA"
+    DATA_URL = "https://www.wota.org.uk/mapping/data/summits.json"
+
+    def __init__(self, provider_config):
+        super().__init__(self.SIG, provider_config, self.DATA_URL, self.POLL_INTERVAL_DAYS)
+
+    def _http_response_to_data(self, http_response):
+        new_data = []
+        for feature in http_response.json().get("features", []):
+            ref_id = feature["properties"]["wotaId"]
+            # Fudge WOTA URLs. Outlying fell (LDO) URLs don't match their ID numbers but require 214 to be
+            # added to them
+            url = "https://www.wota.org.uk/MM_" + ref_id
+            if ref_id.upper().startswith("LDO-"):
+                number = int(ref_id.upper().replace("LDO-", ""))
+                url = "https://www.wota.org.uk/MM_LDO-" + str(number + 214)
+
+            new_data.append(SIGRef(sig=self.SIG, id=ref_id, name=feature["properties"]["title"], url=url,
+                                      grid=feature["properties"]["qthLocator"],
+                                      latitude=feature["geometry"]["coordinates"][1],
+                                      longitude=feature["geometry"]["coordinates"][0]))
+
+        return new_data

sigrefdataproviders/wwbota.py

@@ -0,0 +1,27 @@
+import csv
+
+from data.sig_ref import SIGRef
+from sigrefdataproviders.file_download_sig_ref_data_provider import FileDownloadSIGRefDataProvider
+
+
+class WWBOTA(FileDownloadSIGRefDataProvider):
+    """SIG ref data provider for Worldwide Bunkers on the Air"""
+
+    POLL_INTERVAL_DAYS = 30
+    SIG = "WWBOTA"
+    DATA_URL = "https://api.wwbota.org/bunkers/?format=CSV"
+
+    def __init__(self, provider_config):
+        super().__init__(self.SIG, provider_config, self.DATA_URL, self.POLL_INTERVAL_DAYS)
+
+    def _http_response_to_data(self, http_response):
+        new_data = []
+        for row in csv.DictReader(http_response.content.decode("utf-8-sig").splitlines()):
+            ref_id = row["Reference"]
+            new_data.append(SIGRef(sig=self.SIG, id=ref_id, name=row["Name"] if "Name" in row else None,
+                                      url="https://bunkerwiki.org/?s=" + ref_id if ref_id.startswith("B/G") else None,
+                                      grid=row["Locator"] if "Locator" in row and row["Locator"] != "" else None,
+                                      latitude=float(row["Lat"]) if "Lat" in row and row["Lat"] != "" else None,
+                                      longitude=float(row["Long"]) if "Long" in row and row["Long"] != "" else None))
+
+        return new_data

sigrefdataproviders/wwff.py

@@ -0,0 +1,30 @@
+import csv
+
+from data.sig_ref import SIGRef
+from sigrefdataproviders.file_download_sig_ref_data_provider import FileDownloadSIGRefDataProvider
+
+
+class WWFF(FileDownloadSIGRefDataProvider):
+    """SIG ref data provider for Worldwide Flora & Fauna"""
+
+    POLL_INTERVAL_DAYS = 30
+    SIG = "WWFF"
+    DATA_URL = "https://wwff.co/wwff-data/wwff_directory.csv"
+
+    def __init__(self, provider_config):
+        super().__init__(self.SIG, provider_config, self.DATA_URL, self.POLL_INTERVAL_DAYS)
+
+    def _http_response_to_data(self, http_response):
+        new_data = []
+        for row in csv.DictReader(http_response.content.decode("utf-8-sig").splitlines()):
+            ref_id = row["reference"]
+            new_data.append(SIGRef(sig=self.SIG, id=ref_id, name=row["name"] if "name" in row else None,
+                                      url="https://wwff.co/directory/?showRef=" + ref_id,
+                                      grid=row["iaruLocator"] if "iaruLocator" in row and row[
+                                          "iaruLocator"] != "-" else None,
+                                      latitude=float(row["latitude"]) if "latitude" in row and row[
+                                          "latitude"] != "" and row["latitude"] != "-" else None,
+                                      longitude=float(row["longitude"]) if "longitude" in row and row[
+                                          "longitude"] != "" and row["longitude"] != "-" else None))
+
+        return new_data

sigrefdataproviders/zlota.py

@@ -0,0 +1,34 @@
+from pyhamtools.locator import latlong_to_locator
+
+from data.sig_ref import SIGRef
+from sigrefdataproviders.file_download_sig_ref_data_provider import FileDownloadSIGRefDataProvider
+
+
+class ZLOTA(FileDownloadSIGRefDataProvider):
+    """SIG ref data provider for New Zealand on the Air"""
+
+    POLL_INTERVAL_DAYS = 30
+    SIG = "ZLOTA"
+    DATA_URL = "https://ontheair.nz/assets/assets.json"
+
+    def __init__(self, provider_config):
+        super().__init__(self.SIG, provider_config, self.DATA_URL, self.POLL_INTERVAL_DAYS)
+
+    def _http_response_to_data(self, http_response):
+        new_data = []
+        data = http_response.json()
+        if isinstance(data, list):
+            for ref in data:
+                ref_id = ref["code"]
+                latitude = ref["y"]
+                longitude = ref["x"]
+
+                ref = SIGRef(sig=self.SIG, id=ref_id, name=ref["name"],
+                                          url="https://ontheair.nz/assets/" + ref_id.replace("/", "_"),
+                                          latitude=latitude,
+                                          longitude=longitude)
+                if latitude and longitude:
+                    ref.grid = latlong_to_locator(latitude, longitude, 6)
+                new_data.append(ref)
+
+        return new_data

spothole.py

@@ -1,11 +1,11 @@
 # Main script
-import importlib
 import logging
 import os
 import signal
 import sys
 
-from core.config import config, SERVER_OWNER_CALLSIGN, LOG_LEVEL
+from core.config import config, SERVER_OWNER_CALLSIGN, LOG_LEVEL, get_sig_ref_data_provider_from_config, \
+    get_spot_provider_from_config, get_alert_provider_from_config, get_solar_conditions_provider_from_config
 from core.constants import SOFTWARE_VERSION
 from core.data_store import DATA_STORE
 from core.lookup_helper import lookup_helper
@@ -17,6 +17,7 @@ web_server = None
 spot_providers = []
 alert_providers = []
 solar_condition_providers = []
+sig_ref_data_providers = []
 cleanup_timer = None
 run = True
 
@@ -38,34 +39,13 @@ def shutdown(_signum=None, _frame=None):
     for scp in solar_condition_providers:
         if scp.enabled:
             scp.stop()
+    for srdp in sig_ref_data_providers:
+        if srdp.enabled:
+            srdp.stop()
     DATA_STORE.close()
     os._exit(0)
 
 
-def get_spot_provider_from_config(config_providers_entry):
-    """Utility method to get a spot provider based on the class specified in its config entry."""
-
-    module = importlib.import_module('spotproviders.' + config_providers_entry["class"].lower())
-    provider_class = getattr(module, config_providers_entry["class"])
-    return provider_class(config_providers_entry)
-
-
-def get_alert_provider_from_config(config_providers_entry):
-    """Utility method to get an alert provider based on the class specified in its config entry."""
-
-    module = importlib.import_module('alertproviders.' + config_providers_entry["class"].lower())
-    provider_class = getattr(module, config_providers_entry["class"])
-    return provider_class(config_providers_entry)
-
-
-def get_solar_conditions_provider_from_config(config_providers_entry):
-    """Utility method to get a solar conditions provider based on the class specified in its config entry."""
-
-    module = importlib.import_module('solarconditionsproviders.' + config_providers_entry["class"].lower())
-    provider_class = getattr(module, config_providers_entry["class"])
-    return provider_class(config_providers_entry)
-
-
 # Main function
 if __name__ == '__main__':
     # Set up logging
@@ -85,6 +65,9 @@ if __name__ == '__main__':
     # Shut down gracefully on SIGINT
     signal.signal(signal.SIGINT, shutdown)
 
+    # Set up data store
+    DATA_STORE.setup()
+
     # Set up lookup helper
     lookup_helper.start()
 
@@ -112,9 +95,17 @@ if __name__ == '__main__':
         if p.enabled:
             p.start()
 
+    # Fetch, set up and start SIG reference data providers
+    for entry in config.get("sig-ref-data-providers", []):
+        sig_ref_data_providers.append(get_sig_ref_data_provider_from_config(entry))
+    for p in sig_ref_data_providers:
+        if p.enabled:
+            p.start()
+
     # Set up status reporter
     status_reporter = StatusReporter(web_server=web_server, spot_providers=spot_providers,
                                      alert_providers=alert_providers,
+                                     sig_ref_data_providers=sig_ref_data_providers,
                                      solar_condition_providers=solar_condition_providers, run_interval=5)
     status_reporter.start()
 

spotproviders/http_spot_provider.py

@@ -64,7 +64,7 @@ class HTTPSpotProvider(SpotProvider):
             logging.warning(f"Timeout when accessing {self.name} spots API.")
         except Exception:
             self.status = "Error"
-            logging.exception("Exception in HTTP JSON Spot Provider (" + self.name + ")")
+            logging.exception("Exception in HTTP Spot Provider (" + self.name + ")")
             self._stop_event.wait(timeout=1)
 
     def _http_response_to_spots(self, http_response):

spotproviders/sota.py

@@ -19,8 +19,6 @@ class SOTA(HTTPSpotProvider):
     # The actual data lookup all happens after parsing and checking the epoch.
     EPOCH_URL = "https://api-db2.sota.org.uk/api/spots/epoch"
     SPOTS_URL = "https://api-db2.sota.org.uk/api/spots/60/all/all"
-    # SOTA spots don't contain lat/lon, we need a separate lookup for that
-    SUMMIT_URL_ROOT = "https://api-db2.sota.org.uk/api/summits/"
 
     def __init__(self, provider_config):
         super().__init__("SOTA", provider_config, self.EPOCH_URL, self.POLL_INTERVAL_SEC)

spotproviders/towers.py

@@ -30,8 +30,8 @@ class Towers(HTTPSpotProvider):
                         dx_call=source_spot["call"].upper(),
                         freq=likely_freq,
                         comment=source_spot["comment"],
-                        sig="WWTOTA",
-                        sig_refs=[SIGRef(id=source_spot["ref"], sig="WWTOTA")],
+                        sig="Towers",
+                        sig_refs=[SIGRef(id=source_spot["ref"], sig="Towers")],
                         time=datetime.strptime(response_json["updated"][:10] + source_spot["time"],
                                                "%Y-%m-%d%H:%M").timestamp())
 

spotproviders/wota.py

@@ -25,7 +25,7 @@ class WOTA(HTTPSpotProvider):
 
     def _http_response_to_spots(self, http_response):
         new_spots = []
-        rss = cast(RSS, Parser.parse(http_response.content.decode()))
+        rss = cast(RSS, Parser.parse(http_response.content.decode("utf-8-sig")))
         # Iterate through source data
         for source_spot in rss.channel.items:
 

spotproviders/xota.py

@@ -1,6 +1,4 @@
-import csv
 import json
-import logging
 from datetime import datetime
 
 import pytz
@@ -12,10 +10,11 @@ from spotproviders.websocket_spot_provider import WebsocketSpotProvider
 
 class XOTA(WebsocketSpotProvider):
     """Spot provider for servers based on the "xOTA" software at https://github.com/nischu/xOTA/
-    The provider typically doesn't give us a lat/lon or SIG explicitly, so our own config provides a SIG and a reference
-    to a local CSV file with location information. This functionality is implemented for TOTA events, of which there are
-    several - so a plain lookup of a "TOTA reference" doesn't make sense, it depends on which TOTA and hence which server
-    supplied the data, which is why the CSV location lookup is here and not in sig_utils."""
+    The provider typically doesn't give us a lat/lon or SIG explicitly, so our own config provides a SIG which we can
+    then use for lookups. This functionality is implemented for Toilets on the Air events, of which there are
+    several - so a plain lookup of a "TOTA reference" doesn't make sense, it depends on which TOTA, which is why we also
+    provide a sig_ref_prefix in our config. This is applied to the reference ID, so e.g. "T-01" at C3 might become
+    "C3 T-01". This allows us to provide location lookups for TOTA at several conferences."""
 
     LOCATION_DATA = {}
     SIG = None
@@ -23,26 +22,13 @@ class XOTA(WebsocketSpotProvider):
     def __init__(self, provider_config):
         name = provider_config["name"] if "name" in provider_config else "xOTA"
         super().__init__(name, provider_config, provider_config["url"])
-        locations_csv = str(provider_config["locations-csv"]) if "locations-csv" in provider_config else None
         self.SIG = str(provider_config["sig"]) if "sig" in provider_config else None
-
-        # Load location data
-        if locations_csv:
-            try:
-                f = open(locations_csv)
-                csv_data = f.read()
-                dr = csv.DictReader(csv_data.splitlines())
-                for row in dr:
-                    self.LOCATION_DATA[row["ref"]] = {"lat": row["lat"], "lon": row["lon"]}
-            except:
-                logging.exception("Could not look up location data for XOTA source.")
+        self._sig_ref_prefix = str(provider_config["sig-ref-prefix"]) if "sig-ref-prefix" in provider_config else ""
 
     def _ws_message_to_spot(self, b):
         string = b.decode("utf-8")
         source_spot = json.loads(string)
-        ref_id = source_spot["reference"]["title"]
-        lat = float(self.LOCATION_DATA[ref_id]["lat"]) if ref_id in self.LOCATION_DATA else None
-        lon = float(self.LOCATION_DATA[ref_id]["lon"]) if ref_id in self.LOCATION_DATA else None
+        ref_id = self._sig_ref_prefix + " " + source_spot["reference"]["title"]
         spot = Spot(source=self.name,
                     source_id=source_spot["id"],
                     dx_call=source_spot["stationCallSign"].upper(),
@@ -50,10 +36,7 @@ class XOTA(WebsocketSpotProvider):
                     mode=source_spot["mode"].upper(),
                     sig=self.SIG,
                     sig_refs=[
-                        SIGRef(id=ref_id, sig=self.SIG or "", url=source_spot["reference"]["website"], latitude=lat,
-                               longitude=lon)],
+                        SIGRef(id=ref_id, sig=self.SIG or "", url=source_spot["reference"]["website"])],
                     time=datetime.now(pytz.UTC).timestamp(),
-                    dx_latitude=lat,
-                    dx_longitude=lon,
                     qrt=source_spot["state"] != "active")
         return spot

static/apidocs/openapi.yml

@@ -23,6 +23,7 @@ info:
     * Added `comment_names` to SIGs in the `/options`, to reflect how they might be referred to in spot comments where
       it differs from their `name`.
     * Added `propagation_mode` field to spots
+    * Added `sig_ref_data_providers` to status and removed `cleanup`
 
     ### 1.3
 
@@ -795,7 +796,7 @@ components:
         - HEMA
         - WCA
         - MOTA
-        - SiOTA
+        - SIOTA
         - ARLHS
         - ILLW
         - ZLOTA
@@ -1720,6 +1721,32 @@ components:
             is zero, the provider has never updated.
           example: 1759579508
 
+    SIGRefDataProviderStatus:
+      type: object
+      properties:
+        sig_name:
+          type: string
+          description: The name of the SIG.
+          example: WWFF
+        enabled:
+          type: boolean
+          description: Whether the provider is enabled or not.
+          example: true
+        status:
+          type: string
+          description: The status of the provider.
+          example: OK
+        last_updated:
+          type: number
+          description: >
+            The last time at which this provider received data, UTC seconds since UNIX epoch. If this
+            is zero, the provider has never updated.
+          example: 1759579508
+        reference_count:
+          type: number
+          description: The number of references fetched using this provider.
+          example: 1234
+
     SpotList:
       type: array
       items:
@@ -1787,17 +1814,6 @@ components:
           type: integer
           description: Number of alerts currently in the system.
           example: 123
-        "cleanup":
-          type: object
-          properties:
-            status:
-              type: string
-              description: The status of the cleanup thread
-              example: OK
-            last_ran:
-              type: number
-              description: The last time the cleanup operation ran, UTC seconds since UNIX epoch.
-              example: 1759579508
         "webserver":
           type: object
           properties:
@@ -1828,6 +1844,11 @@ components:
           description: An array of all the solar conditions providers.
           items:
             $ref: '#/components/schemas/SolarConditionsProviderStatus'
+        sig_ref_data_providers:
+          type: array
+          description: An array of all the SIG reference data providers.
+          items:
+            $ref: '#/components/schemas/SIGRefDataProviderStatus'
 
     Options:
       type: object

static/js/status.js

@@ -12,9 +12,6 @@ function loadStatus() {
         $("#web-server-last-api").text(moment.unix(jsonData["webserver"]["last_api_access"]).utc().fromNow());
         $("#web-server-last-page").text(moment.unix(jsonData["webserver"]["last_page_access"]).utc().fromNow());
 
-        $("#cleanup-status").text(jsonData["cleanup"]["status"]);
-        $("#cleanup-last-ran").text(moment.unix(jsonData["cleanup"]["last_ran"]).utc().fromNow());
-
         jsonData["spot_providers"].forEach(p => {
             $("#spot-providers-status-container").append(`
                 <div class="row row-cols-1 row-cols-md-4 g-4 mb-2">
@@ -42,6 +39,16 @@ function loadStatus() {
                     <div class="col">Last updated: ${(p["enabled"] && p["last_updated"] > 0) ? moment.unix(p["last_updated"]).utc().fromNow() : "N/A"}</div>
                 </div>`);
         });
+
+        jsonData["sig_ref_data_providers"].forEach(p => {
+            $("#sig-ref-data-providers-status-container").append(`
+                <div class="row row-cols-1 row-cols-md-4 g-4 mb-2">
+                    <div class="col"><strong>${p["sig_name"]}</strong></div>
+                    <div class="col">Status: ${p["status"]}</div>
+                    <div class="col">Last updated: ${(p["enabled"] && p["last_updated"] > 0) ? moment.unix(p["last_updated"]).utc().fromNow() : "N/A"}</div>
+                    <div class="col">References: ${(p["enabled"] && p["reference_count"] > 0) ? p["reference_count"] : "N/A"}</div>
+                </div>`);
+        });
     });
 }
 

templates/status.html

@@ -24,11 +24,6 @@
             <div class="col">Last API call: <span id="web-server-last-api"></span></div>
             <div class="col">Last page req: <span id="web-server-last-page"></span></div>
         </div>
-        <div class="row row-cols-1 row-cols-md-4 g-4 mb-2">
-            <div class="col"><strong>Cleanup Service</strong></div>
-            <div class="col">Status: <span id="cleanup-status"></span></div>
-            <div class="col">Last ran: <span id="cleanup-last-ran"></span></div>
-        </div>
     </div>
 </div>
 
@@ -59,6 +54,15 @@
     </div>
 </div>
 
+<div class="card mt-3">
+    <div class="card-header">
+        SIG Reference Data Providers
+    </div>
+    <div class="card-body" id="sig-ref-data-providers-status-container">
+
+    </div>
+</div>
+
 <script src="/static/js/status.js?v=1785434213"></script>
 <script>
     $(document).ready(function () {