Format documentation.

Author: ebezzam

docs/source/conf.py

@@ -43,8 +43,14 @@
     "sphinx.ext.intersphinx",
     "sphinx.ext.autosummary",
     "sphinx.ext.autodoc",
+    "sphinx.ext.napoleon",
 ]
 
+autodoc_default_options = {
+    "members": True,
+}
+autodoc_typehints = "none"  # for cleaner sphinx output, don't show type hints
+
 intersphinx_mapping = {
     "python": ("https://docs.python.org/3/", None),
     "NumPy [latest]": ("https://docs.scipy.org/doc/numpy/", None),

docs/source/fftconvolve.rst

@@ -1,7 +1,49 @@
 FFT Convolve
 ============
 
-.. automodule:: pydevtips.fftconvolve
+.. GENERATE DOCUMENTATION FOR ALL CLASSES
+.. .. automodule:: pydevtips.fftconvolve
+..     :member-order: bysource
+..     :show-inheritance:
+..     :special-members: __init__, __call__
+
+
+.. GENERATE ONE AT A TIME WITH CUSTOM TEXT
+
+There are two classes in this module for performing convolution in the frequency domain with a fixed filter.
+
+.. autosummary::
+    pydevtips.fftconvolve.RFFTConvolve
+    pydevtips.fftconvolve.FFTConvolve
+
+Both inherit from the base class :class:`pydevtips.fftconvolve.FFTConvolveBase`, 
+overwriting the abstract methods: :func:`pydevtips.fftconvolve.FFTConvolveBase._compute_filter_frequency_response` and 
+:func:`pydevtips.fftconvolve.FFTConvolveBase.__call__`.
+
+RFFTConvolve
+------------
+
+.. autoclass:: pydevtips.fftconvolve.RFFTConvolve
+    :member-order: bysource
+    :show-inheritance:
+    :special-members: __init__, __call__
+
+FFTConvolve
+-----------
+
+.. autoclass:: pydevtips.fftconvolve.FFTConvolve
+    :member-order: bysource
+    :show-inheritance:
+    :special-members: __init__, __call__
+
+
+FFTConvolveBase
+---------------
+
+.. autoclass:: pydevtips.fftconvolve.FFTConvolveBase
+    :member-order: bysource
+    :show-inheritance:
     :members:
     :undoc-members:
-    :show-inheritance:
+    :special-members: __init__, __call__
+    :private-members: _compute_filter_frequency_response

pydevtips/fftconvolve.py

@@ -3,13 +3,15 @@
 
 
 class FFTConvolveBase:
-    """Base class for FFT convolve."""
+    """Abstract class for FFT convolve."""
 
     def __init__(self, filter, length) -> None:
         """
+        Base class for creating a convolver that uses the same filter.
+
         Parameters
         ----------
-        filter : np.ndarray
+        filter : :py:class:`~numpy.ndarray`
             Filter to convolve with. Must be real.
         length : int
             Length of the signal to convolve with.
@@ -22,22 +24,38 @@ def __init__(self, filter, length) -> None:
         self.filter_frequency_response = self._compute_filter_frequency_response()
 
     @abstractmethod
-    def _compute_filter_frequency_response(self, filter) -> np.ndarray:
+    def _compute_filter_frequency_response(self) -> np.ndarray:
+        """
+        Compute the filter frequency response.
+
+        Parameters
+        ----------
+        filter : :py:class:`~numpy.ndarray`
+            Filter to compute the frequency response for.
+
+        Returns
+        -------
+        filter_frequency_response : :py:class:`~numpy.ndarray`
+            Filter frequency response.
+        """
         raise NotImplementedError
 
     @abstractmethod
     def __call__(self, signal) -> np.ndarray:
+        """Apply the filter to the signal, in the frequency domain."""
         pass
 
 
 class RFFTConvolve(FFTConvolveBase):
     """Real FFT convolve."""
 
     def __init__(self, filter, length) -> None:
-        """
+        r"""
+        Create convolver that uses a real-valued filter.
+
         Parameters
         ----------
-        filter : np.ndarray
+        filter : :py:class:`~numpy.ndarray`
             Filter to convolve with. Must be real.
         length : int
             Length of the signal to convolve with.
@@ -48,19 +66,21 @@ def __init__(self, filter, length) -> None:
         super(RFFTConvolve, self).__init__(filter, length)
 
     def _compute_filter_frequency_response(self):
-        """Compute the filter frequency response."""
+        r"""Compute the filter frequency response."""
         return np.fft.rfft(self.filter, n=self.pad_length)
 
     def __call__(self, signal) -> np.ndarray:
-        """
+        r"""
+        Apply the real-valued filter to the signal, in the frequency domain.
+
         Parameters
         ----------
-        signal : np.ndarray
+        signal : :py:class:`~numpy.ndarray`
             Signal to convolve with. Must be real.
 
         Returns
         -------
-        result : np.ndarray
+        result : :py:class:`~numpy.ndarray`
             Convolved signal.
         """
         signal_frequency_response = np.fft.rfft(signal, n=self.pad_length)
@@ -73,6 +93,16 @@ class FFTConvolve(FFTConvolveBase):
     """General FFT convolve."""
 
     def __init__(self, filter, length) -> None:
+        """
+        Create convolver that uses a fixed filter.
+
+        Parameters
+        ----------
+        filter : :py:class:`~numpy.ndarray`
+            Filter to convolve with. Must be real.
+        length : int
+            Length of the signal to convolve with.
+        """
         super(FFTConvolve, self).__init__(filter, length)
 
     def _compute_filter_frequency_response(self):
@@ -81,14 +111,16 @@ def _compute_filter_frequency_response(self):
 
     def __call__(self, signal) -> np.ndarray:
         """
+        Apply the filter to the signal, in the frequency domain.
+
         Parameters
         ----------
-        signal : np.ndarray
+        signal : :py:class:`~numpy.ndarray`
             Signal to convolve with.
 
         Returns
         -------
-        result : np.ndarray
+        result : :py:class:`~numpy.ndarray`
             Convolved signal.
         """
         signal_frequency_response = np.fft.fft(signal, n=self.pad_length)