some annotation

abc.py

@@ -3,23 +3,30 @@ from collections.abc import Iterable
 from pathlib import Path, PosixPath
 from typing import Union
 from copy import copy
-
 from yaml import dump, safe_load
 
 
 class ParametersABC(ABC):
     """
-    Base class to add yaml functionality to parameters
-
+    Defines parameters as attributes and allows parameters to
+    be converted to either a dictionary or to yaml.
     """
 
     def __init__(self, **kwargs):
+        '''
+        Defines parameters as attributes
+        '''
         for k, v in kwargs.items():
             setattr(self, k, v)
 
+    ###
+
     def to_dict(self, iterable="null"):
         """
-        Recursive function that converts class to nested dictionary.
+        Recursive function that converts class to nested dictionary
+
+        Recursive function to return a dictionary version of the attributes
+        of the class instance.
         """
         if isinstance(iterable, dict):
             if any(
@@ -35,35 +42,40 @@ class ParametersABC(ABC):
                 }
             return iterable
         elif iterable == "null":
+            # use instance's built-in __dict__ dictionary of attributes
             return self.to_dict(self.__dict__)
         else:
             return iterable
 
-    @classmethod
-    def from_dict(cls, d: dict):
-        return cls(**d)
 
     def to_yaml(self, path: Union[PosixPath, str] = None):
-        """Return instance as yaml stream and optionally export to file.
+        """
+        Return instance as a yaml stream and optionally exports to file.
 
-        Returns the yaml version of the class instance. If path is provided, it
-        is saved there as well.
+        Returns the yaml version of the attributes of the class instance.
+        If path is provided, the yaml version is saved there.
 
         Parameters
         ----------
         path : Union[PosixPath, str]
             Output path.
-
         """
-
         if path:
             with open(Path(path), "w") as f:
                 dump(self.to_dict(), f)
         return dump(self.to_dict())
 
+    ###
+
+    @classmethod
+    def from_dict(cls, d: dict):
+        return cls(**d)
+
     @classmethod
     def from_yaml(cls, source: Union[PosixPath, str]):
-        """Returns class from a yaml filename or stdin"""
+        """
+        Returns class from a yaml filename or stdin
+        """
         is_buffer = True
         try:
             if Path(source).exists():
@@ -75,26 +87,32 @@ class ParametersABC(ABC):
         else:
             with open(source) as f:
                 params = safe_load(f)
-
         return cls(**params)
 
     @classmethod
     def default(cls, **kwargs):
         overriden_defaults = copy(cls._defaults)
-
         for k, v in kwargs.items():
             overriden_defaults[k] = v
-
         return cls.from_dict(overriden_defaults)
 
+###
 
 class ProcessABC(ABC):
-    """Base class for processes"""
-
+    """
+    Base class for processes.
+    Defines parameters as instances and requires run method to be defined.
+    """
     def __init__(self, parameters):
+        """
+        Arguments
+        ---------
+        parameters: instance of ParametersABC
+        """
         self._parameters = parameters
-
-        for k, v in parameters.to_dict().items():  # access parameters directly
+        # convert parameters to dictionary
+        # and then define each parameter as an attribute
+        for k, v in parameters.to_dict().items():
             setattr(self, k, v)
 
     @property