feat: create small component for data.coordinates

Author: gsiri-code

data/cities.py

@@ -4,6 +4,7 @@
 """
 
 import data.db_connect as dbc
+from data.coordinates import Coordinates
 from data.utils import sanitize_string, sanitize_code
 from datetime import UTC, datetime
 from data.cache import city_by_name_state_cache
@@ -35,6 +36,10 @@
 }
 
 
+def _validate_coordinates(coordinates: dict) -> dict:
+    return Coordinates.from_dict(coordinates).to_dict()
+
+
 def get_cities() -> list:
     """
     Returns a list of all cities
@@ -154,6 +159,8 @@ def add_city(city_data: dict) -> bool:
         city_data[STATE_CODE] = sanitize_code(city_data[STATE_CODE])
     if COUNTRY_CODE in city_data:
         city_data[COUNTRY_CODE] = sanitize_code(city_data[COUNTRY_CODE])
+    if COORDINATES in city_data:
+        city_data[COORDINATES] = _validate_coordinates(city_data[COORDINATES])
 
     # Validate that state_code exists if provided
     if STATE_CODE in city_data and city_data[STATE_CODE]:
@@ -221,6 +228,8 @@ def update_city(name: str, state_code: str, update_data: dict) -> bool:
     # Sanitize string fields in update
     if COUNTRY_CODE in update_data:
         update_data[COUNTRY_CODE] = sanitize_code(update_data[COUNTRY_CODE])
+    if COORDINATES in update_data:
+        update_data[COORDINATES] = _validate_coordinates(update_data[COORDINATES])
 
     # Prevent updating the name or state_code fields directly
     if CITY_NAME in update_data:
@@ -255,6 +264,8 @@ def update_city_by_name_and_country(
     # Sanitize string fields in update
     if STATE_CODE in update_data:
         update_data[STATE_CODE] = sanitize_code(update_data[STATE_CODE])
+    if COORDINATES in update_data:
+        update_data[COORDINATES] = _validate_coordinates(update_data[COORDINATES])
 
     # Prevent updating the name or country_code fields directly
     if CITY_NAME in update_data:

data/coordinates.py

@@ -0,0 +1,85 @@
+"""
+Validated coordinate field types for city data.
+"""
+
+from abc import ABC, abstractmethod
+
+LATITUDE = "latitude"
+LONGITUDE = "longitude"
+
+MIN_LATITUDE = -90
+MAX_LATITUDE = 90
+MIN_LONGITUDE = -180
+MAX_LONGITUDE = 180
+
+
+class Coordinate(ABC):
+    def __init__(self, value: int | float):
+        numeric_value = self._validate_type(value)
+        lower_bound, upper_bound = self.bounds()
+        if numeric_value < lower_bound or numeric_value > upper_bound:
+            raise ValueError(
+                f"Bad value for {self.field_name()}: {numeric_value}. "
+                f"Expected between {lower_bound} and {upper_bound}"
+            )
+        self.value = numeric_value
+
+    @classmethod
+    @abstractmethod
+    def bounds(cls) -> tuple[float, float]:
+        """Return the inclusive coordinate bounds."""
+
+    @classmethod
+    def field_name(cls) -> str:
+        return cls.__name__.lower()
+
+    def _validate_type(self, value: int | float) -> float:
+        if isinstance(value, bool) or not isinstance(value, (int, float)):
+            raise TypeError(f"Bad type for value: {type(value)}")
+        return float(value)
+
+    def __float__(self) -> float:
+        return self.value
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+
+class Latitude(Coordinate):
+    @classmethod
+    def bounds(cls) -> tuple[float, float]:
+        return MIN_LATITUDE, MAX_LATITUDE
+
+
+class Longitude(Coordinate):
+    @classmethod
+    def bounds(cls) -> tuple[float, float]:
+        return MIN_LONGITUDE, MAX_LONGITUDE
+
+
+class Coordinates:
+    def __init__(
+        self,
+        latitude: int | float | Latitude,
+        longitude: int | float | Longitude,
+    ):
+        self.latitude = latitude if isinstance(latitude, Latitude) else Latitude(latitude)
+        self.longitude = (
+            longitude if isinstance(longitude, Longitude) else Longitude(longitude)
+        )
+
+    @classmethod
+    def from_dict(cls, coordinates: dict) -> "Coordinates":
+        if not isinstance(coordinates, dict):
+            raise TypeError(f"Bad type for coordinates: {type(coordinates)}")
+        if LATITUDE not in coordinates:
+            raise ValueError("Missing latitude in coordinates")
+        if LONGITUDE not in coordinates:
+            raise ValueError("Missing longitude in coordinates")
+        return cls(coordinates[LATITUDE], coordinates[LONGITUDE])
+
+    def to_dict(self) -> dict:
+        return {
+            LATITUDE: float(self.latitude),
+            LONGITUDE: float(self.longitude),
+        }