Merge remote-tracking branch 'origin/master' into enh/tank-geometry-fluid-density

# Conflicts:
#	src/services/motor.py
#	src/services/rocket.py
#	src/views/rocket.py

Author: aasitvora99

src/controllers/motor.py

@@ -2,7 +2,7 @@
     ControllerBase,
     controller_exception_handler,
 )
-from src.views.motor import MotorSimulation
+from src.views.motor import MotorSimulation, MotorDrawingGeometryView
 from src.models.motor import MotorModel
 from src.services.motor import MotorService
 
@@ -57,3 +57,27 @@ async def get_motor_simulation(self, motor_id: str) -> MotorSimulation:
         motor = await self.get_motor_by_id(motor_id)
         motor_service = MotorService.from_motor_model(motor.motor)
         return motor_service.get_motor_simulation()
+
+    @controller_exception_handler
+    async def get_motor_drawing_geometry(
+        self, motor_id: str
+    ) -> MotorDrawingGeometryView:
+        """
+        Build the motor-only drawing-geometry payload for a persisted motor.
+
+        Renders the motor at its own coordinate origin (motor_position=0,
+        parent_csys=1) so the playground can show a motor in isolation.
+
+        Args:
+            motor_id: str
+
+        Returns:
+            views.MotorDrawingGeometryView
+
+        Raises:
+            HTTP 404 Not Found: If the motor does not exist in the database.
+            HTTP 422: If the motor has no drawable geometry.
+        """
+        motor = await self.get_motor_by_id(motor_id)
+        motor_service = MotorService.from_motor_model(motor.motor)
+        return motor_service.get_drawing_geometry()

src/mcp/server.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from fastapi import FastAPI
-from fastmcp import FastMCP, settings
+from fastmcp import FastMCP
 
 
 def build_mcp(app: FastAPI) -> FastMCP:
@@ -17,10 +17,9 @@ def build_mcp(app: FastAPI) -> FastMCP:
         FastMCP: The FastMCP instance corresponding to the provided FastAPI app.
     """
 
-    if hasattr(app.state, 'mcp'):
+    if hasattr(app.state, "mcp"):
         return app.state.mcp  # type: ignore[attr-defined]
 
-    settings.experimental.enable_new_openapi_parser = True
     mcp = FastMCP.from_fastapi(app, name=app.title)
     app.state.mcp = mcp  # type: ignore[attr-defined]
     return mcp

src/routes/motor.py

@@ -9,6 +9,7 @@
     MotorSimulation,
     MotorCreated,
     MotorRetrieved,
+    MotorDrawingGeometryView,
 )
 from src.models.motor import MotorModel
 from src.dependencies import MotorControllerDep
@@ -163,3 +164,24 @@ async def get_motor_simulation(
     """
     with tracer.start_as_current_span("get_motor_simulation"):
         return await controller.get_motor_simulation(motor_id)
+
+
+@router.get("/{motor_id}/drawing-geometry")
+async def get_motor_drawing_geometry(
+    motor_id: str,
+    controller: MotorControllerDep,
+) -> MotorDrawingGeometryView:
+    """
+    Returns motor-only drawing geometry so a frontend can render the
+    motor in isolation. The payload mirrors what the motor portion of
+    `rocketpy.Rocket.draw()` would produce, but at the motor's own
+    coordinate origin rather than embedded inside a rocket.
+
+    Use `GET /rockets/{rocket_id}/drawing-geometry` instead when the
+    motor should be shown inside a complete rocket.
+
+    ## Args
+    ``` motor_id: Motor ID ```
+    """
+    with tracer.start_as_current_span("get_motor_drawing_geometry"):
+        return await controller.get_motor_drawing_geometry(motor_id)

src/services/motor.py

@@ -1,25 +1,31 @@
 from typing import Self
 
 import dill
+import numpy as np
 
-from rocketpy.motors.motor import GenericMotor, Motor as RocketPyMotor
+from rocketpy.motors.motor import Motor as RocketPyMotor
 from rocketpy.motors.solid_motor import SolidMotor
 from rocketpy.motors.liquid_motor import LiquidMotor
 from rocketpy.motors.hybrid_motor import HybridMotor
 from rocketpy import (
     CylindricalTank,
     Fluid,
     Function,
+    SphericalTank,
+    TankGeometry,
+)
+from rocketpy.motors import (
+    EmptyMotor,
+    GenericMotor,
     LevelBasedTank,
     MassBasedTank,
     MassFlowRateBasedTank,
-    SphericalTank,
-    TankGeometry,
     UllageBasedTank,
 )
 
 from fastapi import HTTPException, status
 
+from src import logger
 from src.models.sub.tanks import (
     CustomTankGeometry,
     CylindricalTankGeometry,
@@ -28,7 +34,12 @@
     TankKinds,
 )
 from src.models.motor import MotorKinds, MotorModel
-from src.views.motor import MotorSimulation
+from src.views.motor import MotorSimulation, MotorDrawingGeometryView
+from src.views.drawing import (
+    DrawingBounds,
+    MotorDrawingGeometry,
+    MotorPatch,
+)
 from src.utils import collect_attributes
 
 
@@ -84,6 +95,60 @@ def density_callable(temperature, pressure):  # noqa: ARG001
     return Fluid(name=fluids.name, density=density)
 
 
+# ---------------------------------------------------------------------------
+# Drawing-geometry helpers (module-level, shared by the motor and rocket
+# drawing paths). Kept private with the `_` prefix; consumers should go
+# through `MotorService.get_drawing_geometry` for the motor-only response
+# or through `RocketService.get_drawing_geometry` for the composed rocket
+# view (which delegates motor assembly here).
+# ---------------------------------------------------------------------------
+def _polygon_xy(patch) -> dict:
+    """Extract (x, y) coordinate lists from a matplotlib Polygon patch.
+
+    Rocketpy's `_MotorPlots` generator helpers return matplotlib `Polygon`
+    objects; we only ever read `patch.xy` (an Nx2 numpy array) as a data
+    carrier, never for rendering.
+    """
+    xy = np.asarray(patch.xy)
+    return {"x": xy[:, 0].tolist(), "y": xy[:, 1].tolist()}
+
+
+def _rebuild_polygon(x: list[float], y: list[float]):
+    """Rebuild a matplotlib `Polygon` from coordinate lists.
+
+    Used only so `_MotorPlots._generate_motor_region` can read `patch.xy`
+    bounds when we assemble the motor outline.
+    """
+    from matplotlib.patches import (
+        Polygon,
+    )  # local import keeps service cold-start lean
+
+    return Polygon(np.column_stack([np.asarray(x), np.asarray(y)]))
+
+
+def _build_generic_chamber_patch(
+    center_x: float, chamber_height: float, chamber_radius: float
+):
+    """Build a rectangular combustion-chamber polygon for a GenericMotor.
+
+    Mirrors the vertex order of
+    `rocketpy.plots.motor_plots._generate_combustion_chamber` so the patch
+    can flow through `_generate_motor_region` for outline computation
+    identically to a SolidMotor chamber.
+    """
+    from matplotlib.patches import (
+        Polygon,
+    )  # local import keeps service cold-start lean
+
+    half_len = chamber_height / 2.0
+    x = np.array([-half_len, half_len, half_len, -half_len])
+    y = np.array(
+        [chamber_radius, chamber_radius, -chamber_radius, -chamber_radius]
+    )
+    x = x + center_x
+    return Polygon(np.column_stack([x, y]))
+
+
 class MotorService:
     _motor: RocketPyMotor
 
@@ -261,3 +326,195 @@ def get_motor_binary(self) -> bytes:
             bytes
         """
         return dill.dumps(self.motor)
+
+    # --------------------------------------------------------------------
+    # Drawing geometry
+    # --------------------------------------------------------------------
+    def get_drawing_geometry(
+        self,
+        motor_position: float = 0.0,
+        parent_csys: int = 1,
+    ) -> MotorDrawingGeometryView:
+        """Build a motor-only drawing-geometry response.
+
+        Defaults render the motor at its own coordinate origin
+        (`motor_position=0`, `parent_csys=1`) so the payload can be used
+        standalone in the playground's "motor-only" view. Callers that
+        embed the motor into a rocket (see ``RocketService``) pass the
+        rocket-level position + csys to align the motor inside the rocket
+        frame.
+
+        Raises:
+            HTTPException 422 if the motor has no drawable patches.
+        """
+        motor_geometry, _nozzle_position = self.build_drawing_geometry(
+            motor_position=motor_position, parent_csys=parent_csys
+        )
+        if motor_geometry is None:
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail="Motor has no drawable geometry.",
+            )
+        # Fall back to the nozzle radius when the motor has no drawable
+        # patches (e.g. EmptyMotor) so the bounds aren't a zero-height
+        # line. Every real rocketpy motor class exposes nozzle_radius.
+        fallback_radius = float(
+            getattr(self._motor, "nozzle_radius", 0.0) or 0.0
+        )
+        return MotorDrawingGeometryView(
+            motor=motor_geometry,
+            coordinate_system_orientation=str(
+                self._motor.coordinate_system_orientation
+            ),
+            bounds=_compute_motor_bounds(motor_geometry, fallback_radius),
+        )
+
+    def build_drawing_geometry(
+        self,
+        motor_position: float,
+        parent_csys: int,
+    ) -> tuple[MotorDrawingGeometry | None, float]:
+        """Construct motor patches + the absolute nozzle x-position.
+
+        Returned as a tuple so the rocket service can use the nozzle
+        position when extending body tubes to meet the motor. Standalone
+        motor rendering can discard the second element.
+        """
+        motor = self._motor
+        total_csys = parent_csys * motor._csys
+        nozzle_position = motor_position + motor.nozzle_position * total_csys
+
+        if isinstance(motor, EmptyMotor):
+            return (
+                MotorDrawingGeometry(
+                    type="empty",
+                    position=float(motor_position),
+                    nozzle_position=float(nozzle_position),
+                    patches=[],
+                ),
+                float(nozzle_position),
+            )
+
+        patches: list[MotorPatch] = []
+        grains_cm_position: float | None = None
+        motor_type = "generic"
+
+        if isinstance(motor, SolidMotor):
+            motor_type = "solid"
+            grains_cm_position = (
+                motor_position
+                + motor.grains_center_of_mass_position * total_csys
+            )
+            chamber = motor.plots._generate_combustion_chamber(
+                translate=(grains_cm_position, 0), label=None
+            )
+            patches.append(MotorPatch(role="chamber", **_polygon_xy(chamber)))
+            for grain in motor.plots._generate_grains(
+                translate=(grains_cm_position, 0)
+            ):
+                patches.append(MotorPatch(role="grain", **_polygon_xy(grain)))
+        elif isinstance(motor, HybridMotor):
+            motor_type = "hybrid"
+            grains_cm_position = (
+                motor_position
+                + motor.grains_center_of_mass_position * total_csys
+            )
+            chamber = motor.plots._generate_combustion_chamber(
+                translate=(grains_cm_position, 0), label=None
+            )
+            patches.append(MotorPatch(role="chamber", **_polygon_xy(chamber)))
+            for grain in motor.plots._generate_grains(
+                translate=(grains_cm_position, 0)
+            ):
+                patches.append(MotorPatch(role="grain", **_polygon_xy(grain)))
+            for tank, _center in motor.plots._generate_positioned_tanks(
+                translate=(motor_position, 0), csys=total_csys
+            ):
+                patches.append(MotorPatch(role="tank", **_polygon_xy(tank)))
+        elif isinstance(motor, LiquidMotor):
+            motor_type = "liquid"
+            for tank, _center in motor.plots._generate_positioned_tanks(
+                translate=(motor_position, 0), csys=total_csys
+            ):
+                patches.append(MotorPatch(role="tank", **_polygon_xy(tank)))
+        elif isinstance(motor, GenericMotor):
+            # RocketPy's Rocket.draw() does not render a chamber for
+            # GenericMotor — `_generate_combustion_chamber` depends on
+            # grain fields GenericMotor lacks. We build an equivalent
+            # rectangular chamber from the GenericMotor fields so users
+            # see their chamber geometry in the playground.
+            motor_type = "generic"
+            chamber_center_x = (
+                motor_position + motor.chamber_position * total_csys
+            )
+            chamber_patch = _build_generic_chamber_patch(
+                center_x=chamber_center_x,
+                chamber_height=motor.chamber_height,
+                chamber_radius=motor.chamber_radius,
+            )
+            patches.append(
+                MotorPatch(role="chamber", **_polygon_xy(chamber_patch))
+            )
+
+        # Nozzle is always appended after the body so the motor-region
+        # outline encompasses it, matching rocketpy.
+        nozzle_patch = motor.plots._generate_nozzle(
+            translate=(nozzle_position, 0), csys=parent_csys
+        )
+        patches.append(MotorPatch(role="nozzle", **_polygon_xy(nozzle_patch)))
+
+        # Motor-region outline. `_generate_motor_region` reads patch.xy
+        # arrays, so we rebuild matplotlib Polygons once from our
+        # coordinate copies. Any failure here is logged and dropped; the
+        # outline is advisory, not load-bearing.
+        try:
+            mpl_patches = [_rebuild_polygon(p.x, p.y) for p in patches]
+            outline_patch = motor.plots._generate_motor_region(
+                list_of_patches=mpl_patches
+            )
+            patches.insert(
+                0, MotorPatch(role="outline", **_polygon_xy(outline_patch))
+            )
+        except Exception as exc:  # pragma: no cover - defensive
+            logger.warning("Failed to generate motor outline patch: %s", exc)
+
+        return (
+            MotorDrawingGeometry(
+                type=motor_type,
+                position=float(motor_position),
+                nozzle_position=float(nozzle_position),
+                grains_center_of_mass_position=(
+                    float(grains_cm_position)
+                    if grains_cm_position is not None
+                    else None
+                ),
+                patches=patches,
+            ),
+            float(nozzle_position),
+        )
+
+
+def _compute_motor_bounds(
+    motor: MotorDrawingGeometry, radius: float
+) -> DrawingBounds:
+    """Compute a tight bounding box for a motor-only drawing payload.
+
+    Mirrors the rocket-side bounds helper but limited to motor patches —
+    callers who want rocket-wide bounds use the rocket service's own
+    computation.
+    """
+    xs: list[float] = []
+    ys: list[float] = []
+    for patch in motor.patches:
+        xs += patch.x
+        ys += patch.y
+    if not xs:
+        xs = [float(motor.position)]
+    if not ys:
+        ys = [-float(radius), float(radius)]
+    return DrawingBounds(
+        x_min=float(min(xs)),
+        x_max=float(max(xs)),
+        y_min=float(min(ys)),
+        y_max=float(max(ys)),
+    )