Merge pull request #612 from RocketPy-Team/enh/show-variables-monte-carlo

ENH: Adds StochasticModel.visualize_attributes() method

Author: Gui-FernandesBR

CHANGELOG.md

@@ -41,6 +41,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Changed
 
+- ENH: Adds StochasticModel.visualize_attributes() method [#612](https://github.com/RocketPy-Team/RocketPy/pull/612)
 - DOC: Monte carlo documentation updates [#607](https://github.com/RocketPy-Team/RocketPy/pull/607)
 - MNT: refactor u_dot parachute method [#596](https://github.com/RocketPy-Team/RocketPy/pull/596)
 - BLD: Change setup.py to pyproject.toml [#589](https://github.com/RocketPy-Team/RocketPy/pull/589)

docs/notebooks/monte_carlo_analysis/monte_carlo_analysis_outputs/monte_carlo_class_example.inputs.txt

@@ -1,4 +1,5 @@
 import matplotlib.pyplot as plt
+
 from ..tools import generate_monte_carlo_ellipses
 
 

docs/notebooks/monte_carlo_analysis/monte_carlo_analysis_outputs/monte_carlo_class_example.kml

@@ -87,28 +87,6 @@ def __init__(
         )
         self._validate_ensemble(ensemble_member, environment)
 
-    def __str__(self):
-        # special str for environment because of datetime
-        s = ""
-        for key, value in self.__dict__.items():
-            if key.startswith("_"):
-                continue  # Skip attributes starting with underscore
-            if isinstance(value, tuple):
-                try:
-                    # Format the tuple as a string with the mean and standard deviation.
-                    value_str = (
-                        f"{value[0]:.5f} ± {value[1]:.5f} "
-                        f"(numpy.random.{value[2].__name__})"
-                    )
-                except AttributeError:
-                    # treats date attribute
-                    value_str = str(value)
-            else:
-                # Otherwise, just use the default string representation of the value.
-                value_str = str(value)
-            s += f"{key}: {value_str}\n"
-        return s.strip()
-
     def _validate_ensemble(self, ensemble_member, environment):
         """Validates the ensemble member input argument. If the environment
         does not have ensemble members, the ensemble member input argument

docs/notebooks/monte_carlo_analysis/monte_carlo_analysis_outputs/monte_carlo_class_example.outputs.txt

@@ -89,28 +89,8 @@ def __init__(self, object, **kwargs):
                     attr_value = [getattr(self.object, input_name)]
                 setattr(self, input_name, attr_value)
 
-    def __str__(self):
-        """
-        Returns a string representation of the StochasticModel object.
-
-        Returns
-        -------
-        str
-            String containing the class attributes and their values.
-        """
-        s = ""
-        for key, value in self.__dict__.items():
-            if key.startswith("_"):
-                continue
-            if isinstance(value, tuple):
-                value_str = (
-                    f"{value[0]:.5f} ± {value[1]:.5f} "
-                    f"(numpy.random.{value[2].__name__})"
-                )
-            else:
-                value_str = str(value)
-            s += f"{key}: {value_str}\n"
-        return s.strip()
+    def __repr__(self):
+        return f"'{self.__class__.__name__}() object'"
 
     def _validate_tuple(self, input_name, input_value, getattr=getattr):
         """
@@ -492,3 +472,69 @@ def dict_generator(self):
                 generated_dict[arg] = choice(value) if value else value
         self.last_rnd_dict = generated_dict
         yield generated_dict
+
+    def visualize_attributes(self):
+        """
+        This method prints a report of the attributes stored in the Stochastic
+        Model object. The report includes the variable name, the nominal value,
+        the standard deviation, and the distribution function used to generate
+        the random attributes.
+        """
+
+        def format_attribute(attr, value):
+            if isinstance(value, list):
+                return (
+                    f"\t{attr.ljust(max_str_length)} {value[0]}"
+                    if len(value) == 1
+                    else f"\t{attr} {value}"
+                )
+            elif isinstance(value, tuple):
+                nominal_value, std_dev, dist_func = value
+                return (
+                    f"\t{attr.ljust(max_str_length)} "
+                    f"{nominal_value:.5f} ± "
+                    f"{std_dev:.5f} ({dist_func.__name__})"
+                )
+            return None
+
+        attributes = {k: v for k, v in self.__dict__.items() if not k.startswith("_")}
+        max_str_length = max(len(var) for var in attributes) + 2
+
+        report = [
+            f"Reporting the attributes of the `{self.__class__.__name__}` object:"
+        ]
+
+        # Sorting alphabetically makes the report more readable
+        items = attributes.items()
+        items = sorted(items, key=lambda x: x[0])
+
+        to_exclude = ["object", "last_rnd_dict", "exception_list", "parachutes"]
+        items = [item for item in items if item[0] not in to_exclude]
+
+        constant_attributes = [
+            attr for attr, val in items if isinstance(val, list) and len(val) == 1
+        ]
+        tuple_attributes = [attr for attr, val in items if isinstance(val, tuple)]
+        list_attributes = [
+            attr for attr, val in items if isinstance(val, list) and len(val) > 1
+        ]
+
+        if constant_attributes:
+            report.append("\nConstant Attributes:")
+            report.extend(
+                format_attribute(attr, attributes[attr]) for attr in constant_attributes
+            )
+
+        if tuple_attributes:
+            report.append("\nStochastic Attributes:")
+            report.extend(
+                format_attribute(attr, attributes[attr]) for attr in tuple_attributes
+            )
+
+        if list_attributes:
+            report.append("\nStochastic Attributes with choice of values:")
+            report.extend(
+                format_attribute(attr, attributes[attr]) for attr in list_attributes
+            )
+
+        print("\n".join(filter(None, report)))

docs/notebooks/monte_carlo_analysis/monte_carlo_class_usage.ipynb

@@ -83,17 +83,6 @@ def __init__(
             name=None,
         )
 
-    def __repr__(self):
-        return (
-            f"StochasticParachute("
-            f"parachute={self.object}, "
-            f"cd_s={self.cd_s}, "
-            f"trigger={self.trigger}, "
-            f"sampling_rate={self.sampling_rate}, "
-            f"lag={self.lag}, "
-            f"noise={self.noise})"
-        )
-
     def _validate_trigger(self, trigger):
         """Validates the trigger input. If the trigger input argument is not
         None, it must be:

rocketpy/plots/monte_carlo_plots.py

@@ -163,45 +163,6 @@ def __init__(
         self.rail_buttons = Components()
         self.parachutes = []
 
-    def __str__(self):
-        # special str for rocket because of the components and parachutes
-        s = ""
-        for key, value in self.__dict__.items():
-            if key.startswith("_"):
-                continue  # Skip attributes starting with underscore
-            if isinstance(value, tuple):
-                # Format the tuple as a string with the mean and standard deviation.
-                value_str = (
-                    f"{value[0]:.5f} ± {value[1]:.5f} "
-                    f"(numpy.random.{value[2].__name__})"
-                )
-                s += f"{key}: {value_str}\n"
-            elif isinstance(value, Components):
-                # Format Components as string with the mean and std deviation
-                s += f"{key}:\n"
-                if len(value) == 0:
-                    s += "\tNone\n"
-                for component in value:
-                    s += f"\t{component.component.__class__.__name__} "
-                    if isinstance(component.position, tuple):
-                        s += f"at position: {component.position[0]:.5f} ± "
-                        s += f"{component.position[1]:.5f} "
-                        s += f"(numpy.random.{component.position[2].__name__})\n"
-                    elif isinstance(component.position, list):
-                        s += f"at position: {component.position}\n"
-                    else:
-                        s += f"at position: {component.position:.5f}\n"
-            else:
-                # Otherwise, just use the default string representation of the value.
-                value_str = str(value)
-                if isinstance(value, list) and len(value) > 0:
-                    if isinstance(value[0], (StochasticParachute)):
-                        value_str = ""
-                        for parachute in value:
-                            value_str += f"\n\t{parachute.name[0]} "
-                s += f"{key}: {value_str}\n"
-        return s.strip()
-
     def add_motor(self, motor, position=None):
         """Adds a stochastic motor to the stochastic rocket. If a motor is
         already present, it will be replaced.

rocketpy/stochastic/stochastic_environment.py

@@ -0,0 +1,20 @@
+import pytest
+
+
+@pytest.mark.parametrize(
+    "fixture_name",
+    [
+        "stochastic_rail_buttons",
+        "stochastic_main_parachute",
+        "stochastic_environment",
+        "stochastic_tail",
+        "stochastic_calisto",
+    ],
+)
+def test_visualize_attributes(request, fixture_name):
+    """Tests the visualize_attributes method of the StochasticModel class. This
+    test verifies if the method returns None, which means that the method is
+    running without breaking.
+    """
+    fixture = request.getfixturevalue(fixture_name)
+    assert fixture.visualize_attributes() is None