implements rocketpy encoders

Author: GabrielBarberini

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 rocketpy_encoder, DiscretizeConfig
 
 
 class EnvironmentService:
@@ -50,7 +50,9 @@ def get_environment_simulation(self) -> EnvironmentSimulation:
             EnvironmentSimulation
         """
 
-        attributes = get_instance_attributes(self.environment)
+        attributes = rocketpy_encoder(
+            self.environment, DiscretizeConfig.for_environment()
+        )
         env_simulation = EnvironmentSimulation(**attributes)
         return env_simulation
 

src/services/flight.py

@@ -3,12 +3,12 @@
 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.utils import rocketpy_encoder, DiscretizeConfig
 
 
 class FlightService:
@@ -55,7 +55,9 @@ def get_flight_simulation(self) -> FlightSimulation:
         Returns:
             FlightSimulation
         """
-        attributes = get_instance_attributes(self.flight)
+        attributes = rocketpy_encoder(
+            self.flight, DiscretizeConfig.for_flight()
+        )
         flight_simulation = FlightSimulation(**attributes)
         return flight_simulation
 

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 rocketpy_encoder, DiscretizeConfig
 
 
 class MotorService:
@@ -140,7 +140,7 @@ def get_motor_simulation(self) -> MotorSimulation:
         Returns:
             MotorSimulation
         """
-        attributes = get_instance_attributes(self.motor)
+        attributes = rocketpy_encoder(self.motor, DiscretizeConfig.for_motor())
         motor_simulation = MotorSimulation(**attributes)
         return motor_simulation
 

src/services/rocket.py

@@ -11,13 +11,13 @@
     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.utils import rocketpy_encoder, DiscretizeConfig
 
 
 class RocketService:
@@ -107,7 +107,9 @@ def get_rocket_simulation(self) -> RocketSimulation:
         Returns:
             RocketSimulation
         """
-        attributes = get_instance_attributes(self.rocket)
+        attributes = rocketpy_encoder(
+            self.rocket, DiscretizeConfig.for_rocket()
+        )
         rocket_simulation = RocketSimulation(**attributes)
         return rocket_simulation
 

src/utils.py

@@ -1,48 +1,114 @@
 # 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, Tuple
 
-from pydantic import PlainSerializer
+from rocketpy import Function
+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:
+
+class DiscretizeConfig:
     """
-    Convert complex types to Python primitives.
+    Configuration class for RocketPy function discretization.
 
-    Args:
-        v: Any value, particularly those with a 'source' attribute
-       containing numpy arrays or generic types.
+    This class allows easy configuration of discretization parameters
+    for different types of RocketPy objects and their callable attributes.
+    """
 
-    Returns:
-        The primitive representation of the input value.
+    def __init__(
+        self, bounds: Tuple[float, float] = (0, 10), samples: int = 200
+    ):
+        self.bounds = bounds
+        self.samples = samples
+
+    @classmethod
+    def for_environment(cls) -> 'DiscretizeConfig':
+        return cls(bounds=(0, 50000), samples=100)
+
+    @classmethod
+    def for_motor(cls) -> 'DiscretizeConfig':
+        return cls(bounds=(0, 10), samples=150)
+
+    @classmethod
+    def for_rocket(cls) -> 'DiscretizeConfig':
+        return cls(bounds=(0, 1), samples=100)
+
+    @classmethod
+    def for_flight(cls) -> 'DiscretizeConfig':
+        return cls(bounds=(0, 30), samples=200)
+
+
+def rocketpy_encoder(obj, config: DiscretizeConfig = DiscretizeConfig()):
     """
-    if hasattr(v, "source"):
-        if isinstance(v.source, np.ndarray):
-            return v.source.tolist()
+    Encode a RocketPy object using official RocketPy encoders.
 
-        if isinstance(v.source, (np.generic,)):
-            return v.source.item()
+    This function discretizes callable Function attributes and then uses
+    RocketPy's official RocketPyEncoder for complete object serialization.
 
-        return str(v.source)
+    Args:
+        obj: RocketPy object (Environment, Motor, Rocket, Flight)
+        config: DiscretizeConfig object with discretization parameters (optional)
 
-    if isinstance(v, (np.generic,)):
-        return v.item()
+    Returns:
+        Dictionary of encoded attributes
+    """
 
-    if isinstance(v, (np.ndarray,)):
-        return v.tolist()
+    for attr_name in dir(obj):
+        if attr_name.startswith('_'):
+            continue
+
+        try:
+            attr_value = getattr(obj, attr_name)
+        except Exception:
+            continue
+
+        if callable(attr_value) and isinstance(attr_value, Function):
+            try:
+                # Create a new Function from the source to avoid mutating the original object.
+                # This is important because:
+                # 1. The original RocketPy object should remain unchanged for reusability
+                # 2. Multiple simulations might need different discretization parameters
+                # 3. Other parts of the system might depend on the original continuous function
+                discretized_func = Function(attr_value.source)
+                discretized_func.set_discrete(
+                    lower=config.bounds[0],
+                    upper=config.bounds[1],
+                    samples=config.samples,
+                    mutate_self=True,
+                )
 
-    return str(v)
+                setattr(obj, attr_name, discretized_func)
 
+            except Exception as e:
+                logger.warning(f"Failed to discretize {attr_name}: {e}")
 
-AnyToPrimitive = Annotated[
-    Any,
-    PlainSerializer(to_python_primitive),
-]
+    try:
+        json_str = json.dumps(
+            obj,
+            cls=RocketPyEncoder,
+            include_outputs=True,
+            include_function_data=True,
+        )
+        return json.loads(json_str)
+    except Exception as e:
+        logger.warning(f"Failed to encode with RocketPyEncoder: {e}")
+        attributes = {}
+        for attr_name in dir(obj):
+            if not attr_name.startswith('_'):
+                try:
+                    attr_value = getattr(obj, attr_name)
+                    if not callable(attr_value):
+                        attributes[attr_name] = str(attr_value)
+                except Exception:
+                    continue
+        return attributes
 
 
 class RocketPyGZipMiddleware:

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='allow', 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
@@ -26,27 +38,38 @@ class EnvironmentSimulation(ApiBaseView):
     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
+
+    # 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
+
+    def __init__(self, **data):
+        """
+        Initialize with dynamic attribute handling.
+
+        Any additional attributes returned by rocketpy_encoder will be stored
+        as extra fields thanks to the 'allow' extra configuration.
+        """
+        super().__init__(**data)
 
 
 class EnvironmentView(EnvironmentModel):