MNT: address PR review comments from CodeRabbit and Copilot

- Fix implicit string concatenation in notebook source (Pylint W1404)
- Update FlightImported.message to say ".rpy file" instead of "binary"
- Add 10 MB upload size guard with HTTP 413 on POST /flights/upload
- Extract tanks for LIQUID/HYBRID motors in _extract_motor to satisfy
  MotorModel validation (new _extract_tanks and _to_float helpers)
- Add comment explaining default_fins schema fallback
- Tighten test assertion on import success message
- Add pre-yield cache_clear() in environments test fixture

Made-with: Cursor

Author: GabrielBarberini

src/routes/flight.py

@@ -4,7 +4,14 @@
 
 import json
 
-from fastapi import APIRouter, Response, UploadFile, File
+from fastapi import (
+    APIRouter,
+    File,
+    HTTPException,
+    Response,
+    UploadFile,
+    status,
+)
 from opentelemetry import trace
 
 from src.views.flight import (
@@ -30,6 +37,8 @@
 
 tracer = trace.get_tracer(__name__)
 
+MAX_RPY_UPLOAD_BYTES = 10 * 1024 * 1024  # 10 MB
+
 
 @router.post("/", status_code=201)
 async def create_flight(
@@ -186,21 +195,26 @@ async def get_rocketpy_flight_rpy(
 )
 async def import_flight_from_rpy(
     file: UploadFile = File(...),
-    controller: FlightControllerDep = None,
+    controller: FlightControllerDep = None,  # noqa: B008
 ) -> FlightImported:
     """
     Upload a ``.rpy`` JSON file containing a RocketPy Flight.
 
     The file is deserialized and decomposed into its
     constituent objects (Environment, Motor, Rocket, Flight).
     Each object is persisted as a normal JSON model and the
-    corresponding IDs are returned.
+    corresponding IDs are returned.  Maximum upload size is 10 MB.
 
     ## Args
     ``` file: .rpy JSON upload ```
     """
     with tracer.start_as_current_span("import_flight_from_rpy"):
-        content = await file.read()
+        content = await file.read(MAX_RPY_UPLOAD_BYTES + 1)
+        if len(content) > MAX_RPY_UPLOAD_BYTES:
+            raise HTTPException(
+                status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
+                detail="Uploaded .rpy file exceeds 10 MB limit.",
+            )
         return await controller.import_flight_from_rpy(content)
 
 

src/services/flight.py

@@ -5,9 +5,15 @@
 
 from rocketpy.simulation.flight import Flight as RocketPyFlight
 from rocketpy._encoders import RocketPyEncoder, RocketPyDecoder
+from rocketpy.mathutils.function import Function
 from rocketpy.motors.solid_motor import SolidMotor
 from rocketpy.motors.liquid_motor import LiquidMotor
 from rocketpy.motors.hybrid_motor import HybridMotor
+from rocketpy import (
+    LevelBasedTank,
+    MassBasedTank,
+    UllageBasedTank,
+)
 from rocketpy.rocket.aero_surface import (
     NoseCone as RocketPyNoseCone,
     TrapezoidalFins as RocketPyTrapezoidalFins,
@@ -27,6 +33,7 @@
     Tail,
     Parachute,
 )
+from src.models.sub.tanks import MotorTank, TankFluids, TankKinds
 from src.views.flight import FlightSimulation
 from src.views.rocket import RocketSimulation
 from src.views.motor import MotorSimulation
@@ -169,22 +176,27 @@ def _extract_motor(motor) -> MotorModel:
             ),
         }
 
+        grain_fields = {
+            "grain_number": motor.grain_number,
+            "grain_density": motor.grain_density,
+            "grain_outer_radius": motor.grain_outer_radius,
+            "grain_initial_inner_radius": (motor.grain_initial_inner_radius),
+            "grain_initial_height": motor.grain_initial_height,
+            "grain_separation": motor.grain_separation,
+            "grains_center_of_mass_position": (
+                motor.grains_center_of_mass_position
+            ),
+            "throat_radius": motor.throat_radius,
+        }
+
         match kind:
-            case MotorKinds.SOLID | MotorKinds.HYBRID:
-                data |= {
-                    "grain_number": motor.grain_number,
-                    "grain_density": motor.grain_density,
-                    "grain_outer_radius": (motor.grain_outer_radius),
-                    "grain_initial_inner_radius": (
-                        motor.grain_initial_inner_radius
-                    ),
-                    "grain_initial_height": (motor.grain_initial_height),
-                    "grain_separation": motor.grain_separation,
-                    "grains_center_of_mass_position": (
-                        motor.grains_center_of_mass_position
-                    ),
-                    "throat_radius": motor.throat_radius,
-                }
+            case MotorKinds.SOLID:
+                data |= grain_fields
+            case MotorKinds.HYBRID:
+                data |= grain_fields
+                data["tanks"] = FlightService._extract_tanks(motor)
+            case MotorKinds.LIQUID:
+                data["tanks"] = FlightService._extract_tanks(motor)
             case MotorKinds.GENERIC:
                 data |= {
                     "chamber_radius": getattr(motor, "chamber_radius", None),
@@ -202,6 +214,83 @@ def _extract_motor(motor) -> MotorModel:
 
         return MotorModel(**data)
 
+    @staticmethod
+    def _to_float(value) -> float:
+        """Extract a plain float from a RocketPy Function or scalar."""
+        match value:
+            case Function():
+                return float(value(0))
+            case _:
+                return float(value)
+
+    @staticmethod
+    def _extract_tanks(motor) -> list[MotorTank]:
+        tanks: list[MotorTank] = []
+        for entry in motor.positioned_tanks:
+            tank, position = entry["tank"], entry["position"]
+
+            match tank:
+                case LevelBasedTank():
+                    tank_kind = TankKinds.LEVEL
+                case MassBasedTank():
+                    tank_kind = TankKinds.MASS
+                case UllageBasedTank():
+                    tank_kind = TankKinds.ULLAGE
+                case _:
+                    tank_kind = TankKinds.MASS_FLOW
+
+            geometry = [
+                (bounds, float(func(0)))
+                for bounds, func in tank.geometry.geometry.items()
+            ]
+
+            data: dict = {
+                "geometry": geometry,
+                "gas": TankFluids(
+                    name=tank.gas.name,
+                    density=tank.gas.density,
+                ),
+                "liquid": TankFluids(
+                    name=tank.liquid.name,
+                    density=tank.liquid.density,
+                ),
+                "flux_time": tank.flux_time,
+                "position": position,
+                "discretize": tank.discretize,
+                "tank_kind": tank_kind,
+                "name": tank.name,
+            }
+
+            _f = FlightService._to_float
+            match tank_kind:
+                case TankKinds.LEVEL:
+                    data["liquid_height"] = _f(tank.liquid_height)
+                case TankKinds.MASS:
+                    data["liquid_mass"] = _f(tank.liquid_mass)
+                    data["gas_mass"] = _f(tank.gas_mass)
+                case TankKinds.MASS_FLOW:
+                    data |= {
+                        "gas_mass_flow_rate_in": _f(
+                            tank.gas_mass_flow_rate_in
+                        ),
+                        "gas_mass_flow_rate_out": _f(
+                            tank.gas_mass_flow_rate_out
+                        ),
+                        "liquid_mass_flow_rate_in": _f(
+                            tank.liquid_mass_flow_rate_in
+                        ),
+                        "liquid_mass_flow_rate_out": _f(
+                            tank.liquid_mass_flow_rate_out
+                        ),
+                        "initial_liquid_mass": (tank.initial_liquid_mass),
+                        "initial_gas_mass": (tank.initial_gas_mass),
+                    }
+                case TankKinds.ULLAGE:
+                    data["ullage"] = _f(tank.ullage)
+
+            tanks.append(MotorTank(**data))
+        return tanks
+
     @staticmethod
     def _drag_to_list(fn) -> list:
         match getattr(fn, "source", None):
@@ -293,6 +382,8 @@ def _extract_rocket(rocket, motor_model: MotorModel) -> RocketModel:
             rocket.I_33_without_motor,
         )
 
+        # Schema requires at least one Fins entry; n=0 means
+        # no physical fins (safe for downstream aero calculations).
         default_fins = [
             Fins(
                 fins_kind="trapezoidal",
@@ -359,7 +450,7 @@ def _extract_flight(
         )
 
     # ------------------------------------------------------------------
-    # Simulation & binary
+    # Simulation & export
     # ------------------------------------------------------------------
 
     def get_flight_simulation(self) -> FlightSimulation:
@@ -432,7 +523,7 @@ def generate_notebook(flight_id: str) -> dict:
                 "metadata": {},
                 "outputs": [],
                 "source": [
-                    "from rocketpy.utilities import " "load_from_rpy\n",
+                    "from rocketpy.utilities import load_from_rpy\n",
                     "import matplotlib\n",
                 ],
             },

src/views/flight.py

@@ -151,7 +151,7 @@ class FlightCreated(ApiBaseView):
 
 
 class FlightImported(ApiBaseView):
-    message: str = "Flight successfully imported from binary"
+    message: str = "Flight successfully imported from .rpy file"
     flight_id: str
     rocket_id: str
     motor_id: str

tests/unit/test_routes/test_environments_route.py

@@ -38,6 +38,8 @@ def mock_controller_instance():
 
         mock_class.return_value = mock_controller
 
+        get_environment_controller.cache_clear()
+
         yield mock_controller
 
         get_environment_controller.cache_clear()

tests/unit/test_routes/test_flights_route.py

@@ -568,7 +568,7 @@ def test_import_flight_from_rpy(mock_controller_instance):
     assert body['rocket_id'] == 'r1'
     assert body['motor_id'] == 'm1'
     assert body['environment_id'] == 'e1'
-    assert 'imported' in body['message'].lower()
+    assert body['message'] == "Flight successfully imported from .rpy file"
     mock_controller_instance.import_flight_from_rpy.assert_called_once_with(
         rpy_content
     )