Improve load_from_thrustcurve_api and test_load_from_thrustcurve_api with clean imports

Author: Monta120

rocketpy/motors/motor.py

@@ -5,16 +5,18 @@
 import xml.etree.ElementTree as ET
 from abc import ABC, abstractmethod
 from functools import cached_property
-from os import path
+from os import path, remove
 
 import numpy as np
 import requests
-
+import logging
 from ..mathutils.function import Function, funcify_method
 from ..plots.motor_plots import _MotorPlots
 from ..prints.motor_prints import _MotorPrints
 from ..tools import parallel_axis_theorem_from_com, tuple_handler
 
+logger = logging.getLogger(__name__)
+
 
 # pylint: disable=too-many-public-methods
 class Motor(ABC):
@@ -1916,7 +1918,7 @@ def load_from_rse_file(
             interpolation_method=interpolation_method,
             coordinate_system_orientation=coordinate_system_orientation,
         )
-
+    
     @staticmethod
     def load_from_thrustcurve_api(name: str, **kwargs):
         """
@@ -1926,16 +1928,25 @@ def load_from_thrustcurve_api(name: str, **kwargs):
         Parameters
         ----------
         name : str
-            The motor name according to the API (e.g., "Cesaroni_M1670").
+            The motor name according to the API (e.g., "Cesaroni_M1670" or "M1670").
+            Both manufacturer-prefixed and shorthand names are commonly used; if multiple
+            motors match the search, the first result is used.
         **kwargs :
-            Additional arguments passed to the Motor constructor, such as dry_mass, nozzle_radius, etc.
+            Additional arguments passed to the Motor constructor or loader, such as
+            dry_mass, nozzle_radius, etc.
 
         Returns
         -------
-        instance : cls
-            A new Motor instance initialized using the downloaded .eng file.
+        instance : GenericMotor
+            A new GenericMotor instance initialized using the downloaded .eng file.
+
+        Raises
+        ------
+        ValueError
+            If no motor is found or if the downloaded .eng data is missing.
+        requests.exceptions.RequestException
+            If a network or HTTP error occurs during the API call.
         """
-
         base_url = "https://www.thrustcurve.org/api/v1"
 
         # Step 1. Search motor
@@ -1944,34 +1955,55 @@ def load_from_thrustcurve_api(name: str, **kwargs):
         data = response.json()
 
         if not data.get("results"):
-            print("No motor found.")
-            return None
+            raise ValueError(
+                f"No motor found for name '{name}'. "
+                "Please verify the motor name format (e.g., 'Cesaroni_M1670' or 'M1670') and try again."
+            )
 
-        motor = data["results"][0]
-        motor_id = motor["motorId"]
-        designation = motor["designation"].replace("/", "-")
-        print(f"Motor found: {designation} ({motor['manufacturer']})")
+        motor_info = data["results"][0]
+        motor_id = motor_info.get("motorId")
+        designation = motor_info.get("designation", "").replace("/", "-")
+        manufacturer = motor_info.get("manufacturer", "")
+        # Logging the fact that the motor was found 
+        logger.info(f"Motor found: {designation} ({manufacturer})")
 
         # Step 2. Download the .eng file
         dl_response = requests.get(
             f"{base_url}/download.json",
             params={"motorIds": motor_id, "format": "RASP", "data": "file"},
         )
         dl_response.raise_for_status()
-        data = dl_response.json()
+        dl_data = dl_response.json()
 
-        data_base64 = data["results"][0]["data"]
-        data_bytes = base64.b64decode(data_base64)
-
-        # Step 3. Create the motor from the .eng file
+        if not dl_data.get("results"):
+            raise ValueError(f"No .eng file found for motor '{name}' in the ThrustCurve API.")
 
-        with tempfile.NamedTemporaryFile(suffix=".eng", delete=True) as tmp_file:
-            tmp_file.write(data_bytes)
-            tmp_file.flush()
+        data_base64 = dl_data["results"][0].get("data")
+        if not data_base64:
+            raise ValueError(f"Downloaded .eng data for motor '{name}' is empty or invalid.")
 
-            motor = GenericMotor.load_from_eng_file(tmp_file.name, **kwargs)
+        data_bytes = base64.b64decode(data_base64)
 
-        return motor
+        # Step 3. Create the motor from the .eng file
+        tmp_path = None
+        try:
+            # create a temporary file that persists until we explicitly remove it
+            with tempfile.NamedTemporaryFile(suffix=".eng", delete=False) as tmp_file:
+                tmp_file.write(data_bytes)
+                tmp_file.flush()
+                tmp_path = tmp_file.name
+
+        
+            motor_instance = GenericMotor.load_from_eng_file(tmp_path, **kwargs)
+            return motor_instance
+        finally:
+            # Ensuring the temporary file is removed
+            if tmp_path and path.exists(tmp_path):
+                try:
+                    remove(tmp_path)
+                except OSError:
+                    # If cleanup fails, don't raise: we don't want to mask prior exceptions.
+                    pass
 
     def all_info(self):
         """Prints out all data and graphs available about the Motor."""

tests/unit/motors/test_genericmotor.py

@@ -1,6 +1,9 @@
 import numpy as np
 import pytest
 import scipy.integrate
+import requests
+import base64
+
 
 from rocketpy import Function, Motor
 
@@ -212,49 +215,87 @@ def test_load_from_rse_file(generic_motor):
     assert thrust_curve[-1][0] == 2.2  # Last point of time
     assert thrust_curve[-1][1] == 0.0  # Last thrust point
 
-
-def test_load_from_thrustcurve_api(generic_motor):
-    """Tests the GenericMotor.load_from_thrustcurve_api method.
-
+def test_load_from_thrustcurve_api(monkeypatch, generic_motor):
+    """
+    Tests the GenericMotor.load_from_thrustcurve_api method with mocked ThrustCurve API responses.
     Parameters
     ----------
+    monkeypatch : pytest.MonkeyPatch
+        The pytest monkeypatch fixture for mocking.
     generic_motor : rocketpy.GenericMotor
         The GenericMotor object to be used in the tests.
+        
     """
-    # using cesaroni data as example
+
+    class MockResponse:
+        def __init__(self, json_data):
+            self._json_data = json_data
+
+        def json(self):
+            return self._json_data
+
+        def raise_for_status(self):
+            # Simulate a successful HTTP response (200)
+            return None
+
+    # Provide mocked responses for the two endpoints: search.json and download.json
+    def mock_get(url, params=None):
+        if "search.json" in url:
+            # Return a mock search result with a motorId and designation
+            return MockResponse(
+                {
+                    "results": [
+                        {
+                            "motorId": "12345",
+                            "designation": "Cesaroni_M1670",
+                            "manufacturer": "Cesaroni",
+                        }
+                    ]
+                }
+            )
+        elif "download.json" in url:
+            # Read the local .eng file and return its base64-encoded content as the API would
+            eng_path = "data/motors/cesaroni/Cesaroni_M1670.eng"
+            with open(eng_path, "rb") as f:
+                encoded = base64.b64encode(f.read()).decode("utf-8")
+            return MockResponse({"results": [{"data": encoded}]})
+        else:
+            raise RuntimeError(f"Unexpected URL called in test mock: {url}")
+
+    monkeypatch.setattr(requests, "get", mock_get)
+
+    # Expected parameters from the original test
     burn_time = (0, 3.9)
     dry_mass = 5.231 - 3.101  # 2.130 kg
     propellant_initial_mass = 3.101
     chamber_radius = 75 / 1000
     chamber_height = 757 / 1000
     nozzle_radius = chamber_radius * 0.85  # 85% of chamber radius
 
-    # Parameters from manual testing using the SolidMotor class as a reference
     average_thrust = 1545.218
     total_impulse = 6026.350
     max_thrust = 2200.0
     exhaust_velocity = 1943.357
 
-    # creating motor from .eng file
-    generic_motor = generic_motor.load_from_thrustcurve_api("M1670")
-
-    # testing relevant parameters
-    assert generic_motor.burn_time == burn_time
-    assert generic_motor.dry_mass == dry_mass
-    assert generic_motor.propellant_initial_mass == propellant_initial_mass
-    assert generic_motor.chamber_radius == chamber_radius
-    assert generic_motor.chamber_height == chamber_height
-    assert generic_motor.chamber_position == 0
-    assert generic_motor.average_thrust == pytest.approx(average_thrust)
-    assert generic_motor.total_impulse == pytest.approx(total_impulse)
-    assert generic_motor.exhaust_velocity.average(*burn_time) == pytest.approx(
-        exhaust_velocity
-    )
-    assert generic_motor.max_thrust == pytest.approx(max_thrust)
-    assert generic_motor.nozzle_radius == pytest.approx(nozzle_radius)
-
-    # testing thrust curve
+    # Call the method using the class (works if it's a staticmethod); using type(generic_motor)
+    # ensures test works if the method is invoked on a GenericMotor instance in the project
+    motor = type(generic_motor).load_from_thrustcurve_api("M1670")
+
+    # Assertions (same as original)
+    assert motor.burn_time == burn_time
+    assert motor.dry_mass == dry_mass
+    assert motor.propellant_initial_mass == propellant_initial_mass
+    assert motor.chamber_radius == chamber_radius
+    assert motor.chamber_height == chamber_height
+    assert motor.chamber_position == 0
+    assert motor.average_thrust == pytest.approx(average_thrust)
+    assert motor.total_impulse == pytest.approx(total_impulse)
+    assert motor.exhaust_velocity.average(*burn_time) == pytest.approx(exhaust_velocity)
+    assert motor.max_thrust == pytest.approx(max_thrust)
+    assert motor.nozzle_radius == pytest.approx(nozzle_radius)
+
+    # testing thrust curve equality against the local .eng import (as in original test)
     _, _, points = Motor.import_eng("data/motors/cesaroni/Cesaroni_M1670.eng")
-    assert generic_motor.thrust.y_array == pytest.approx(
+    assert motor.thrust.y_array == pytest.approx(
         Function(points, "Time (s)", "Thrust (N)", "linear", "zero").y_array
     )