MNT: make Parachute base serialization inheritance-safe

The abstract Parachute.to_dict/from_dict referenced model-specific
attributes (cd_s, radius, drag_coefficient, height, porosity) that the
base no longer owns, and from_dict forwarded a `parachute_type` kwarg that
concrete constructors do not accept. They worked only because
HemisphericalParachute fully overrode them; any future parachute model
inheriting them would hit AttributeError/TypeError.

Reduce the base methods to the fields the base actually owns and expose a
shared `_decode_trigger` helper. HemisphericalParachute now builds on
`super().to_dict()` (matching the repo-wide serialization convention) and
adds only its own fields, removing the verbatim duplication. Serialized
output and round-trip behavior are unchanged. Drop the now-unused imports.

Author: Gui-FernandesBR

rocketpy/rocket/parachutes/hemispherical_parachute.py

@@ -1,8 +1,5 @@
 import numpy as np
 
-from rocketpy.tools import from_hex_decode, to_hex_encode
-
-from ...mathutils.function import Function
 from .parachute import Parachute
 
 
@@ -374,54 +371,24 @@ def u_dot(self, t, u, flight_information, post_processing=False):
 
     # serialization methods
     def to_dict(self, **kwargs):
-        allow_pickle = kwargs.get("allow_pickle", True)
-        trigger = self.trigger
-
-        if callable(self.trigger) and not isinstance(self.trigger, Function):
-            if allow_pickle:
-                trigger = to_hex_encode(trigger)
-            else:
-                trigger = trigger.__name__
-
-        data = {
-            "name": self.name,
-            "parachute_type": self.parachute_type,
-            "cd_s": self.cd_s,
-            "trigger": trigger,
-            "sampling_rate": self.sampling_rate,
-            "lag": self.lag,
-            "noise": self.noise,
-            "radius": self.radius,
-            "drag_coefficient": self.drag_coefficient,
-            "height": self.height,
-            "porosity": self.porosity,
-        }
-
-        if kwargs.get("include_outputs", False):
-            data["noise_signal"] = self.noise_signal
-            data["noise_function"] = (
-                to_hex_encode(self.noise_function)
-                if allow_pickle
-                else self.noise_function.__name__
-            )
-            data["noisy_pressure_signal"] = self.noisy_pressure_signal
-            data["clean_pressure_signal"] = self.clean_pressure_signal
-
+        data = super().to_dict(**kwargs)
+        data.update(
+            {
+                "cd_s": self.cd_s,
+                "radius": self.radius,
+                "drag_coefficient": self.drag_coefficient,
+                "height": self.height,
+                "porosity": self.porosity,
+            }
+        )
         return data
 
     @classmethod
     def from_dict(cls, data):
-        trigger = data["trigger"]
-
-        try:
-            trigger = from_hex_decode(trigger)
-        except (TypeError, ValueError):
-            pass
-
-        parachute = cls(
+        return cls(
             name=data["name"],
             cd_s=data["cd_s"],
-            trigger=trigger,
+            trigger=cls._decode_trigger(data["trigger"]),
             sampling_rate=data["sampling_rate"],
             lag=data["lag"],
             noise=data["noise"],
@@ -430,5 +397,3 @@ def from_dict(cls, data):
             height=data.get("height", None),
             porosity=data.get("porosity", 0.0432),
         )
-
-        return parachute

rocketpy/rocket/parachutes/parachute.py

@@ -351,6 +351,9 @@ def u_dot(self, t, u, flight_information, post_processing=False):
         """
 
     def to_dict(self, **kwargs):
+        """Serializes the fields shared by every parachute model. Subclasses
+        should call ``super().to_dict(**kwargs)`` and add their model-specific
+        attributes to the returned dictionary."""
         allow_pickle = kwargs.get("allow_pickle", True)
         trigger = self.trigger
 
@@ -363,15 +366,10 @@ def to_dict(self, **kwargs):
         data = {
             "name": self.name,
             "parachute_type": self.parachute_type,
-            "cd_s": self.cd_s,
             "trigger": trigger,
             "sampling_rate": self.sampling_rate,
             "lag": self.lag,
             "noise": self.noise,
-            "radius": self.radius,
-            "drag_coefficient": self.drag_coefficient,
-            "height": self.height,
-            "porosity": self.porosity,
         }
 
         if kwargs.get("include_outputs", False):
@@ -386,22 +384,25 @@ def to_dict(self, **kwargs):
 
         return data
 
-    @classmethod
-    def from_dict(cls, data):
-        trigger = data["trigger"]
-
+    @staticmethod
+    def _decode_trigger(trigger):
+        """Decodes a (possibly hex-encoded) serialized trigger back into a
+        callable, leaving numeric/string triggers untouched."""
         try:
-            trigger = from_hex_decode(trigger)
+            return from_hex_decode(trigger)
         except (TypeError, ValueError):
-            pass
+            return trigger
 
-        parachute = cls(
+    @classmethod
+    def from_dict(cls, data):
+        """Reconstructs a parachute from the fields shared by every model.
+        Subclasses with additional constructor arguments (e.g. ``cd_s``) must
+        override this method; ``parachute_type`` is not forwarded because each
+        concrete model sets it itself."""
+        return cls(
             name=data["name"],
-            parachute_type=data["parachute_type"],
-            trigger=trigger,
+            trigger=cls._decode_trigger(data["trigger"]),
             sampling_rate=data["sampling_rate"],
             lag=data["lag"],
             noise=data["noise"],
         )
-
-        return parachute