enhance structure

JulesL2 · JulesL2 · commit bacf7643daeb · 2025-02-13T18:50:48.000+01:00
diff --git a/pretty_gpx/rendering_modes/city/data/roads.py b/pretty_gpx/rendering_modes/city/data/roads.py
@@ -4,6 +4,7 @@
 from dataclasses import dataclass
 from enum import auto
 from enum import Enum
+from typing import Any
 
 from tqdm import tqdm
 
@@ -29,13 +30,46 @@ class CityRoadType(Enum):
     ACCESS_ROAD = auto()
 
 
+class RoadPrecisionLevel:
+    """City road precision level."""
+    def __init__(self, name: str, priority: int):
+        self.name = name
+        self.priority = priority
+
+    def __str__(self) -> str:
+        return self.name
+    
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, RoadPrecisionLevel):
+            return self.priority == other.priority
+        return False
+    
+    def __lt__(self, other: 'RoadPrecisionLevel') -> bool:
+        if isinstance(other, RoadPrecisionLevel):
+            return self.priority < other.priority
+        return NotImplemented
+
+
+class CityRoadPrecision(Enum):
+    """Enum defining different road precision levels."""
+    VERY_HIGH = RoadPrecisionLevel(name="Very-High", priority=3)
+    HIGH = RoadPrecisionLevel(name="High", priority=2)
+    MEDIUM = RoadPrecisionLevel(name="Medium", priority=1)
+    LOW = RoadPrecisionLevel(name="Low", priority=0)
+
+    @classmethod
+    def from_string(cls, precision_name: str) -> 'CityRoadPrecision':
+        """Convert a string representation to a CityRoadPrecision enum value."""
+        for precision in cls:
+            if precision.value.name.lower() == precision_name.lower():
+                return precision
+        raise ValueError(f"Invalid precision level: {precision_name}")
+    
+    @property
+    def priority(self) -> int:
+        """Get the priority value for the precision level."""
+        return self.value.priority
 
-ROAD_PRECISION_LEVEL = {
-    "Low":0,
-    "Medium":1,
-    "High":2,
-    "Very High": 3
-}
 
 @dataclass(frozen=True)
 class RoadTypeData:
@@ -57,16 +91,19 @@ class RoadTypeData:
                                              key=lambda road_type: ROAD_TYPE_DATA[road_type].priority)
 
 
-def get_city_roads_with_priority_better_than(x: int) -> list[CityRoadType]:
+def get_city_roads_with_priority_better_than(precision: CityRoadPrecision) -> list[CityRoadType]:
     """Returns a list of CityRoadType with a priority better than the given x."""
     # Filter ROAD_TYPE_DATA to get only those with priority less than x
-    return [road_type for road_type, data in ROAD_TYPE_DATA.items() if data.priority <= x]
-
+    return [
+            road_type 
+            for road_type, data in ROAD_TYPE_DATA.items() 
+            if data.priority <= precision.priority
+        ]
 
 @profile
 def prepare_download_city_roads(query: OverpassQuery,
                                 bounds: GpxBounds,
-                                road_precision: str) -> list[CityRoadType]:
+                                road_precision: CityRoadPrecision) -> list[CityRoadType]:
     """Download roads map from OpenStreetMap.
 
     Args:
@@ -79,10 +116,9 @@ def prepare_download_city_roads(query: OverpassQuery,
     """
     cache_pkl = ROADS_CACHE.get_path(bounds)
 
-    assert road_precision in ROAD_PRECISION_LEVEL.keys()
+    logger.debug(f"Road precision: {road_precision.name}")
 
-    logger.debug(f"Road precision : {road_precision}")
-    roads_to_plot: list[CityRoadType] = get_city_roads_with_priority_better_than(ROAD_PRECISION_LEVEL[road_precision])
+    roads_to_plot: list[CityRoadType] = get_city_roads_with_priority_better_than(road_precision)
 
     if os.path.isfile(cache_pkl):
         cityroads_cache: dict[CityRoadType, list[ListLonLat]] = read_pickle(file_path=cache_pkl)
@@ -112,9 +148,9 @@ def prepare_download_city_roads(query: OverpassQuery,
 def process_city_roads(query: OverpassQuery,
                        bounds: GpxBounds,
                        city_roads_downloaded: list[CityRoadType],
-                       road_precision: str) -> dict[CityRoadType,list[ListLonLat]]:
+                       road_precision: CityRoadPrecision) -> dict[CityRoadType,list[ListLonLat]]:
     """Query the overpass API to get the roads of a city."""
-    roads_to_plot: list[CityRoadType] = get_city_roads_with_priority_better_than(ROAD_PRECISION_LEVEL[road_precision])
+    roads_to_plot: list[CityRoadType] = get_city_roads_with_priority_better_than(road_precision)
 
     if len(city_roads_downloaded) > 0:
         # We need to process some downloaded road types.
diff --git a/pretty_gpx/rendering_modes/city/drawing/city_background.py b/pretty_gpx/rendering_modes/city/drawing/city_background.py
@@ -16,6 +16,7 @@
 from pretty_gpx.rendering_modes.city.data.forests import process_city_forests
 from pretty_gpx.rendering_modes.city.data.rivers import prepare_download_city_rivers
 from pretty_gpx.rendering_modes.city.data.rivers import process_city_rivers
+from pretty_gpx.rendering_modes.city.data.roads import CityRoadPrecision
 from pretty_gpx.rendering_modes.city.data.roads import CityRoadType
 from pretty_gpx.rendering_modes.city.data.roads import prepare_download_city_roads
 from pretty_gpx.rendering_modes.city.data.roads import process_city_roads
@@ -51,7 +52,7 @@ class CityBackground:
     @staticmethod
     @profile
     def from_union_bounds(union_bounds: GpxBounds,
-                          road_precision: str) -> 'CityBackground':
+                          road_precision: CityRoadPrecision) -> 'CityBackground':
         """Initialize the City Background from the Union Bounds."""
         total_query = OverpassQuery()
         roads_downloaded = prepare_download_city_roads(total_query, union_bounds, road_precision)
diff --git a/pretty_gpx/rendering_modes/city/drawing/city_params.py b/pretty_gpx/rendering_modes/city/drawing/city_params.py
@@ -12,6 +12,7 @@
 from pretty_gpx.common.drawing.utils.fonts import FontEnum
 from pretty_gpx.common.drawing.utils.plt_marker import MarkerType
 from pretty_gpx.common.drawing.utils.scatter_point import ScatterPointCategory
+from pretty_gpx.rendering_modes.city.data.roads import CityRoadPrecision
 from pretty_gpx.rendering_modes.city.data.roads import CityRoadType
 from pretty_gpx.rendering_modes.city.drawing.city_colors import CITY_COLOR_THEMES
 
@@ -48,7 +49,7 @@ class CityParams:
     user_title: str | None = None
     user_uphill_m: int | None = None
     user_dist_km: float | None = None
-    user_road_precision: str = "Medium"
+    user_road_precision: CityRoadPrecision = CityRoadPrecision.MEDIUM
 
     @staticmethod
     def default() -> "CityParams":
diff --git a/pretty_gpx/ui/pages/city/page.py b/pretty_gpx/ui/pages/city/page.py
@@ -3,11 +3,12 @@
 from dataclasses import dataclass
 
 from pretty_gpx.common.drawing.utils.scatter_point import ScatterPointCategory
+from pretty_gpx.rendering_modes.city.data.roads import CityRoadPrecision
 from pretty_gpx.rendering_modes.city.drawing.city_colors import CITY_COLOR_THEMES
 from pretty_gpx.rendering_modes.city.drawing.city_drawer import _update_city_background
 from pretty_gpx.rendering_modes.city.drawing.city_drawer import CityDrawer
 from pretty_gpx.rendering_modes.city.drawing.city_params import CityParams
-from pretty_gpx.ui.pages.template.ui_input import UiDropdownStr
+from pretty_gpx.ui.pages.template.ui_input import UiDropdownGeneric
 from pretty_gpx.ui.pages.template.ui_input import UiInputInt
 from pretty_gpx.ui.pages.template.ui_manager import UiManager
 from pretty_gpx.ui.utils.run import run_cpu_bound
@@ -22,7 +23,7 @@ def city_page() -> None:
 class CityUiManager(UiManager[CityDrawer]):
     """City Ui Manager."""
     uphill: UiInputInt
-    road_precision: UiDropdownStr
+    road_precision: UiDropdownGeneric
 
     def __init__(self) -> None:
         drawer = CityDrawer(params=CityParams.default(), top_ratio=0.18, bot_ratio=0.22, margin_ratio=0.1)
@@ -34,11 +35,12 @@ def __init__(self) -> None:
             self.uphill = UiInputInt.create(label='D+ (m)', value="", on_enter=self.on_click_update,
                                             tooltip="Press Enter to override elevation from GPX")
 
-            self.road_precision = UiDropdownStr.create(label='Road precision',
-                                                       discrete_val=["Low", "Medium", "High", "Very High"],
-                                                       default_idx=1,
-                                                       on_change=self.background_update,
-                                                       tooltip="Change the roads level of details")
+            precision_dropdown_values = {precision: precision.name for precision in CityRoadPrecision}
+            self.road_precision = UiDropdownGeneric.create(label='Road precision',
+                                                           discrete_val=precision_dropdown_values,
+                                                           default_val=CityRoadPrecision.MEDIUM,
+                                                           on_change=self.background_update,
+                                                           tooltip="Change the roads level of details")
 
 
     @staticmethod
diff --git a/pretty_gpx/ui/pages/template/ui_input.py b/pretty_gpx/ui/pages/template/ui_input.py
@@ -3,13 +3,21 @@
 from collections.abc import Awaitable
 from collections.abc import Callable
 from dataclasses import dataclass
+from typing import Any
 from typing import Self
 
 from nicegui import ui
+from typing_extensions import TypedDict
 
 from pretty_gpx.common.utils.utils import safe
 
 
+class DiscreteValue(TypedDict):
+    """Structured representation of discrete values for dropdowns."""
+    name: str
+    priority: Any
+
+
 @dataclass
 class UiInput:
     """NiceGUI Input Wrapper."""
@@ -43,14 +51,19 @@ class UiDropdown:
     def create(cls,
                *,
                label: str,
-               discrete_val: list[str],
-               default_idx: int,
+               discrete_val: list[str] | dict[Any, str],
+               default_val: Any,
                tooltip: str,
                on_change: Callable[[], Awaitable[None]]) -> Self:
         """Create NiceGUI Dropdown select element and add a tooltip."""
+        if isinstance(discrete_val, list):
+            discrete_val = {val: val for val in discrete_val}
+
+        assert isinstance(discrete_val, dict)
+        assert default_val in list(discrete_val.keys())
         with ui.select(discrete_val,
                        label=label,
-                       value=discrete_val[default_idx]).on('update:modelValue', on_change).style('width:100%') as input:
+                       value=default_val).on('update:modelValue', on_change).style('width:100%') as input:
             ui.tooltip(tooltip)
         return cls(input)
 
@@ -60,6 +73,12 @@ def _value_str(self) -> str:
         val = str(safe(self.input.value))
         return val
 
+    @property
+    def _value_raw(self) -> Any:
+        """Return the str value."""
+        val: Any = safe(self.input.value)
+        return val
+
 
 @dataclass
 class UiDropdownStr(UiDropdown):
@@ -70,6 +89,14 @@ def value(self) -> str:
         """Return the value."""
         return self._value_str
 
+@dataclass
+class UiDropdownGeneric(UiDropdown):
+    """NiceGUI Str Dropdown Wrapper."""
+
+    @property
+    def value(self) -> Any:
+        """Return the value."""
+        return self._value_raw
 
 @dataclass
 class UiInputStr(UiInput):
