Complete rewrite of config handling

Author: nalquas

.vscode/settings.json

@@ -7,7 +7,7 @@
         "**/.pytest_cache": true,
         "**/.mypy_cache": true
     },
-    "python.analysis.typeCheckingMode": "standard",
+    "python.analysis.typeCheckingMode": "basic",
     "python.testing.pytestArgs": [
         "tests"
     ],

bears_flight_simulation/core/config.py

@@ -0,0 +1,16 @@
+class Config:
+    def __init__(self, data: dict) -> None:
+        self.extend_field_links([])
+        for field_name, field_type in self.field_links:
+            self.__setattr__(field_name, field_type(data[field_name]))
+
+    def serialize(self) -> dict:
+        return {
+            field_name: getattr(self, field_name) for field_name, _ in self.field_links
+        }
+
+    def extend_field_links(self, new_field_links: list[tuple[str, type]]) -> None:
+        existing_field_links = getattr(self, "field_links", None)
+        if existing_field_links is None:
+            self.field_links = []
+        self.field_links += new_field_links

bears_flight_simulation/core/flight_simulation.py

@@ -1,18 +1,14 @@
 from abc import ABC, abstractmethod
 
+from bears_flight_simulation.core.config import Config
 
-class LibraryEntry(ABC):
-    id: str
 
+class LibraryEntry(ABC, Config):
     def __init__(self, data: dict) -> None:
-        # Load identifier
-        self.id = str(data["ID"])
+        self.extend_field_links([("id", str)])
+        super().__init__(data)
 
     @classmethod
     @abstractmethod
     def new_default(cls, id: str) -> "LibraryEntry":
         raise NotImplementedError
-
-    @abstractmethod
-    def serialize(self) -> dict:
-        raise NotImplementedError

bears_flight_simulation/core/library_entry.py

@@ -2,16 +2,16 @@
 
 from bears_flight_simulation.core.library import Library
 from bears_flight_simulation.core.library_entry import LibraryEntry
-from bears_flight_simulation.parsers.location import Location
+from bears_flight_simulation.parsers.location_config import LocationConfig
 
 
 class LocationLibrary(Library):
     def load_entry(self, data: dict) -> LibraryEntry:
-        return Location(data)
+        return LocationConfig(data)
 
     def new_entry(self) -> LibraryEntry:
         id = str(uuid4())
-        entry = Location.new_default(id)
+        entry = LocationConfig.new_default(id)
         self.entries[id] = entry
         self.save()
         return entry

bears_flight_simulation/core/location_library.py

@@ -11,21 +11,21 @@
 
 
 class AirbrakeConfig(LibraryEntry):
-    sampling_rate_hz: float
-    controller_name: str
     controller_function: t.Callable
-    drag_curve_filename_without_folder: str
     drag_curve_filepath: Path
-    drag_curve_standard_deviation_factor: float
 
     def __init__(self, data: dict, airbrake_folder: Path) -> None:
+        self.extend_field_links(
+            [
+                ("sampling_rate_hz", float),
+                ("controller_function_name", str),
+                ("drag_curve_file", str),
+                ("drag_curve_standard_deviation_factor", float),
+            ]
+        )
         super().__init__(data)
 
-        self.sampling_rate_hz = float(data["sampling_rate_hz"])
-
-        self.controller_name = str(data["controller_function_name"])
-
-        match self.controller_name:
+        match self.controller_function_name:  # type: ignore
             case "disabled_controller":
                 self.controller_function = disabled_controller
             case "enabled_controller":
@@ -37,30 +37,17 @@ def __init__(self, data: dict, airbrake_folder: Path) -> None:
             case _:
                 raise NotImplementedError
 
-        self.drag_curve_filename_without_folder = str(data["drag_curve_file"])
         self.drag_curve_filepath = airbrake_folder / str(data["drag_curve_file"])
-        self.drag_curve_standard_deviation_factor = float(
-            data["drag_curve_standard_deviation_factor"]
-        )
 
     @classmethod
     def new_default(cls, id: str) -> "AirbrakeConfig":
         return AirbrakeConfig(
             {
-                "ID": id,
+                "id": id,
                 "sampling_rate_hz": 10.0,
                 "controller_function_name": "disabled_controller",
                 "drag_curve_file": "stargaze_airbrake_drag_curve.csv",
                 "drag_curve_standard_deviation_factor": 0.1,
             },
             airbrake_folder=Path(""),
         )
-
-    def serialize(self) -> dict:
-        return {
-            "ID": self.id,
-            "sampling_rate_hz": self.sampling_rate_hz,
-            "controller_function_name": self.controller_name,
-            "drag_curve_file": self.drag_curve_filename_without_folder,
-            "drag_curve_standard_deviation_factor": self.drag_curve_standard_deviation_factor,
-        }

bears_flight_simulation/parsers/airbrake_config.py

@@ -2,34 +2,47 @@
 
 import yaml
 
+from bears_flight_simulation.core.library_entry import LibraryEntry
 
-class FinsConfig:
-    n: int
-    root_chord: float
-    tip_chord: float
-    span: float
-    position: float
-    cant_angle: float
+
+class FinsConfig(LibraryEntry):
     sweep_length: t.Union[float, None]
     sweep_angle: t.Union[float, None]
     radius: t.Union[float, None]
 
-    def __init__(self, fins_config_file: t.TextIO) -> None:
-        # Load yaml file
-        data = yaml.safe_load(fins_config_file)
+    def __init__(self, data: dict) -> None:
+        self.extend_field_links(
+            [
+                ("n", int),
+                ("root_chord", float),
+                ("tip_chord", float),
+                ("span", float),
+                ("position", float),
+                ("cant_angle", float),
+            ]
+        )
+        super().__init__(data)
 
-        # Load fins data
-        self.n = int(data["n"])
-        self.root_chord = float(data["root_chord"])
-        self.tip_chord = float(data["tip_chord"])
-        self.span = float(data["span"])
-        self.position = float(data["position"])
-        self.cant_angle = float(data["cant_angle"])
         self.sweep_length = data["sweep_length"]
-        self.sweep_angle = data["sweep_angle"]
-        self.radius = data["radius"]
-
-        # Ensure types for multi-type attributes
         assert type(self.sweep_length) in [float, type(None)]
+        self.sweep_angle = data["sweep_angle"]
         assert type(self.sweep_angle) in [float, type(None)]
+        self.radius = data["radius"]
         assert type(self.radius) in [float, type(None)]
+
+    @classmethod
+    def new_default(cls, id: str) -> LibraryEntry:
+        return FinsConfig(
+            {
+                "id": id,
+                "n": 3,
+                "root_chord": 0.236,
+                "tip_chord": 0.136,
+                "span": 0.091,
+                "position": 0.246,
+                "cant_angle": 0.0,
+                "sweep_length": 0.0498,
+                "sweep_angle": None,
+                "radius": None,
+            }
+        )

bears_flight_simulation/parsers/fins_config.py

@@ -0,0 +1,24 @@
+from bears_flight_simulation.core.library_entry import LibraryEntry
+
+
+class LocationConfig(LibraryEntry):
+    def __init__(self, data: dict) -> None:
+        self.extend_field_links(
+            [
+                ("latitude", float),
+                ("longitude", float),
+                ("elevation", float),
+            ]
+        )
+        super().__init__(data)
+
+    @classmethod
+    def new_default(cls, id: str) -> "LocationConfig":
+        return LocationConfig(
+            {
+                "id": id,
+                "latitude": 0.0,
+                "longitude": 0.0,
+                "elevation": 0.0,
+            }
+        )