Merge remote-tracking branch 'origin/feat/flight-binary-and-notebook-export' into drop-22apr

Author: aasitvora99

requirements.txt

@@ -1,5 +1,6 @@
 dill
 python-dotenv
+python-multipart
 fastapi
 uvloop
 pydantic

src/controllers/flight.py

@@ -4,12 +4,13 @@
     ControllerBase,
     controller_exception_handler,
 )
-from src.views.flight import FlightSimulation, FlightCreated
+from src.views.flight import FlightSimulation, FlightCreated, FlightImported
 from src.models.flight import (
     FlightModel,
     FlightWithReferencesRequest,
 )
 from src.models.environment import EnvironmentModel
+from src.models.motor import MotorModel
 from src.models.rocket import RocketModel
 from src.repositories.interface import RepositoryInterface
 from src.services.flight import FlightService
@@ -22,6 +23,7 @@ class FlightController(ControllerBase):
     Enables:
         - Simulation of a RocketPy Flight.
         - CRUD for Flight BaseApiModel.
+        - Import/export as portable .rpy files and Jupyter notebooks.
     """
 
     def __init__(self):
@@ -122,25 +124,26 @@ async def update_rocket_by_flight_id(
         return
 
     @controller_exception_handler
-    async def get_rocketpy_flight_binary(
+    async def get_rocketpy_flight_rpy(
         self,
         flight_id: str,
     ) -> bytes:
         """
-        Get rocketpy.flight as dill binary.
+        Get rocketpy.flight as a portable ``.rpy`` JSON file.
 
         Args:
             flight_id: str
 
         Returns:
-            bytes
+            bytes (UTF-8 encoded JSON)
 
         Raises:
-            HTTP 404 Not Found: If the flight is not found in the database.
+            HTTP 404 Not Found: If the flight is not found
+                in the database.
         """
         flight = await self.get_flight_by_id(flight_id)
         flight_service = FlightService.from_flight_model(flight.flight)
-        return flight_service.get_flight_binary()
+        return flight_service.get_flight_rpy()
 
     @controller_exception_handler
     async def get_flight_simulation(
@@ -162,3 +165,71 @@ async def get_flight_simulation(
         flight = await self.get_flight_by_id(flight_id)
         flight_service = FlightService.from_flight_model(flight.flight)
         return flight_service.get_flight_simulation()
+
+    async def _persist_model(self, model_cls, model_instance) -> str:
+        repo_cls = RepositoryInterface.get_model_repo(model_cls)
+        async with repo_cls() as repo:
+            creator = getattr(repo, f"create_{model_cls.NAME}")
+            return await creator(model_instance)
+
+    @controller_exception_handler
+    async def import_flight_from_rpy(
+        self,
+        content: bytes,
+    ) -> FlightImported:
+        """
+        Import a ``.rpy`` JSON file: decompose the RocketPy Flight
+        into Environment, Motor, Rocket and Flight models, persist
+        each one via the normal CRUD pipeline, and return all IDs.
+
+        Args:
+            content: raw bytes of a ``.rpy`` JSON file.
+
+        Returns:
+            FlightImported with environment_id, motor_id,
+            rocket_id, and flight_id.
+
+        Raises:
+            HTTP 422: If the file is not a valid ``.rpy`` Flight.
+        """
+        try:
+            flight_service = FlightService.from_rpy(content)
+        except Exception as exc:
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=f"Invalid .rpy file: {exc}",
+            ) from exc
+
+        env, motor, rocket, flight = flight_service.extract_models()
+
+        env_id = await self._persist_model(EnvironmentModel, env)
+        motor_id = await self._persist_model(MotorModel, motor)
+        rocket_id = await self._persist_model(RocketModel, rocket)
+        flight_id = await self._persist_model(FlightModel, flight)
+
+        return FlightImported(
+            flight_id=flight_id,
+            rocket_id=rocket_id,
+            motor_id=motor_id,
+            environment_id=env_id,
+        )
+
+    @controller_exception_handler
+    async def get_flight_notebook(
+        self,
+        flight_id: str,
+    ) -> dict:
+        """
+        Generate a Jupyter notebook for a persisted flight.
+
+        Args:
+            flight_id: str
+
+        Returns:
+            dict representing a valid .ipynb.
+
+        Raises:
+            HTTP 404 Not Found: If the flight does not exist.
+        """
+        await self.get_flight_by_id(flight_id)
+        return FlightService.generate_notebook(flight_id)

src/routes/flight.py

@@ -2,13 +2,23 @@
 Flight routes with dependency injection for improved performance.
 """
 
-from fastapi import APIRouter, Response
+import json
+
+from fastapi import (
+    APIRouter,
+    File,
+    HTTPException,
+    Response,
+    UploadFile,
+    status,
+)
 from opentelemetry import trace
 
 from src.views.flight import (
     FlightSimulation,
     FlightCreated,
     FlightRetrieved,
+    FlightImported,
 )
 from src.models.environment import EnvironmentModel
 from src.models.flight import FlightModel, FlightWithReferencesRequest
@@ -27,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(
@@ -77,6 +89,7 @@ async def read_flight(
         return await controller.get_flight_by_id(flight_id)
 
 
+
 @router.put("/{flight_id}", status_code=204)
 async def update_flight(
     flight_id: str,
@@ -138,33 +151,38 @@ async def delete_flight(
     "/{flight_id}/rocketpy",
     responses={
         200: {
-            "description": "Binary file download",
-            "content": {"application/octet-stream": {}},
+            "description": "Portable .rpy JSON file download",
+            "content": {"application/json": {}},
         }
     },
     status_code=200,
     response_class=Response,
 )
+
 async def get_rocketpy_flight_binary(
     flight_id: str,
     controller: FlightControllerDep,
 ):
     """
-    Loads rocketpy.flight as a dill binary.
-    Currently only amd64 architecture is supported.
+    Export a flight as a Jupyter notebook (.ipynb).
+
+    The notebook loads the flight's ``.rpy`` file and calls
+    ``flight.all_info()`` for interactive exploration.
 
     ## Args
     ``` flight_id: str ```
     """
-    with tracer.start_as_current_span("get_rocketpy_flight_binary"):
+    with tracer.start_as_current_span("get_flight_notebook"):
+        notebook = await controller.get_flight_notebook(flight_id)
+        content = json.dumps(notebook, indent=1).encode()
+        filename = f"flight_{flight_id}.ipynb"
         headers = {
-            'Content-Disposition': f'attachment; filename="rocketpy_flight_{flight_id}.dill"'
+            "Content-Disposition": (f'attachment; filename="{filename}"'),
         }
-        binary = await controller.get_rocketpy_flight_binary(flight_id)
         return Response(
-            content=binary,
+            content=content,
             headers=headers,
-            media_type="application/octet-stream",
+            media_type="application/x-ipynb+json",
             status_code=200,
         )