flynt pass to provide consistency to string formatters and concatenation

core/config.py

@@ -40,6 +40,6 @@ def create_provider_from_config(package, config_providers_entry):
     package to look for it in, as there are several types of provider. e.g. package "providers.spot", where the config
     entry is for a POTA spot provider."""
 
-    module = importlib.import_module(package + "." + config_providers_entry["class"].lower())
+    module = importlib.import_module(f"{package}.{config_providers_entry['class'].lower()}")
     provider_class = getattr(module, config_providers_entry["class"])
     return provider_class(config_providers_entry)

core/constants.py

@@ -6,8 +6,8 @@ from data.sig import SIG
 SOFTWARE_VERSION = "2.0-pre"
 
 # HTTP headers used for spot providers that use HTTP
-HTTP_HEADERS = {"User-Agent": "Spothole v" + SOFTWARE_VERSION + " (operated by " + SERVER_OWNER_CALLSIGN + ")"}
-HAMQTH_PRG = ("Spothole v" + SOFTWARE_VERSION + " operated by " + SERVER_OWNER_CALLSIGN).replace(" ", "_")
+HTTP_HEADERS = {"User-Agent": f"Spothole v{SOFTWARE_VERSION} (operated by {SERVER_OWNER_CALLSIGN})"}
+HAMQTH_PRG = f"Spothole v{SOFTWARE_VERSION} operated by {SERVER_OWNER_CALLSIGN}".replace(" ", "_")
 
 # Special Interest Groups
 SIGS = [

core/data_store.py

@@ -46,34 +46,34 @@ class DataStore:
 
         # 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")
+        self._solar = diskcache.Cache(f"{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")
+        self._status = diskcache.Cache(f"{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 cache for static reference and 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.dxcc_data = diskcache.Cache(CACHE_DIR + "dxcc_data")
+        self.dxcc_data = diskcache.Cache(f"{CACHE_DIR}dxcc_data")
         self.regenerate_call_regex_to_dxcc_entity_map()
 
         # For SIG reference data specifically, 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(CACHE_DIR + "sigrefs")
+        self.sigrefs = diskcache.Cache(f"{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.callsign_data_countryfiles = diskcache.Cache(CACHE_DIR + "callsign_data_countryfiles")
-        self.callsign_data_clublogxml = diskcache.Cache(CACHE_DIR + "callsign_data_clublogxml")
-        self.callsign_data_clublogapi = diskcache.Cache(CACHE_DIR + "callsign_data_clublogapi")
-        self.callsign_data_qrz = diskcache.Cache(CACHE_DIR + "callsign_data_qrz")
-        self.callsign_data_hamqth = diskcache.Cache(CACHE_DIR + "callsign_data_hamqth")
+        self.callsign_data_countryfiles = diskcache.Cache(f"{CACHE_DIR}callsign_data_countryfiles")
+        self.callsign_data_clublogxml = diskcache.Cache(f"{CACHE_DIR}callsign_data_clublogxml")
+        self.callsign_data_clublogapi = diskcache.Cache(f"{CACHE_DIR}callsign_data_clublogapi")
+        self.callsign_data_qrz = diskcache.Cache(f"{CACHE_DIR}callsign_data_qrz")
+        self.callsign_data_hamqth = diskcache.Cache(f"{CACHE_DIR}callsign_data_hamqth")
         unique_keys = set()
         for c in [self.callsign_data_countryfiles, self.callsign_data_clublogxml, self.callsign_data_clublogapi,
                   self.callsign_data_qrz, self.callsign_data_hamqth]:
@@ -84,12 +84,12 @@ class DataStore:
         # 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=CACHE_DIR + "spots",
+                                   snapshot_dir=f"{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=CACHE_DIR + "alerts",
+                                    snapshot_dir=f"{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()))
 

core/geo_utils.py

@@ -172,7 +172,7 @@ def wab_wai_square_to_lat_lon(ref):
     elif re.match(r"^W[AV][0-9]{2}$", ref):
         return utm_grid_square_to_lat_lon(ref)
     else:
-        logging.warning("Invalid WAB/WAI square: " + ref)
+        logging.warning(f"Invalid WAB/WAI square: {ref}")
         return None
 
 

core/sig_lookup_helper.py

@@ -68,14 +68,14 @@ def get_sig_ref_info(sig, ref_id):
             if not sig_ref.name:
                 sig_ref.name = sig_ref.id
             if sig_ref.name:
-                sig_ref.url = "https://www.beachesontheair.com/beaches/" + sig_ref.name.lower().replace(" ", "-")
+                sig_ref.url = f"https://www.beachesontheair.com/beaches/{sig_ref.name.lower().replace(' ', '-')}"
             return sig_ref
 
         ### ACTUAL LOOKUP ###
         #
         # OK, this is something we have to look up. Now check to see if our data store contains reference data and use
         # that.
-        key = sig + ":" + ref_id
+        key = f"{sig}:{ref_id}"
         lookup_data = DATA_STORE.sigrefs.get(key) if key in DATA_STORE.sigrefs else None
         if lookup_data:
             return lookup_data
@@ -86,7 +86,7 @@ def get_sig_ref_info(sig, ref_id):
             logging.debug("%s database did not contain data for ref %s", sig, ref_id)
 
     except Exception:
-        logging.exception("Exception when looking up sig_ref info for " + sig + " ref " + ref_id)
+        logging.exception(f"Exception when looking up sig_ref info for {sig} ref {ref_id}")
     return sig_ref
 
 

core/sig_utils.py

@@ -21,4 +21,4 @@ def get_sig_name_from_comment_name(sig):
 
 
 # Regex matching any SIG's "comment name", i.e. how it may be referred to in spot comments
-ANY_SIG_REGEX = r"(" + r"|".join(n for s in SIGS for n in s.comment_names) + r")"
+ANY_SIG_REGEX = rf"({'|'.join((n for s in SIGS for n in s.comment_names))})"

core/url_data_cache.py

@@ -17,7 +17,7 @@ class URLDataCache(CachedSession):
     _lock = threading.Lock()
 
     def __init__(self, name):
-        super().__init__(CACHE_DIR + "urls/" + name, expire_after=timedelta(days=1),
+        super().__init__(f"{CACHE_DIR}urls/{name}", expire_after=timedelta(days=1),
                          allowable_codes=(200, 400, 401, 403, 404))
 
     def get(self, *args, **kwargs):

core/utils.py

@@ -39,7 +39,7 @@ def infer_mode_type_from_mode(mode):
         return "DATA"
     else:
         if mode.upper() != "OTHER":
-            logging.warning("Found an unrecognised mode: " + mode + ". Developer should categorise this.")
+            logging.warning(f"Found an unrecognised mode: {mode}. Developer should categorise this.")
         return None