MNT: adapt discretization schema to RocketPy encoder.

src/models/rocket.py

@@ -19,7 +19,7 @@ class RocketModel(ApiBaseModel):
     radius: float
     mass: float
     motor_position: float
-    center_of_mass_without_motor: int
+    center_of_mass_without_motor: float
     inertia: Union[
         Tuple[float, float, float],
         Tuple[float, float, float, float, float, float],

src/services/environment.py

@@ -3,9 +3,9 @@
 import dill
 
 from rocketpy.environment.environment import Environment as RocketPyEnvironment
-from rocketpy.utilities import get_instance_attributes
 from src.models.environment import EnvironmentModel
 from src.views.environment import EnvironmentSimulation
+from src.utils import collect_attributes
 
 
 class EnvironmentService:
@@ -54,8 +54,11 @@ def get_environment_simulation(self) -> EnvironmentSimulation:
             EnvironmentSimulation
         """
 
-        attributes = get_instance_attributes(self.environment)
-        env_simulation = EnvironmentSimulation(**attributes)
+        encoded_attributes = collect_attributes(
+            self.environment,
+            [EnvironmentSimulation],
+        )
+        env_simulation = EnvironmentSimulation(**encoded_attributes)
         return env_simulation
 
     def get_environment_binary(self) -> bytes:

src/services/flight.py

@@ -3,13 +3,15 @@
 import dill
 
 from rocketpy.simulation.flight import Flight as RocketPyFlight
-from rocketpy.utilities import get_instance_attributes
 
 from src.services.environment import EnvironmentService
 from src.services.rocket import RocketService
 from src.models.flight import FlightModel
 from src.views.flight import FlightSimulation
-
+from src.views.rocket import RocketSimulation
+from src.views.motor import MotorSimulation
+from src.views.environment import EnvironmentSimulation
+from src.utils import collect_attributes
 
 class FlightService:
     _flight: RocketPyFlight
@@ -55,8 +57,11 @@ def get_flight_simulation(self) -> FlightSimulation:
         Returns:
             FlightSimulation
         """
-        attributes = get_instance_attributes(self.flight)
-        flight_simulation = FlightSimulation(**attributes)
+        encoded_attributes = collect_attributes(
+            self.flight,
+            [FlightSimulation, RocketSimulation, MotorSimulation, EnvironmentSimulation]
+        )
+        flight_simulation = FlightSimulation(**encoded_attributes)
         return flight_simulation
 
     def get_flight_binary(self) -> bytes:

src/services/motor.py

@@ -6,7 +6,6 @@
 from rocketpy.motors.solid_motor import SolidMotor
 from rocketpy.motors.liquid_motor import LiquidMotor
 from rocketpy.motors.hybrid_motor import HybridMotor
-from rocketpy.utilities import get_instance_attributes
 from rocketpy import (
     LevelBasedTank,
     MassBasedTank,
@@ -18,6 +17,7 @@
 from src.models.sub.tanks import TankKinds
 from src.models.motor import MotorKinds, MotorModel
 from src.views.motor import MotorSimulation
+from src.utils import collect_attributes
 
 
 class MotorService:
@@ -140,8 +140,11 @@ def get_motor_simulation(self) -> MotorSimulation:
         Returns:
             MotorSimulation
         """
-        attributes = get_instance_attributes(self.motor)
-        motor_simulation = MotorSimulation(**attributes)
+        encoded_attributes = collect_attributes(
+            self.motor,
+            [MotorSimulation],
+        )
+        motor_simulation = MotorSimulation(**encoded_attributes)
         return motor_simulation
 
     def get_motor_binary(self) -> bytes:

src/services/rocket.py

@@ -11,14 +11,14 @@
     Fins as RocketPyFins,
     Tail as RocketPyTail,
 )
-from rocketpy.utilities import get_instance_attributes
 
 from src import logger
 from src.models.rocket import RocketModel, Parachute
 from src.models.sub.aerosurfaces import NoseCone, Tail, Fins
 from src.services.motor import MotorService
 from src.views.rocket import RocketSimulation
-
+from src.views.motor import MotorSimulation
+from src.utils import collect_attributes
 
 class RocketService:
     _rocket: RocketPyRocket
@@ -107,8 +107,11 @@ def get_rocket_simulation(self) -> RocketSimulation:
         Returns:
             RocketSimulation
         """
-        attributes = get_instance_attributes(self.rocket)
-        rocket_simulation = RocketSimulation(**attributes)
+        encoded_attributes = collect_attributes(
+            self.rocket,
+            [RocketSimulation, MotorSimulation]
+        )
+        rocket_simulation = RocketSimulation(**encoded_attributes)
         return rocket_simulation
 
     def get_rocket_binary(self) -> bytes:

src/utils.py

@@ -1,49 +1,147 @@
-# fork of https://github.com/encode/starlette/blob/master/starlette/middleware/gzip.py
 import gzip
 import io
+import logging
+import json
 
-from typing import Annotated, NoReturn, Any
-import numpy as np
+from typing import NoReturn
 
-from pydantic import PlainSerializer
+from views.environment import EnvironmentSimulation
+from views.flight import FlightSimulation
+from views.motor import MotorSimulation
+from views.rocket import RocketSimulation
+
+from rocketpy._encoders import RocketPyEncoder
 from starlette.datastructures import Headers, MutableHeaders
 from starlette.types import ASGIApp, Message, Receive, Scope, Send
 
+logger = logging.getLogger(__name__)
+
 
-def to_python_primitive(v: Any) -> Any:
+def rocketpy_encoder(obj):
     """
-    Convert complex types to Python primitives.
+    Encode a RocketPy object using official RocketPy encoders.
+
+    This function uses RocketPy's official RocketPyEncoder for complete
+    object serialization.
 
     Args:
-        v: Any value, particularly those with a 'source' attribute
-       containing numpy arrays or generic types.
+        obj: RocketPy object (Environment, Motor, Rocket, Flight)
 
     Returns:
-        The primitive representation of the input value.
+        Dictionary of encoded attributes
     """
-    if hasattr(v, "source"):
-        if isinstance(v.source, np.ndarray):
-            return v.source.tolist()
-
-        if isinstance(v.source, (np.generic,)):
-            return v.source.item()
 
-        return str(v.source)
+    json_str = json.dumps(
+        obj,
+        cls=RocketPyEncoder,
+        include_outputs=True,
+        include_function_data=True,
+        discretize=True,
+        allow_pickle=False,
+    )
+    return json.loads(json_str)
 
-    if isinstance(v, (np.generic,)):
-        return v.item()
 
-    if isinstance(v, (np.ndarray,)):
-        return v.tolist()
+def collect_attributes(obj, attribute_classes=None):
+    """
+    Collect attributes from various simulation classes and populate them from the flight object.
+
+    Args:
+        obj: RocketPy Flight object
+        attribute_classes: List of attribute classes to collect from
 
-    return str(v)
+    Returns:
+        Dictionary with all collected attributes
+    """
+    if attribute_classes is None:
+        attribute_classes = []
 
+    attributes = rocketpy_encoder(obj)
 
-AnyToPrimitive = Annotated[
-    Any,
-    PlainSerializer(to_python_primitive),
-]
+    for attribute_class in attribute_classes:
+        if issubclass(attribute_class, FlightSimulation):
+            flight_attributes_list = [
+                attr for attr in attribute_class.__annotations__.keys() 
+                if attr not in ['message', 'rocket', 'env']
+            ]
+            try:
+                for key in flight_attributes_list:
+                    if key not in attributes:
+                        try:
+                            value = getattr(obj, key)
+                            attributes[key] = value
+                        except AttributeError:
+                            pass
+                        except Exception:
+                            pass
+            except Exception:
+                pass
+
+        elif issubclass(attribute_class, RocketSimulation):
+            rocket_attributes_list = [
+                attr for attr in attribute_class.__annotations__.keys() 
+                if attr not in ['message', 'motor']
+            ]
+            try:
+                for key in rocket_attributes_list:
+                    if key not in attributes.get("rocket", {}):
+                        try:
+                            value = getattr(obj.rocket, key)
+                            if "rocket" not in attributes:
+                                attributes["rocket"] = {}
+                            attributes["rocket"][key] = value
+                        except AttributeError:
+                            pass
+                        except Exception:
+                            pass
+            except Exception:
+                pass
+
+        elif issubclass(attribute_class, MotorSimulation):
+            motor_attributes_list = [
+                attr for attr in attribute_class.__annotations__.keys() 
+                if attr not in ['message']
+            ]
+            try:
+                for key in motor_attributes_list:
+                    if key not in attributes.get("rocket", {}).get("motor", {}):
+                        try:
+                            value = getattr(obj.rocket.motor, key)
+                            if "rocket" not in attributes:
+                                attributes["rocket"] = {}
+                            if "motor" not in attributes["rocket"]:
+                                attributes["rocket"]["motor"] = {}
+                            attributes["rocket"]["motor"][key] = value
+                        except AttributeError:
+                            pass
+                        except Exception:
+                            pass
+            except Exception:
+                pass
+
+        elif issubclass(attribute_class, EnvironmentSimulation):
+            environment_attributes_list = [
+                attr for attr in attribute_class.__annotations__.keys()
+                if attr not in ['message']
+            ]
+            try:
+                for key in environment_attributes_list:
+                    if key not in attributes.get("env", {}):
+                        try:
+                            value = getattr(obj.env, key)
+                            if "env" not in attributes:
+                                attributes["env"] = {}
+                            attributes["env"][key] = value
+                        except AttributeError:
+                            pass
+                        except Exception:
+                            pass
+            except Exception:
+                pass
+        else:
+            continue
 
+    return rocketpy_encoder(attributes)
 
 class RocketPyGZipMiddleware:
     def __init__(
@@ -70,6 +168,7 @@ async def __call__(
 
 
 class GZipResponder:
+    # fork of https://github.com/encode/starlette/blob/master/starlette/middleware/gzip.py
     def __init__(
         self, app: ASGIApp, minimum_size: int, compresslevel: int = 9
     ) -> None:

src/views/environment.py

@@ -1,12 +1,24 @@
-from typing import Optional
+from typing import Optional, Any
 from datetime import datetime, timedelta
+from pydantic import ConfigDict
 from src.views.interface import ApiBaseView
 from src.models.environment import EnvironmentModel
-from src.utils import AnyToPrimitive
 
 
 class EnvironmentSimulation(ApiBaseView):
+    """
+    Environment simulation view that handles dynamically encoded RocketPy Environment attributes.
+
+    Uses the new rocketpy_encoder which may return different attributes based on the
+    actual RocketPy Environment object. The model allows extra fields to accommodate
+    any new attributes that might be encoded.
+    """
+
+    model_config = ConfigDict(extra='ignore', arbitrary_types_allowed=True)
+
     message: str = "Environment successfully simulated"
+
+    # Core Environment attributes (always present)
     latitude: Optional[float] = None
     longitude: Optional[float] = None
     elevation: Optional[float] = 1
@@ -23,30 +35,32 @@ class EnvironmentSimulation(ApiBaseView):
     initial_hemisphere: Optional[str] = None
     initial_ew: Optional[str] = None
     max_expected_height: Optional[float] = None
-    date: Optional[datetime] = datetime.today() + timedelta(days=1)
-    local_date: Optional[datetime] = datetime.today() + timedelta(days=1)
-    datetime_date: Optional[datetime] = datetime.today() + timedelta(days=1)
-    ellipsoid: Optional[AnyToPrimitive] = None
-    barometric_height: Optional[AnyToPrimitive] = None
-    barometric_height_ISA: Optional[AnyToPrimitive] = None
-    pressure: Optional[AnyToPrimitive] = None
-    pressure_ISA: Optional[AnyToPrimitive] = None
-    temperature: Optional[AnyToPrimitive] = None
-    temperature_ISA: Optional[AnyToPrimitive] = None
-    density: Optional[AnyToPrimitive] = None
-    speed_of_sound: Optional[AnyToPrimitive] = None
-    dynamic_viscosity: Optional[AnyToPrimitive] = None
-    gravity: Optional[AnyToPrimitive] = None
-    somigliana_gravity: Optional[AnyToPrimitive] = None
-    wind_speed: Optional[AnyToPrimitive] = None
-    wind_direction: Optional[AnyToPrimitive] = None
-    wind_heading: Optional[AnyToPrimitive] = None
-    wind_velocity_x: Optional[AnyToPrimitive] = None
-    wind_velocity_y: Optional[AnyToPrimitive] = None
-    calculate_earth_radius: Optional[AnyToPrimitive] = None
-    decimal_degrees_to_arc_seconds: Optional[AnyToPrimitive] = None
-    geodesic_to_utm: Optional[AnyToPrimitive] = None
-    utm_to_geodesic: Optional[AnyToPrimitive] = None
+    date: Optional[Any] = datetime.today() + timedelta(days=1)
+    local_date: Optional[Any] = datetime.today() + timedelta(days=1)
+    datetime_date: Optional[Any] = datetime.today() + timedelta(days=1)
+
+    # Function attributes (discretized by rocketpy_encoder, serialized by RocketPyEncoder)
+    ellipsoid: Optional[Any] = None
+    barometric_height: Optional[Any] = None
+    barometric_height_ISA: Optional[Any] = None
+    pressure: Optional[Any] = None
+    pressure_ISA: Optional[Any] = None
+    temperature: Optional[Any] = None
+    temperature_ISA: Optional[Any] = None
+    density: Optional[Any] = None
+    speed_of_sound: Optional[Any] = None
+    dynamic_viscosity: Optional[Any] = None
+    gravity: Optional[Any] = None
+    somigliana_gravity: Optional[Any] = None
+    wind_speed: Optional[Any] = None
+    wind_direction: Optional[Any] = None
+    wind_heading: Optional[Any] = None
+    wind_velocity_x: Optional[Any] = None
+    wind_velocity_y: Optional[Any] = None
+    calculate_earth_radius: Optional[Any] = None
+    decimal_degrees_to_arc_seconds: Optional[Any] = None
+    geodesic_to_utm: Optional[Any] = None
+    utm_to_geodesic: Optional[Any] = None
 
 
 class EnvironmentView(EnvironmentModel):