Add formatting and type checks

karldns/services/ddns.py

@@ -8,6 +8,7 @@ import sqlite3
 import threading
 import time
 import urllib.parse
+from collections.abc import Mapping
 from dataclasses import dataclass
 
 from fastapi import HTTPException, Request
@@ -18,6 +19,7 @@ from ..models import UpdateResult
 from ..security import client_ip
 from ..settings import DdnsSettings
 from ..store import DdnsStore
+from ..store.types import AccountRow
 
 LOGGER = logging.getLogger(__name__)
 INITIAL_PLACEHOLDER_IPV4 = "192.0.2.1"
@@ -41,7 +43,7 @@ class DdnsService:
         self.store = store
         self._locks = [threading.Lock() for _ in range(self._LOCK_STRIPES)]
 
-    def create_managed_account(self) -> dict[str, str]:
+    def create_managed_account(self) -> AccountRow:
         if not self.settings.hostname_suffix:
             raise HTTPException(status_code=500, detail="DDNS_HOSTNAME_SUFFIX is required")
         for _ in range(5):
@@ -79,6 +81,8 @@ class DdnsService:
         source_ip = client_ip(request, self.settings)
         source_fallback = source_ip if _is_global_ip(source_ip) else ""
         supplied_ip = any(value and value.strip() for value in (myip, ipaddr, myipv6, ip6addr))
+        ipv4: str | None
+        ipv6: str | None
         if not supplied_ip and not source_fallback:
             ipv4 = INITIAL_PLACEHOLDER_IPV4
             ipv6 = None
@@ -108,7 +112,9 @@ class DdnsService:
                         planned.update_ipv6,
                         type(exc).__name__,
                     )
-                    self.store.log_update_event(hostname, ipv4, ipv6, DNS_RECONCILE_FAILED, f"{type(exc).__name__}: {exc}", source_ip)
+                    self.store.log_update_event(
+                        hostname, ipv4, ipv6, DNS_RECONCILE_FAILED, f"{type(exc).__name__}: {exc}", source_ip
+                    )
                     raise
                 except DnsProviderError as exc:
                     LOGGER.warning(
@@ -118,7 +124,9 @@ class DdnsService:
                         planned.update_ipv6,
                         type(exc).__name__,
                     )
-                    self.store.log_update_event(hostname, ipv4, ipv6, DNS_FAILED, f"{type(exc).__name__}: {exc}", source_ip)
+                    self.store.log_update_event(
+                        hostname, ipv4, ipv6, DNS_FAILED, f"{type(exc).__name__}: {exc}", source_ip
+                    )
                     raise
             result = self.store.commit_update_result(planned)
             self.store.log_update_event(hostname, result.ipv4, result.ipv6, UPDATED, detail, source_ip)
@@ -149,7 +157,9 @@ class DdnsService:
             )
             lock = self._lock_for(hostname)
             with lock:
-                planned = self.store.preview_update(hostname, ipv4, ipv6, update_ipv4=update_ipv4, update_ipv6=update_ipv6)
+                planned = self.store.preview_update(
+                    hostname, ipv4, ipv6, update_ipv4=update_ipv4, update_ipv6=update_ipv6
+                )
                 if planned.changed:
                     try:
                         publish_dns(planned, self.settings)
@@ -180,7 +190,9 @@ class DdnsService:
                             planned.update_ipv6,
                             type(exc).__name__,
                         )
-                        self.store.log_update_event(hostname, ipv4, ipv6, DNS_FAILED, f"{type(exc).__name__}: {exc}", source_ip)
+                        self.store.log_update_event(
+                            hostname, ipv4, ipv6, DNS_FAILED, f"{type(exc).__name__}: {exc}", source_ip
+                        )
                         raise
                     result = self.store.commit_update_result(planned)
                     is_success = True
@@ -203,19 +215,19 @@ class DdnsService:
                 is_bad_ip=is_bad_ip,
             )
 
-    def fritz_update_url(self, account: dict[str, str]) -> str:
+    def fritz_update_url(self, account: Mapping[str, object]) -> str:
         base = self.settings.public_base_url.rstrip("/")
-        slug = urllib.parse.quote(account["update_slug"])
+        slug = urllib.parse.quote(str(account["update_slug"]))
         return f"{base}/api/v1/router/update/{slug}?myip=<ipaddr>&myipv6=<ip6addr>"
 
-    def dashboard_url(self, account: dict[str, str]) -> str:
+    def dashboard_url(self, account: Mapping[str, object]) -> str:
         base = self.settings.public_base_url.rstrip("/")
-        slug = urllib.parse.quote(account["management_slug"])
+        slug = urllib.parse.quote(str(account["management_slug"]))
         return f"{base}/m/{slug}"
 
-    def registration_url(self, account: dict[str, str]) -> str:
+    def registration_url(self, account: Mapping[str, object]) -> str:
         base = self.settings.public_base_url.rstrip("/")
-        slug = urllib.parse.quote(account["management_slug"])
+        slug = urllib.parse.quote(str(account["management_slug"]))
         return f"{base}/api/v1/router/register/{slug}"
 
     def random_managed_hostname(self) -> str: