[#323] Restructure dyn and fsw model inheritance

Author: Mark2000

docs/source/release_notes.rst

@@ -20,18 +20,19 @@ Development - |version|
 * Allow flight software and dynamics models to be specified as lists of classes. This allows
   for multiple inheritance to be used for easily creating more complex satellite models.
 * The inheritance structure of flight software and dynamics models has changed. Most models
-  now inherit from :class:`~bsk_rl.sim.fsw.BaseFSWModel` or :class:`~bsk_rl.sim.dyn.BaseDynModel`
-  instead of :class:`~bsk_rl.sim.fsw.BasicFSWModel` or :class:`~bsk_rl.sim.dyn.BasicDynModel`.
-  These are lighter-weight base classes that lack some functionality that was not always
-  wanted.
+  now inherit from :class:`~bsk_rl.sim.fsw.FSWModel` or :class:`~bsk_rl.sim.dyn.DynModel`, 
+  which are instantiable versions of the abstract bases :class:`~bsk_rl.sim.fsw.FSWModelABC` and
+  :class:`~bsk_rl.sim.dyn.DynModelABC`, instead of from :class:`~bsk_rl.sim.fsw.BasicFSWModel` 
+  or :class:`~bsk_rl.sim.dyn.BasicDynModel`. These are lighter-weight base classes that lack
+  some functionality that was not always wanted.
 
   .. warning::
 
     If your custom satellite configurations break as a result of this change, add 
     :class:`~bsk_rl.sim.fsw.BasicFSWModel` and :class:`~bsk_rl.sim.dyn.BasicDynModel`
     to your ``fsw_type`` and ``dyn_type`` lists in your satellite classes.
 
-* :class:`~bsk_rl.sim.fsw.BaseFSWModel` implements direct actuator-less attitude control.
+* :class:`~bsk_rl.sim.fsw.FSWModel` implements direct actuator-less attitude control.
   By inheriting from a FSW class that overrides the ``MRPControlTask``, such as
   :class:`~bsk_rl.sim.fsw.BasicFSWModel` or :class:`~bsk_rl.sim.fsw.SteeringFSWModel`,
   users can implement custom attitude control strategies.

examples/rso_inspection.ipynb

@@ -76,7 +76,7 @@
     "    ]\n",
     "    action_spec = [act.NadirPoint(duration=1e9)]\n",
     "    dyn_type = (dyn.ConjunctionDynModel, dyn.RSODynModel)\n",
-    "    fsw_type = fsw.BaseFSWModel\n"
+    "    fsw_type = fsw.FSWModel\n"
    ]
   },
   {

src/bsk_rl/act/__init__.py

@@ -24,7 +24,7 @@ class MyActionSatellite(Satellite):
 +----------------------------+---------+-------------------------------------------------------------------------------------------------------+
 | **Action**                 |**Count**| **Description**                                                                                       |
 +----------------------------+---------+-------------------------------------------------------------------------------------------------------+
-| :class:`DiscreteFSWAction` | 1       | Call an arbitrary ``@action`` decorated function in the :class:`~bsk_rl.sim.fsw.FSWModel`.            |
+| :class:`DiscreteFSWAction` | 1       | Call an arbitrary ``@action`` decorated function in the :class:`~bsk_rl.sim.fsw.FSWModelABC`.            |
 +----------------------------+---------+-------------------------------------------------------------------------------------------------------+
 | :class:`Charge`            | 1       | Point the solar panels at the sun.                                                                    |
 +----------------------------+---------+-------------------------------------------------------------------------------------------------------+

src/bsk_rl/act/discrete_actions.py

@@ -120,7 +120,7 @@ def __init__(
     ):
         """Discrete action to task a flight software action function.
 
-        This action executes a function of a :class:`~bsk_rl.sim.fsw.FSWModel`
+        This action executes a function of a :class:`~bsk_rl.sim.fsw.FSWModelABC`
         instance that takes no arguments, typically decorated with ``@action``.
 
         Args:

src/bsk_rl/gym.py

@@ -17,7 +17,7 @@
 from bsk_rl.sats import Satellite
 from bsk_rl.scene import Scenario
 from bsk_rl.sim import Simulator
-from bsk_rl.sim.world import BaseWorldModel, WorldModel
+from bsk_rl.sim.world import WorldModel, WorldModelABC
 from bsk_rl.utils import functional, logging_config, vizard
 
 logger = logging.getLogger(__name__)
@@ -57,7 +57,7 @@ def __init__(
         scenario: Optional[Scenario] = None,
         rewarder: Optional[Union[GlobalReward, list[GlobalReward]]] = None,
         world_type: Optional[
-            Union[type[WorldModel], tuple[type[WorldModel], ...]]
+            Union[type[WorldModelABC], tuple[type[WorldModelABC], ...]]
         ] = None,
         world_args: Optional[dict[str, Any]] = None,
         communicator: Optional[CommunicationMethod] = None,
@@ -99,7 +99,7 @@ def __init__(
                 be a function that takes a list of satellites and returns a dictionary that
                 maps satellites to dictionaries of satellite model arguments to be overridden.
             world_type: Type or tuple of types of Basilisk world model to be constructed.
-            world_args: Arguments for :class:`~bsk_rl.sim.world.WorldModel` construction.
+            world_args: Arguments for :class:`~bsk_rl.sim.world.WorldModelABC` construction.
                 Should be in the form of a dictionary with keys corresponding to the
                 arguments of the constructor and values that are either the desired value
                 or a function that takes no arguments and returns a randomized value.
@@ -184,7 +184,9 @@ def __init__(
             )
             if not isinstance(world_type, (list, tuple)):
                 world_type = (world_type,)
-            world_type = functional.compose_types(*world_type, WorldModel, name="World")
+            world_type = functional.compose_types(
+                *world_type, WorldModelABC, name="World"
+            )
         self.world_type = world_type
         if world_args is None:
             world_args = self.world_type.default_world_args()
@@ -223,15 +225,15 @@ def __init__(
         self.render_mode = render_mode
         self.generate_obs_retasking_only = generate_obs_retasking_only
 
-    def _minimum_world_model(self) -> type[WorldModel]:
+    def _minimum_world_model(self) -> type[WorldModelABC]:
         """Determine the minimum world model required by the satellites."""
         world_types = set(
             sum(
                 [satellite.dyn_type._requires_world() for satellite in self.satellites],
                 [],
             )
         )
-        return functional.compose_types(*world_types, BaseWorldModel, name="World")
+        return functional.compose_types(*world_types, WorldModel, name="World")
 
     def get_satellite(self, name: str) -> "Satellite":
         """Get a satellite by name.

src/bsk_rl/sats/satellite.py

@@ -40,9 +40,9 @@ class Satellite(ABC, Resetable):
     """Abstract base class for satellites."""
 
     dyn_type: Union[
-        type["dyn.DynamicsModel"], tuple[type["dyn.DynamicsModel"], ...]
+        type["dyn.DynamicsModelABC"], tuple[type["dyn.DynamicsModelABC"], ...]
     ] = AbstractClassProperty()
-    fsw_type: Union[type["fsw.FSWModel"], tuple[type["fsw.FSWModel"], ...]] = (
+    fsw_type: Union[type["fsw.FSWModelABC"], tuple[type["fsw.FSWModelABC"], ...]] = (
         AbstractClassProperty()
     )
     observation_spec: list["Observation"] = AbstractClassProperty()
@@ -51,7 +51,7 @@ class Satellite(ABC, Resetable):
     _dyn_type = None
 
     @classmethod
-    def get_dyn_type(cls) -> type["dyn.DynamicsModel"]:
+    def get_dyn_type(cls) -> type["dyn.DynamicsModelABC"]:
         """Get the dynamics model type for the satellite.
 
         This should be used in class methods instead of referencing ``dyn_type``. In
@@ -65,13 +65,13 @@ def get_dyn_type(cls) -> type["dyn.DynamicsModel"]:
                 dyn_types = cls.dyn_type
             else:
                 dyn_types = (cls.dyn_type,)
-            cls._dyn_type = compose_types(*dyn_types, dyn.BaseDynamicsModel, name="Dyn")
+            cls._dyn_type = compose_types(*dyn_types, dyn.DynamicsModel, name="Dyn")
         return cls._dyn_type
 
     _fsw_type = None
 
     @classmethod
-    def get_fsw_type(cls) -> type["fsw.FSWModel"]:
+    def get_fsw_type(cls) -> type["fsw.FSWModelABC"]:
         """Get the flight software model type for the satellite.
 
         This should be used in class methods instead of referencing ``fsw_type``. In
@@ -85,12 +85,12 @@ def get_fsw_type(cls) -> type["fsw.FSWModel"]:
                 fsw_types = cls.fsw_type
             else:
                 fsw_types = (cls.fsw_type,)
-            cls._fsw_type = compose_types(*fsw_types, fsw.BaseFSWModel, name="FSW")
+            cls._fsw_type = compose_types(*fsw_types, fsw.FSWModel, name="FSW")
         return cls._fsw_type
 
     @classmethod
     def default_sat_args(cls, **kwargs) -> dict[str, Any]:
-        """Compile default arguments for :class:`~bsk_rl.sim.dyn.DynamicsModel` and :class:`~bsk_rl.sim.fsw.FSWModel`, replacing those specified.
+        """Compile default arguments for :class:`~bsk_rl.sim.dyn.DynamicsModelABC` and :class:`~bsk_rl.sim.fsw.FSWModelABC`, replacing those specified.
 
         Args:
             **kwargs: Arguments to override in the default arguments.
@@ -129,8 +129,8 @@ def __init__(
 
         Args:
             name: Identifier for satellite; does not need to be unique.
-            sat_args: Arguments for :class:`~bsk_rl.sim.dyn.DynamicsModel` and
-                :class:`~bsk_rl.sim.fsw.FSWModel` construction. Should be in the form of
+            sat_args: Arguments for :class:`~bsk_rl.sim.dyn.DynamicsModelABC` and
+                :class:`~bsk_rl.sim.fsw.FSWModelABC` construction. Should be in the form of
                 a dictionary with keys corresponding to the arguments of the constructor
                 and values that are either the desired value or a function that takes no
                 arguments and returns a randomized value.
@@ -147,8 +147,8 @@ def __init__(
             sat_args = self.default_sat_args()
         self.sat_args_generator = self.default_sat_args(**sat_args)
         self.simulator: "Simulator"
-        self.fsw: "fsw.FSWModel"
-        self.dynamics: "dyn.DynamicsModel"
+        self.fsw: "fsw.FSWModelABC"
+        self.dynamics: "dyn.DynamicsModelABC"
         self.data_store: "DataStore"
         self.requires_retasking: bool
         self.variable_interval = variable_interval
@@ -228,7 +228,7 @@ def set_simulator(self, simulator: "Simulator"):
         """
         self.simulator = proxy(simulator)
 
-    def set_dynamics(self, dyn_rate: float) -> "dyn.DynamicsModel":
+    def set_dynamics(self, dyn_rate: float) -> "dyn.DynamicsModelABC":
         """Create dynamics model; called during simulator initialization.
 
         Args:
@@ -243,7 +243,7 @@ def set_dynamics(self, dyn_rate: float) -> "dyn.DynamicsModel":
         self.dynamics = proxy(dynamics)
         return dynamics
 
-    def set_fsw(self, fsw_rate: float) -> "fsw.FSWModel":
+    def set_fsw(self, fsw_rate: float) -> "fsw.FSWModelABC":
         """Create flight software model; called during simulator initialization.
 
         Args:

src/bsk_rl/sim/dyn/__init__.py

@@ -40,10 +40,10 @@
 
 from bsk_rl.sim.dyn.base import (
     AtmosphericDragDynModel,
-    BaseDynamicsModel,
     BasicDynamicsModel,
     DisturbanceTorqueDynModel,
     DynamicsModel,
+    DynamicsModelABC,
     EclipseDynModel,
 )
 from bsk_rl.sim.dyn.ground_imaging import (
@@ -72,8 +72,8 @@ def __init__(self, *args, **kwargs) -> None:
 
 __doc_title__ = "Dynamics Sims"
 __all__ = [
+    "DynamicsModelABC",
     "DynamicsModel",
-    "BaseDynamicsModel",
     "BasicDynamicsModel",
     "EclipseDynModel",
     "DisturbanceTorqueDynModel",

src/bsk_rl/sim/dyn/base.py

@@ -35,15 +35,15 @@
 if TYPE_CHECKING:  # pragma: no cover
     from bsk_rl.sats import Satellite
     from bsk_rl.sim import Simulator
-    from bsk_rl.sim.world import WorldModel
+    from bsk_rl.sim.world import WorldModelABC
 
 
-class DynamicsModel(ABC, Resetable):
+class DynamicsModelABC(ABC, Resetable):
     """Abstract Basilisk dynamics model."""
 
     @classmethod
-    def _requires_world(cls) -> list[type["WorldModel"]]:
-        """Define minimum :class:`~bsk_rl.sim.world.WorldModel` for compatibility."""
+    def _requires_world(cls) -> list[type["WorldModelABC"]]:
+        """Define minimum :class:`~bsk_rl.sim.world.WorldModelABC` for compatibility."""
         return []
 
     def __init__(
@@ -55,7 +55,7 @@ def __init__(
     ) -> None:
         """The abstract base dynamics model.
 
-        One DynamicsModel is instantiated for each satellite in the environment each
+        One DynamicsModelABC is instantiated for each satellite in the environment each
         time the environment is reset and new simulator is created.
 
         Args:
@@ -92,7 +92,7 @@ def simulator(self) -> "Simulator":
         return self.satellite.simulator
 
     @property
-    def world(self) -> "WorldModel":
+    def world(self) -> "WorldModelABC":
         """Reference to the episode world model."""
         return self.simulator.world
 
@@ -123,9 +123,9 @@ def __del__(self):
         self.logger.debug("Basilisk dynamics deleted")
 
 
-class BaseDynamicsModel(DynamicsModel):
+class DynamicsModel(DynamicsModelABC):
     @classmethod
-    def _requires_world(cls) -> list[type["WorldModel"]]:
+    def _requires_world(cls) -> list[type["WorldModelABC"]]:
         return []
 
     @property
@@ -344,7 +344,7 @@ def setup_spacecraft_hub(
         self.setup_gravity_bodies()
 
     def setup_gravity_bodies(self) -> None:
-        """Set up gravitational bodies from the :class:`~bsk_rl.sim.world.WorldModel` to included in the simulation."""
+        """Set up gravitational bodies from the :class:`~bsk_rl.sim.world.WorldModelABC` to included in the simulation."""
         self.scObject.gravField.gravBodies = spacecraft.GravBodyVector(
             list(self.world.gravFactory.gravBodies.values())
         )
@@ -372,15 +372,15 @@ def altitude_valid(self) -> bool:
         return np.linalg.norm(self.r_BN_N) > self.min_orbital_radius
 
 
-class EclipseDynModel(BaseDynamicsModel):
+class EclipseDynModel(DynamicsModel):
     """Dynamics model with eclipse checking."""
 
     def __init__(self, *args, **kwargs) -> None:
         """Dynamics model with eclipse checking."""
         super().__init__(*args, **kwargs)
 
     @classmethod
-    def _requires_world(cls) -> list[type["WorldModel"]]:
+    def _requires_world(cls) -> list[type["WorldModelABC"]]:
         return [
             world.EclipseWorldModel,
         ] + super()._requires_world()
@@ -395,7 +395,7 @@ def setup_eclipse_object(self) -> None:
         self.eclipse_index = len(self.world.eclipseObject.eclipseOutMsgs) - 1
 
 
-class DisturbanceTorqueDynModel(BaseDynamicsModel):
+class DisturbanceTorqueDynModel(DynamicsModel):
     """Dynamics model with constant disturbance torque."""
 
     def __init__(self, *args, **kwargs) -> None:
@@ -424,15 +424,15 @@ def setup_disturbance_torque(
         self.scObject.addDynamicEffector(self.extForceTorqueObject)
 
 
-class AtmosphericDragDynModel(BaseDynamicsModel):
+class AtmosphericDragDynModel(DynamicsModel):
     """Dynamics model with atmospheric drag."""
 
     def __init__(self, *args, **kwargs) -> None:
         """Dynamics model with atmospheric drag."""
         super().__init__(*args, **kwargs)
 
     @classmethod
-    def _requires_world(cls) -> list[type["WorldModel"]]:
+    def _requires_world(cls) -> list[type["WorldModelABC"]]:
         return [
             world.AtmosphereWorldModel,
         ] + super()._requires_world()
@@ -523,7 +523,7 @@ class BasicDynamicsModel(
     EclipseDynModel,
     DisturbanceTorqueDynModel,
     AtmosphericDragDynModel,
-    BaseDynamicsModel,
+    DynamicsModel,
 ):
     """Basic Dynamics model with minimum necessary Basilisk components."""
 
@@ -548,7 +548,7 @@ def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
 
     @classmethod
-    def _requires_world(cls) -> list[type["WorldModel"]]:
+    def _requires_world(cls) -> list[type["WorldModelABC"]]:
         return super()._requires_world()
 
     @property
@@ -810,8 +810,8 @@ def setup_reaction_wheel_power(
 __doc_title__ = "Dynamics Base"
 
 __all__ = [
+    "DynamicsModelABC",
     "DynamicsModel",
-    "BaseDynamicsModel",
     "BasicDynamicsModel",
     "EclipseDynModel",
     "DisturbanceTorqueDynModel",

src/bsk_rl/sim/dyn/ground_imaging.py

@@ -19,7 +19,7 @@
 from bsk_rl.utils.functional import aliveness_checker, default_args
 
 if TYPE_CHECKING:  # pragma: no cover
-    from bsk_rl.sim.world import WorldModel
+    from bsk_rl.sim.world import WorldModelABC
 
 
 class ImagingDynModel(BasicDynamicsModel):
@@ -419,7 +419,7 @@ def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
 
     @classmethod
-    def _requires_world(cls) -> list[type["WorldModel"]]:
+    def _requires_world(cls) -> list[type["WorldModelABC"]]:
         return super()._requires_world() + [world.GroundStationWorldModel]
 
     def _setup_dynamics_objects(self, **kwargs) -> None: