diff --git a/CHANGELOG.md b/CHANGELOG.md
index 63c16c386..b644e3491 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -29,15 +29,16 @@
 ## Improvements
 * Use mixing tests for ecephy's mocks [PR #1136](https://github.com/catalystneuro/neuroconv/pull/1136)
 * Use pytest format for dandi tests to avoid window permission error on teardown [PR #1151](https://github.com/catalystneuro/neuroconv/pull/1151)
+* Added many docstrings for public functions [PR #1063](https://github.com/catalystneuro/neuroconv/pull/1063)
 
 # v0.6.5 (November 1, 2024)
 
-## Deprecations
-
 ## Bug Fixes
 * Fixed formatwise installation from pipy [PR #1118](https://github.com/catalystneuro/neuroconv/pull/1118)
 * Fixed dailies [PR #1113](https://github.com/catalystneuro/neuroconv/pull/1113)
 
+## Deprecations
+
 ## Features
 * Using in-house `GenericDataChunkIterator` [PR #1068](https://github.com/catalystneuro/neuroconv/pull/1068)
 * Data interfaces now perform source (argument inputs) validation with the json schema  [PR #1020](https://github.com/catalystneuro/neuroconv/pull/1020)
diff --git a/pyproject.toml b/pyproject.toml
index a4f391512..e318cc9c1 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -356,7 +356,7 @@ doctest_optionflags = "ELLIPSIS"
 
 [tool.black]
 line-length = 120
-target-version = ['py38', 'py39', 'py310']
+target-version = ['py39', 'py310']
 include = '\.pyi?$'
 extend-exclude = '''
 /(
diff --git a/src/neuroconv/basedatainterface.py b/src/neuroconv/basedatainterface.py
index 530eec60c..d9e9dc11e 100644
--- a/src/neuroconv/basedatainterface.py
+++ b/src/neuroconv/basedatainterface.py
@@ -36,7 +36,14 @@ class BaseDataInterface(ABC):
 
     @classmethod
     def get_source_schema(cls) -> dict:
-        """Infer the JSON schema for the source_data from the method signature (annotation typing)."""
+        """
+        Infer the JSON schema for the source_data from the method signature (annotation typing).
+
+        Returns
+        -------
+        dict
+            The JSON schema for the source_data.
+        """
         return get_json_schema_from_method_signature(cls, exclude=["source_data"])
 
     @classmethod
diff --git a/src/neuroconv/datainterfaces/behavior/lightningpose/lightningposeconverter.py b/src/neuroconv/datainterfaces/behavior/lightningpose/lightningposeconverter.py
index 505aa144d..62edaf140 100644
--- a/src/neuroconv/datainterfaces/behavior/lightningpose/lightningposeconverter.py
+++ b/src/neuroconv/datainterfaces/behavior/lightningpose/lightningposeconverter.py
@@ -111,6 +111,28 @@ def add_to_nwbfile(
         starting_frames_labeled_videos: Optional[list[int]] = None,
         stub_test: bool = False,
     ):
+        """
+        Add behavior and pose estimation data, including original and labeled videos, to the specified NWBFile.
+
+        Parameters
+        ----------
+        nwbfile : NWBFile
+            The NWBFile object to which the data will be added.
+        metadata : dict
+            Metadata dictionary containing information about the behavior and videos.
+        reference_frame : str, optional
+            Description of the reference frame for pose estimation, by default None.
+        confidence_definition : str, optional
+            Definition for the confidence levels in pose estimation, by default None.
+        external_mode : bool, optional
+            If True, the videos will be referenced externally rather than embedded within the NWB file, by default True.
+        starting_frames_original_videos : list of int, optional
+            List of starting frames for the original videos, by default None.
+        starting_frames_labeled_videos : list of int, optional
+            List of starting frames for the labeled videos, by default None.
+        stub_test : bool, optional
+            If True, only a subset of the data will be added for testing purposes, by default False.
+        """
         original_video_interface = self.data_interface_objects["OriginalVideo"]
 
         original_video_metadata = next(
@@ -172,6 +194,33 @@ def run_conversion(
         starting_frames_labeled_videos: Optional[list] = None,
         stub_test: bool = False,
     ) -> None:
+        """
+        Run the full conversion process, adding behavior, video, and pose estimation data to an NWB file.
+
+        Parameters
+        ----------
+        nwbfile_path : FilePath, optional
+            The file path where the NWB file will be saved. If None, the file is handled in memory.
+        nwbfile : NWBFile, optional
+            An in-memory NWBFile object. If None, a new NWBFile object will be created.
+        metadata : dict, optional
+            Metadata dictionary for describing the NWB file contents. If None, it is auto-generated.
+        overwrite : bool, optional
+            If True, overwrites the NWB file at `nwbfile_path` if it exists. If False, appends to the file, by default False.
+        reference_frame : str, optional
+            Description of the reference frame for pose estimation, by default None.
+        confidence_definition : str, optional
+            Definition for confidence levels in pose estimation, by default None.
+        external_mode : bool, optional
+            If True, the videos will be referenced externally rather than embedded within the NWB file, by default True.
+        starting_frames_original_videos : list of int, optional
+            List of starting frames for the original videos, by default None.
+        starting_frames_labeled_videos : list of int, optional
+            List of starting frames for the labeled videos, by default None.
+        stub_test : bool, optional
+            If True, only a subset of the data will be added for testing purposes, by default False.
+
+        """
         if metadata is None:
             metadata = self.get_metadata()
 
diff --git a/src/neuroconv/datainterfaces/behavior/medpc/medpcdatainterface.py b/src/neuroconv/datainterfaces/behavior/medpc/medpcdatainterface.py
index 09f9111d7..d519dc71a 100644
--- a/src/neuroconv/datainterfaces/behavior/medpc/medpcdatainterface.py
+++ b/src/neuroconv/datainterfaces/behavior/medpc/medpcdatainterface.py
@@ -187,6 +187,7 @@ def add_to_nwbfile(
         nwbfile: NWBFile,
         metadata: dict,
     ) -> None:
+
         ndx_events = get_package(package_name="ndx_events", installation_instructions="pip install ndx-events")
         medpc_name_to_info_dict = metadata["MedPC"].get("medpc_name_to_info_dict", None)
         assert medpc_name_to_info_dict is not None, "medpc_name_to_info_dict must be provided in metadata"
diff --git a/src/neuroconv/datainterfaces/ecephys/basesortingextractorinterface.py b/src/neuroconv/datainterfaces/ecephys/basesortingextractorinterface.py
index dca2dea5f..8eeb59324 100644
--- a/src/neuroconv/datainterfaces/ecephys/basesortingextractorinterface.py
+++ b/src/neuroconv/datainterfaces/ecephys/basesortingextractorinterface.py
@@ -220,6 +220,19 @@ def set_aligned_segment_starting_times(self, aligned_segment_starting_times: lis
                 sorting_segment._t_start = aligned_segment_starting_time
 
     def subset_sorting(self):
+        """
+        Generate a subset of the sorting extractor based on spike timing data.
+
+        This method identifies the earliest spike time across all units in the sorting extractor and creates a
+        subset of the sorting data up to 110% of the earliest spike time. If the sorting extractor is associated
+        with a recording, the subset is further limited by the total number of samples in the recording.
+
+        Returns
+        -------
+        SortingExtractor
+            A new `SortingExtractor` object representing the subset of the original sorting data,
+            sliced from the start frame to the calculated end frame.
+        """
         max_min_spike_time = max(
             [
                 min(x)
diff --git a/src/neuroconv/datainterfaces/ecephys/cellexplorer/cellexplorerdatainterface.py b/src/neuroconv/datainterfaces/ecephys/cellexplorer/cellexplorerdatainterface.py
index 46e825fb5..9ffeb78a2 100644
--- a/src/neuroconv/datainterfaces/ecephys/cellexplorer/cellexplorerdatainterface.py
+++ b/src/neuroconv/datainterfaces/ecephys/cellexplorer/cellexplorerdatainterface.py
@@ -518,6 +518,33 @@ def __init__(self, file_path: FilePath, verbose: bool = True):
                 )
 
     def generate_recording_with_channel_metadata(self):
+        """
+        Generate a dummy recording extractor with channel metadata from session data.
+
+        This method reads session data from a `.session.mat` file (if available) and generates a dummy recording
+        extractor. The recording extractor is then populated with channel metadata extracted from the session file.
+
+        Returns
+        -------
+        NumpyRecording
+            A `NumpyRecording` object representing the dummy recording extractor, containing the channel metadata.
+
+        Notes
+        -----
+        - The method reads the `.session.mat` file using `pymatreader` and extracts `extracellular` data.
+        - It creates a dummy recording extractor using `spikeinterface.core.numpyextractors.NumpyRecording`.
+        - The generated extractor includes channel IDs and other relevant metadata such as number of channels,
+        number of samples, and sampling frequency.
+        - Channel metadata is added to the dummy extractor using the `add_channel_metadata_to_recoder` function.
+        - If the `.session.mat` file is not found, no extractor is returned.
+
+        Warnings
+        --------
+        Ensure that the `.session.mat` file is correctly located in the expected session path, or the method will not generate
+        a recording extractor. The expected session is self.session_path / f"{self.session_id}.session.mat"
+
+        """
+
         session_data_file_path = self.session_path / f"{self.session_id}.session.mat"
         if session_data_file_path.is_file():
             from pymatreader import read_mat
diff --git a/src/neuroconv/datainterfaces/ophys/baseimagingextractorinterface.py b/src/neuroconv/datainterfaces/ophys/baseimagingextractorinterface.py
index 0019b8bd7..04407a3d4 100644
--- a/src/neuroconv/datainterfaces/ophys/baseimagingextractorinterface.py
+++ b/src/neuroconv/datainterfaces/ophys/baseimagingextractorinterface.py
@@ -47,6 +47,17 @@ def __init__(
     def get_metadata_schema(
         self,
     ) -> dict:
+        """
+        Retrieve the metadata schema for the optical physiology (Ophys) data, with optional handling of photon series type.
+
+        Parameters
+        ----------
+        photon_series_type : {"OnePhotonSeries", "TwoPhotonSeries"}, optional
+            The type of photon series to include in the schema. If None, the value from the instance is used.
+            This argument is deprecated and will be removed in a future version. Set `photon_series_type` during
+            the initialization of the `BaseImagingExtractorInterface` instance.
+
+        """
 
         metadata_schema = super().get_metadata_schema()
 
@@ -93,6 +104,16 @@ def get_metadata_schema(
     def get_metadata(
         self,
     ) -> DeepDict:
+        """
+        Retrieve the metadata for the imaging data, with optional handling of photon series type.
+
+        Parameters
+        ----------
+        photon_series_type : {"OnePhotonSeries", "TwoPhotonSeries"}, optional
+            The type of photon series to include in the metadata. If None, the value from the instance is used.
+            This argument is deprecated and will be removed in a future version. Instead, set `photon_series_type`
+            during the initialization of the `BaseImagingExtractorInterface` instance.
+        """
 
         from ...tools.roiextractors import get_nwb_imaging_metadata
 
diff --git a/src/neuroconv/datainterfaces/ophys/basesegmentationextractorinterface.py b/src/neuroconv/datainterfaces/ophys/basesegmentationextractorinterface.py
index 0f2e41bb9..66d35f57a 100644
--- a/src/neuroconv/datainterfaces/ophys/basesegmentationextractorinterface.py
+++ b/src/neuroconv/datainterfaces/ophys/basesegmentationextractorinterface.py
@@ -24,6 +24,27 @@ def __init__(self, verbose: bool = False, **source_data):
         self.segmentation_extractor = self.get_extractor()(**source_data)
 
     def get_metadata_schema(self) -> dict:
+        """
+        Generate the metadata schema for Ophys data, updating required fields and properties.
+
+        This method builds upon the base schema and customizes it for Ophys-specific metadata, including required
+        components such as devices, fluorescence data, imaging planes, and two-photon series. It also applies
+        temporary schema adjustments to handle certain use cases until a centralized metadata schema definition
+        is available.
+
+        Returns
+        -------
+        dict
+            A dictionary representing the updated Ophys metadata schema.
+
+        Notes
+        -----
+        - Ensures that `Device` and `ImageSegmentation` are marked as required.
+        - Updates various properties, including ensuring arrays for `ImagingPlane` and `TwoPhotonSeries`.
+        - Adjusts the schema for `Fluorescence`, including required fields and pattern properties.
+        - Adds schema definitions for `DfOverF`, segmentation images, and summary images.
+        - Applies temporary fixes, such as setting additional properties for `ImageSegmentation` to True.
+        """
         metadata_schema = super().get_metadata_schema()
         metadata_schema["required"] = ["Ophys"]
         metadata_schema["properties"]["Ophys"] = get_base_schema()
diff --git a/src/neuroconv/datainterfaces/ophys/brukertiff/brukertiffconverter.py b/src/neuroconv/datainterfaces/ophys/brukertiff/brukertiffconverter.py
index 2a67da720..1fc854b81 100644
--- a/src/neuroconv/datainterfaces/ophys/brukertiff/brukertiffconverter.py
+++ b/src/neuroconv/datainterfaces/ophys/brukertiff/brukertiffconverter.py
@@ -31,6 +31,7 @@ def get_source_schema(cls):
         return source_schema
 
     def get_conversion_options_schema(self):
+        """get the conversion options schema."""
         interface_name = list(self.data_interface_objects.keys())[0]
         return self.data_interface_objects[interface_name].get_conversion_options_schema()
 
@@ -91,6 +92,20 @@ def add_to_nwbfile(
         stub_test: bool = False,
         stub_frames: int = 100,
     ):
+        """
+        Add data from multiple data interfaces to the specified NWBFile.
+
+        Parameters
+        ----------
+        nwbfile : NWBFile
+            The NWBFile object to which the data will be added.
+        metadata : dict
+            Metadata dictionary containing information to describe the data being added to the NWB file.
+        stub_test : bool, optional
+            If True, only a subset of the data (up to `stub_frames`) will be added for testing purposes. Default is False.
+        stub_frames : int, optional
+            The number of frames to include in the subset if `stub_test` is True. Default is 100.
+        """
         for photon_series_index, (interface_name, data_interface) in enumerate(self.data_interface_objects.items()):
             data_interface.add_to_nwbfile(
                 nwbfile=nwbfile,
@@ -109,6 +124,24 @@ def run_conversion(
         stub_test: bool = False,
         stub_frames: int = 100,
     ) -> None:
+        """
+        Run the conversion process for the instantiated data interfaces and add data to the NWB file.
+
+        Parameters
+        ----------
+        nwbfile_path : FilePath, optional
+            Path where the NWB file will be written. If None, the file will be handled in-memory.
+        nwbfile : NWBFile, optional
+            An in-memory NWBFile object. If None, a new NWBFile object will be created.
+        metadata : dict, optional
+            Metadata dictionary for describing the NWB file. If None, it will be auto-generated using the `get_metadata()` method.
+        overwrite : bool, optional
+            If True, overwrites the existing NWB file at `nwbfile_path`. If False, appends to the file (default is False).
+        stub_test : bool, optional
+            If True, only a subset of the data (up to `stub_frames`) will be added for testing purposes, by default False.
+        stub_frames : int, optional
+            The number of frames to include in the subset if `stub_test` is True, by default 100.
+        """
         if metadata is None:
             metadata = self.get_metadata()
 
@@ -141,6 +174,7 @@ def get_source_schema(cls):
         return get_json_schema_from_method_signature(cls)
 
     def get_conversion_options_schema(self):
+        """Get the conversion options schema."""
         interface_name = list(self.data_interface_objects.keys())[0]
         return self.data_interface_objects[interface_name].get_conversion_options_schema()
 
@@ -187,6 +221,21 @@ def add_to_nwbfile(
         stub_test: bool = False,
         stub_frames: int = 100,
     ):
+        """
+        Add data from all instantiated data interfaces to the provided NWBFile.
+
+        Parameters
+        ----------
+        nwbfile : NWBFile
+            The NWBFile object to which the data will be added.
+        metadata : dict
+            Metadata dictionary containing information about the data to be added.
+        stub_test : bool, optional
+            If True, only a subset of the data (defined by `stub_frames`) will be added for testing purposes,
+            by default False.
+        stub_frames : int, optional
+            The number of frames to include in the subset if `stub_test` is True, by default 100.
+        """
         for photon_series_index, (interface_name, data_interface) in enumerate(self.data_interface_objects.items()):
             data_interface.add_to_nwbfile(
                 nwbfile=nwbfile,
@@ -205,6 +254,24 @@ def run_conversion(
         stub_test: bool = False,
         stub_frames: int = 100,
     ) -> None:
+        """
+        Run the NWB conversion process for all instantiated data interfaces.
+
+        Parameters
+        ----------
+        nwbfile_path : FilePath, optional
+            The file path where the NWB file will be written. If None, the file is handled in-memory.
+        nwbfile : NWBFile, optional
+            An existing in-memory NWBFile object. If None, a new NWBFile object will be created.
+        metadata : dict, optional
+            Metadata dictionary used to create or validate the NWBFile. If None, metadata is automatically generated.
+        overwrite : bool, optional
+            If True, the NWBFile at `nwbfile_path` is overwritten if it exists. If False (default), data is appended.
+        stub_test : bool, optional
+            If True, only a subset of the data (up to `stub_frames`) is used for testing purposes. By default False.
+        stub_frames : int, optional
+            The number of frames to include in the subset if `stub_test` is True. By default 100.
+        """
         if metadata is None:
             metadata = self.get_metadata()
 
diff --git a/src/neuroconv/datainterfaces/ophys/brukertiff/brukertiffdatainterface.py b/src/neuroconv/datainterfaces/ophys/brukertiff/brukertiffdatainterface.py
index 9742711e1..f7e7bee1b 100644
--- a/src/neuroconv/datainterfaces/ophys/brukertiff/brukertiffdatainterface.py
+++ b/src/neuroconv/datainterfaces/ophys/brukertiff/brukertiffdatainterface.py
@@ -16,6 +16,7 @@ class BrukerTiffMultiPlaneImagingInterface(BaseImagingExtractorInterface):
 
     @classmethod
     def get_source_schema(cls) -> dict:
+        """Get the source schema for the Bruker TIFF imaging data."""
         source_schema = super().get_source_schema()
         source_schema["properties"]["folder_path"][
             "description"
@@ -28,6 +29,23 @@ def get_streams(
         folder_path: DirectoryPath,
         plane_separation_type: Literal["contiguous", "disjoint"] = None,
     ) -> dict:
+        """
+        Get streams for the Bruker TIFF imaging data.
+
+        Parameters
+        ----------
+        folder_path : DirectoryPath
+            Path to the folder containing the Bruker TIFF files.
+        plane_separation_type : Literal["contiguous", "disjoint"], optional
+            Type of plane separation to apply. If "contiguous", only the first plane stream for each channel is retained.
+
+        Returns
+        -------
+        dict
+            A dictionary containing the streams for the Bruker TIFF imaging data. The dictionary has the following keys:
+            - "channel_streams": List of channel stream names.
+            - "plane_streams": Dictionary where keys are channel stream names and values are lists of plane streams.
+        """
         from roiextractors import BrukerTiffMultiPlaneImagingExtractor
 
         streams = BrukerTiffMultiPlaneImagingExtractor.get_streams(folder_path=folder_path)
@@ -117,6 +135,7 @@ def _determine_position_current(self) -> list[float]:
         return position_values
 
     def get_metadata(self) -> DeepDict:
+        """get metadata for the Bruker TIFF imaging data."""
         metadata = super().get_metadata()
 
         xml_metadata = self.imaging_extractor.xml_metadata
@@ -183,6 +202,7 @@ class BrukerTiffSinglePlaneImagingInterface(BaseImagingExtractorInterface):
 
     @classmethod
     def get_source_schema(cls) -> dict:
+        """Get the source schema for the Bruker TIFF imaging data."""
         source_schema = super().get_source_schema()
         source_schema["properties"]["folder_path"][
             "description"
@@ -191,6 +211,19 @@ def get_source_schema(cls) -> dict:
 
     @classmethod
     def get_streams(cls, folder_path: DirectoryPath) -> dict:
+        """
+        Get streams for the Bruker TIFF imaging data.
+
+        Parameters
+        ----------
+        folder_path : DirectoryPath
+            Path to the folder containing the Bruker TIFF files.
+
+        Returns
+        -------
+        dict
+            A dictionary containing the streams extracted from the Bruker TIFF files.
+        """
         from roiextractors import BrukerTiffMultiPlaneImagingExtractor
 
         streams = BrukerTiffMultiPlaneImagingExtractor.get_streams(folder_path=folder_path)
@@ -263,6 +296,7 @@ def _determine_position_current(self) -> list[float]:
         return position_values
 
     def get_metadata(self) -> DeepDict:
+        """get metadata for the Bruker TIFF imaging data."""
         metadata = super().get_metadata()
 
         xml_metadata = self.imaging_extractor.xml_metadata
diff --git a/src/neuroconv/datainterfaces/ophys/caiman/caimandatainterface.py b/src/neuroconv/datainterfaces/ophys/caiman/caimandatainterface.py
index 386c03d3c..802645139 100644
--- a/src/neuroconv/datainterfaces/ophys/caiman/caimandatainterface.py
+++ b/src/neuroconv/datainterfaces/ophys/caiman/caimandatainterface.py
@@ -12,6 +12,7 @@ class CaimanSegmentationInterface(BaseSegmentationExtractorInterface):
 
     @classmethod
     def get_source_schema(cls) -> dict:
+        """Get the source schema for the Caiman segmentation interface."""
         source_metadata = super().get_source_schema()
         source_metadata["properties"]["file_path"]["description"] = "Path to .hdf5 file."
         return source_metadata
diff --git a/src/neuroconv/datainterfaces/ophys/micromanagertiff/micromanagertiffdatainterface.py b/src/neuroconv/datainterfaces/ophys/micromanagertiff/micromanagertiffdatainterface.py
index 17cbc95ed..5373b7004 100644
--- a/src/neuroconv/datainterfaces/ophys/micromanagertiff/micromanagertiffdatainterface.py
+++ b/src/neuroconv/datainterfaces/ophys/micromanagertiff/micromanagertiffdatainterface.py
@@ -13,6 +13,7 @@ class MicroManagerTiffImagingInterface(BaseImagingExtractorInterface):
 
     @classmethod
     def get_source_schema(cls) -> dict:
+        """get the source schema for the Micro-Manager TIFF imaging interface."""
         source_schema = super().get_source_schema()
 
         source_schema["properties"]["folder_path"]["description"] = "The folder containing the OME-TIF image files."
@@ -37,6 +38,7 @@ def __init__(self, folder_path: DirectoryPath, verbose: bool = True):
         self.imaging_extractor._channel_names = [f"OpticalChannel{channel_name}"]
 
     def get_metadata(self) -> dict:
+        """Get metadata for the Micro-Manager TIFF imaging data."""
         metadata = super().get_metadata()
 
         micromanager_metadata = self.imaging_extractor.micromanager_metadata
diff --git a/src/neuroconv/datainterfaces/ophys/miniscope/miniscopeconverter.py b/src/neuroconv/datainterfaces/ophys/miniscope/miniscopeconverter.py
index d1a0fb701..59424d7a5 100644
--- a/src/neuroconv/datainterfaces/ophys/miniscope/miniscopeconverter.py
+++ b/src/neuroconv/datainterfaces/ophys/miniscope/miniscopeconverter.py
@@ -61,6 +61,7 @@ def __init__(self, folder_path: DirectoryPath, verbose: bool = True):
         )
 
     def get_conversion_options_schema(self) -> dict:
+        """get the conversion options schema."""
         return self.data_interface_objects["MiniscopeImaging"].get_conversion_options_schema()
 
     def add_to_nwbfile(
@@ -70,6 +71,21 @@ def add_to_nwbfile(
         stub_test: bool = False,
         stub_frames: int = 100,
     ):
+        """
+        Add Miniscope imaging and behavioral camera data to the specified NWBFile.
+
+        Parameters
+        ----------
+        nwbfile : NWBFile
+            The NWBFile object to which the imaging and behavioral data will be added.
+        metadata : dict
+            Metadata dictionary containing information about the imaging and behavioral recordings.
+        stub_test : bool, optional
+            If True, only a subset of the data (defined by `stub_frames`) will be added for testing purposes,
+            by default False.
+        stub_frames : int, optional
+            The number of frames to include in the subset if `stub_test` is True, by default 100.
+        """
         self.data_interface_objects["MiniscopeImaging"].add_to_nwbfile(
             nwbfile=nwbfile,
             metadata=metadata,
@@ -90,6 +106,25 @@ def run_conversion(
         stub_test: bool = False,
         stub_frames: int = 100,
     ) -> None:
+        """
+        Run the NWB conversion process for the instantiated data interfaces.
+
+        Parameters
+        ----------
+        nwbfile_path : str, optional
+            Path where the NWBFile will be written. If None, the file is handled in-memory.
+        nwbfile : NWBFile, optional
+            An in-memory NWBFile object to be written to the file. If None, a new NWBFile is created.
+        metadata : dict, optional
+            Metadata dictionary with information to create the NWBFile. If None, metadata is auto-generated.
+        overwrite : bool, optional
+            If True, overwrites the existing NWBFile at `nwbfile_path`. If False (default), data is appended.
+        stub_test : bool, optional
+            If True, only a subset of the data (up to `stub_frames`) is written for testing purposes,
+            by default False.
+        stub_frames : int, optional
+            The number of frames to include in the subset if `stub_test` is True, by default 100.
+        """
         if metadata is None:
             metadata = self.get_metadata()
 
diff --git a/src/neuroconv/datainterfaces/ophys/miniscope/miniscopeimagingdatainterface.py b/src/neuroconv/datainterfaces/ophys/miniscope/miniscopeimagingdatainterface.py
index 64a180c46..5a1f6d521 100644
--- a/src/neuroconv/datainterfaces/ophys/miniscope/miniscopeimagingdatainterface.py
+++ b/src/neuroconv/datainterfaces/ophys/miniscope/miniscopeimagingdatainterface.py
@@ -19,6 +19,7 @@ class MiniscopeImagingInterface(BaseImagingExtractorInterface):
 
     @classmethod
     def get_source_schema(cls) -> dict:
+        """Get the source schema for the Miniscope imaging interface."""
         source_schema = super().get_source_schema()
         source_schema["properties"]["folder_path"][
             "description"
@@ -49,6 +50,7 @@ def __init__(self, folder_path: DirectoryPath):
         self.photon_series_type = "OnePhotonSeries"
 
     def get_metadata(self) -> DeepDict:
+        """Get metadata for the Miniscope imaging data."""
         from ....tools.roiextractors import get_nwb_imaging_metadata
 
         metadata = super().get_metadata()
@@ -74,6 +76,7 @@ def get_metadata(self) -> DeepDict:
         return metadata
 
     def get_metadata_schema(self) -> dict:
+        """Get the metadata schema for the Miniscope imaging data."""
         metadata_schema = super().get_metadata_schema()
         metadata_schema["properties"]["Ophys"]["definitions"]["Device"]["additionalProperties"] = True
         return metadata_schema
@@ -92,6 +95,23 @@ def add_to_nwbfile(
         stub_test: bool = False,
         stub_frames: int = 100,
     ):
+        """
+        Add imaging data to the specified NWBFile, including device and photon series information.
+
+        Parameters
+        ----------
+        nwbfile : NWBFile
+            The NWBFile object to which the imaging data will be added.
+        metadata : dict, optional
+            Metadata containing information about the imaging device and photon series. If None, default metadata is used.
+        photon_series_type : {"TwoPhotonSeries", "OnePhotonSeries"}, optional
+            The type of photon series to be added, either "TwoPhotonSeries" or "OnePhotonSeries", by default "OnePhotonSeries".
+        stub_test : bool, optional
+            If True, only a subset of the data (defined by `stub_frames`) will be added for testing purposes,
+            by default False.
+        stub_frames : int, optional
+            The number of frames to include if `stub_test` is True, by default 100.
+        """
         from ndx_miniscope.utils import add_miniscope_device
 
         from ....tools.roiextractors import add_photon_series_to_nwbfile
diff --git a/src/neuroconv/datainterfaces/ophys/sbx/sbxdatainterface.py b/src/neuroconv/datainterfaces/ophys/sbx/sbxdatainterface.py
index 554cc5aba..49e556d06 100644
--- a/src/neuroconv/datainterfaces/ophys/sbx/sbxdatainterface.py
+++ b/src/neuroconv/datainterfaces/ophys/sbx/sbxdatainterface.py
@@ -37,6 +37,7 @@ def __init__(
         )
 
     def get_metadata(self) -> dict:
+        """Get metadata for the Scanbox imaging data."""
         metadata = super().get_metadata()
         metadata["Ophys"]["Device"][0]["description"] = "Scanbox imaging"
         return metadata
diff --git a/src/neuroconv/datainterfaces/ophys/scanimage/scanimageimaginginterfaces.py b/src/neuroconv/datainterfaces/ophys/scanimage/scanimageimaginginterfaces.py
index c74161e55..7d9d7003b 100644
--- a/src/neuroconv/datainterfaces/ophys/scanimage/scanimageimaginginterfaces.py
+++ b/src/neuroconv/datainterfaces/ophys/scanimage/scanimageimaginginterfaces.py
@@ -28,6 +28,7 @@ class ScanImageImagingInterface(BaseImagingExtractorInterface):
 
     @classmethod
     def get_source_schema(cls) -> dict:
+        """Get the source schema for the ScanImage imaging interface."""
         source_schema = super().get_source_schema()
         source_schema["properties"]["file_path"]["description"] = "Path to Tiff file."
         return source_schema
@@ -139,6 +140,7 @@ def __init__(
         super().__init__(file_path=file_path, fallback_sampling_frequency=fallback_sampling_frequency, verbose=verbose)
 
     def get_metadata(self) -> dict:
+        """get metadata for the ScanImage imaging data"""
         device_number = 0  # Imaging plane metadata is a list with metadata for each plane
 
         metadata = super().get_metadata()
@@ -174,6 +176,7 @@ class ScanImageMultiFileImagingInterface(BaseImagingExtractorInterface):
 
     @classmethod
     def get_source_schema(cls) -> dict:
+        """get the source schema for the ScanImage multi-file imaging interface."""
         source_schema = super().get_source_schema()
         source_schema["properties"]["folder_path"]["description"] = "Path to the folder containing the TIFF files."
         return source_schema
@@ -304,6 +307,7 @@ def __init__(
         )
 
     def get_metadata(self) -> dict:
+        """get metadata for the ScanImage imaging data"""
         metadata = super().get_metadata()
 
         extracted_session_start_time = datetime.datetime.strptime(
@@ -421,6 +425,7 @@ def __init__(
         )
 
     def get_metadata(self) -> dict:
+        """get metadata for the ScanImage imaging data"""
         metadata = super().get_metadata()
 
         extracted_session_start_time = datetime.datetime.strptime(
@@ -548,6 +553,7 @@ def __init__(
         )
 
     def get_metadata(self) -> dict:
+        """get metadata for the ScanImage imaging data"""
         metadata = super().get_metadata()
 
         extracted_session_start_time = datetime.datetime.strptime(
@@ -677,6 +683,7 @@ def __init__(
         )
 
     def get_metadata(self) -> dict:
+        """get metadata for the ScanImage imaging data"""
         metadata = super().get_metadata()
 
         extracted_session_start_time = datetime.datetime.strptime(
diff --git a/src/neuroconv/datainterfaces/ophys/suite2p/suite2pdatainterface.py b/src/neuroconv/datainterfaces/ophys/suite2p/suite2pdatainterface.py
index 056616ce5..8a3f876c2 100644
--- a/src/neuroconv/datainterfaces/ophys/suite2p/suite2pdatainterface.py
+++ b/src/neuroconv/datainterfaces/ophys/suite2p/suite2pdatainterface.py
@@ -50,6 +50,7 @@ class Suite2pSegmentationInterface(BaseSegmentationExtractorInterface):
 
     @classmethod
     def get_source_schema(cls) -> dict:
+        """Get the source schema for the Suite2p segmentation interface."""
         schema = super().get_source_schema()
         schema["properties"]["folder_path"][
             "description"
@@ -113,6 +114,7 @@ def __init__(
         self.verbose = verbose
 
     def get_metadata(self) -> DeepDict:
+        """get metadata for the Suite2p segmentation data"""
         metadata = super().get_metadata()
 
         # No need to update the metadata links for the default plane segmentation name
@@ -140,6 +142,40 @@ def add_to_nwbfile(
         iterator_options: Optional[dict] = None,
         compression_options: Optional[dict] = None,
     ):
+        """
+        Add segmentation data to the specified NWBFile.
+
+        Parameters
+        ----------
+        nwbfile : NWBFile
+            The NWBFile object to which the segmentation data will be added.
+        metadata : dict, optional
+            Metadata containing information about the segmentation. If None, default metadata is used.
+        stub_test : bool, optional
+            If True, only a subset of the data (defined by `stub_frames`) will be added for testing purposes,
+            by default False.
+        stub_frames : int, optional
+            The number of frames to include in the subset if `stub_test` is True, by default 100.
+        include_roi_centroids : bool, optional
+            Whether to include the centroids of regions of interest (ROIs) in the data, by default True.
+        include_roi_acceptance : bool, optional
+            Whether to include acceptance status of ROIs, by default True.
+        mask_type : str, default: 'image'
+            There are three types of ROI masks in NWB, 'image', 'pixel', and 'voxel'.
+
+            * 'image' masks have the same shape as the reference images the segmentation was applied to, and weight each pixel
+            by its contribution to the ROI (typically boolean, with 0 meaning 'not in the ROI').
+            * 'pixel' masks are instead indexed by ROI, with the data at each index being the shape of the image by the number
+            of pixels in each ROI.
+            * 'voxel' masks are instead indexed by ROI, with the data at each index being the shape of the volume by the number
+            of voxels in each ROI.
+
+            Specify your choice between these two as mask_type='image', 'pixel', 'voxel', or None.
+            plane_segmentation_name : str, optional
+            The name of the plane segmentation object, by default None.
+        iterator_options : dict, optional
+            Additional options for iterating over the data, by default None.
+        """
         super().add_to_nwbfile(
             nwbfile=nwbfile,
             metadata=metadata,
diff --git a/src/neuroconv/datainterfaces/ophys/tdt_fp/tdtfiberphotometrydatainterface.py b/src/neuroconv/datainterfaces/ophys/tdt_fp/tdtfiberphotometrydatainterface.py
index 8b092464e..0c6b90aea 100644
--- a/src/neuroconv/datainterfaces/ophys/tdt_fp/tdtfiberphotometrydatainterface.py
+++ b/src/neuroconv/datainterfaces/ophys/tdt_fp/tdtfiberphotometrydatainterface.py
@@ -47,6 +47,7 @@ def __init__(self, folder_path: DirectoryPath, verbose: bool = True):
         import ndx_fiber_photometry  # noqa: F401
 
     def get_metadata(self) -> DeepDict:
+        """Get metadata for the TDTFiberPhotometryInterface."""
         metadata = super().get_metadata()
         tdt_photometry = self.load(evtype=["scalars"])  # This evtype quickly loads info without loading all the data.
         start_timestamp = tdt_photometry.info.start_date.timestamp()
@@ -55,6 +56,7 @@ def get_metadata(self) -> DeepDict:
         return metadata
 
     def get_metadata_schema(self) -> dict:
+        """Get the metadata schema for the TDTFiberPhotometryInterface."""
         metadata_schema = super().get_metadata_schema()
         return metadata_schema
 
diff --git a/src/neuroconv/datainterfaces/ophys/tiff/tiffdatainterface.py b/src/neuroconv/datainterfaces/ophys/tiff/tiffdatainterface.py
index 1eaa3b55e..ce98561de 100644
--- a/src/neuroconv/datainterfaces/ophys/tiff/tiffdatainterface.py
+++ b/src/neuroconv/datainterfaces/ophys/tiff/tiffdatainterface.py
@@ -14,6 +14,7 @@ class TiffImagingInterface(BaseImagingExtractorInterface):
 
     @classmethod
     def get_source_schema(cls) -> dict:
+        """ "Get the source schema for the TIFF imaging interface."""
         source_schema = super().get_source_schema()
         source_schema["properties"]["file_path"]["description"] = "Path to Tiff file."
         return source_schema
diff --git a/src/neuroconv/datainterfaces/text/timeintervalsinterface.py b/src/neuroconv/datainterfaces/text/timeintervalsinterface.py
index 5f5b1107d..a1de63a07 100644
--- a/src/neuroconv/datainterfaces/text/timeintervalsinterface.py
+++ b/src/neuroconv/datainterfaces/text/timeintervalsinterface.py
@@ -24,16 +24,20 @@ def __init__(
         verbose: bool = True,
     ):
         """
+        Initialize the TimeIntervalsInterface.
+
         Parameters
         ----------
         file_path : FilePath
+            The path to the file containing time intervals data.
         read_kwargs : dict, optional
-        verbose : bool, default: True
+            Additional arguments for reading the file, by default None.
+        verbose : bool, optional
+            If True, provides verbose output, by default True.
         """
         read_kwargs = read_kwargs or dict()
         super().__init__(file_path=file_path)
         self.verbose = verbose
-
         self._read_kwargs = read_kwargs
         self.dataframe = self._read_file(file_path, **read_kwargs)
         self.time_intervals = None
@@ -50,22 +54,74 @@ def get_metadata(self) -> dict:
         return metadata
 
     def get_metadata_schema(self) -> dict:
+        """
+        Get the metadata schema for the time intervals.
+
+        Returns
+        -------
+        dict
+            The schema dictionary for time intervals metadata.
+        """
         fpath = Path(__file__).parent.parent.parent / "schemas" / "timeintervals_schema.json"
         return load_dict_from_file(fpath)
 
     def get_original_timestamps(self, column: str) -> np.ndarray:
+        """
+        Get the original timestamps for a given column.
+
+        Parameters
+        ----------
+        column : str
+            The name of the column containing timestamps.
+
+        Returns
+        -------
+        np.ndarray
+            The original timestamps from the specified column.
+
+        Raises
+        ------
+        ValueError
+            If the column name does not end with '_time'.
+        """
         if not column.endswith("_time"):
             raise ValueError("Timing columns on a TimeIntervals table need to end with '_time'!")
 
         return self._read_file(**self.source_data, **self._read_kwargs)[column].values
 
     def get_timestamps(self, column: str) -> np.ndarray:
+        """
+        Get the current timestamps for a given column.
+
+        Parameters
+        ----------
+        column : str
+            The name of the column containing timestamps.
+
+        Returns
+        -------
+        np.ndarray
+            The current timestamps from the specified column.
+
+        Raises
+        ------
+        ValueError
+            If the column name does not end with '_time'.
+        """
         if not column.endswith("_time"):
             raise ValueError("Timing columns on a TimeIntervals table need to end with '_time'!")
 
         return self.dataframe[column].values
 
     def set_aligned_starting_time(self, aligned_starting_time: float):
+        """
+        Align the starting time by shifting all timestamps by the given value.
+
+        Parameters
+        ----------
+        aligned_starting_time : float
+            The aligned starting time to shift all timestamps by.
+        """
         timing_columns = [column for column in self.dataframe.columns if column.endswith("_time")]
 
         for column in timing_columns:
@@ -74,6 +130,23 @@ def set_aligned_starting_time(self, aligned_starting_time: float):
     def set_aligned_timestamps(
         self, aligned_timestamps: np.ndarray, column: str, interpolate_other_columns: bool = False
     ):
+        """
+        Set aligned timestamps for the given column and optionally interpolate other columns.
+
+        Parameters
+        ----------
+        aligned_timestamps : np.ndarray
+            The aligned timestamps to set for the given column.
+        column : str
+            The name of the column to update with the aligned timestamps.
+        interpolate_other_columns : bool, optional
+            If True, interpolate the timestamps in other columns, by default False.
+
+        Raises
+        ------
+        ValueError
+            If the column name does not end with '_time'.
+        """
         if not column.endswith("_time"):
             raise ValueError("Timing columns on a TimeIntervals table need to end with '_time'!")
 
@@ -96,6 +169,18 @@ def set_aligned_timestamps(
             )
 
     def align_by_interpolation(self, unaligned_timestamps: np.ndarray, aligned_timestamps: np.ndarray, column: str):
+        """
+        Align timestamps using linear interpolation.
+
+        Parameters
+        ----------
+        unaligned_timestamps : np.ndarray
+            The original unaligned timestamps that map to the aligned timestamps.
+        aligned_timestamps : np.ndarray
+            The target aligned timestamps corresponding to the unaligned timestamps.
+        column : str
+            The name of the column containing the timestamps to be aligned.
+        """
         current_timestamps = self.get_timestamps(column=column)
         assert (
             current_timestamps[1] >= unaligned_timestamps[0]
diff --git a/src/neuroconv/nwbconverter.py b/src/neuroconv/nwbconverter.py
index fe1b09915..2d70cf8ee 100644
--- a/src/neuroconv/nwbconverter.py
+++ b/src/neuroconv/nwbconverter.py
@@ -177,7 +177,21 @@ def create_nwbfile(self, metadata: Optional[dict] = None, conversion_options: Op
         self.add_to_nwbfile(nwbfile=nwbfile, metadata=metadata, conversion_options=conversion_options)
         return nwbfile
 
-    def add_to_nwbfile(self, nwbfile: NWBFile, metadata, conversion_options: Optional[dict] = None) -> None:
+    def add_to_nwbfile(self, nwbfile: NWBFile, metadata, conversion_options: Optional[dict] = None):
+        """
+        Add data from the instantiated data interfaces to the given NWBFile.
+
+        Parameters
+        ----------
+        nwbfile : NWBFile
+            The NWB file object to which the data from the data interfaces will be added.
+        metadata : dict
+            The metadata dictionary that contains information used to describe the data.
+        conversion_options : dict, optional
+            A dictionary containing conversion options for each interface, where non-default behavior is requested.
+            Each key corresponds to a data interface name, and the values are dictionaries with options for that interface.
+            By default, None.
+        """
         conversion_options = conversion_options or dict()
         for interface_name, data_interface in self.data_interface_objects.items():
             data_interface.add_to_nwbfile(
diff --git a/src/neuroconv/tools/hdmf.py b/src/neuroconv/tools/hdmf.py
index 660971df5..f32ea23a0 100644
--- a/src/neuroconv/tools/hdmf.py
+++ b/src/neuroconv/tools/hdmf.py
@@ -50,6 +50,7 @@ def estimate_default_chunk_shape(chunk_mb: float, maxshape: tuple[int, ...], dty
     def estimate_default_buffer_shape(
         buffer_gb: float, chunk_shape: tuple[int, ...], maxshape: tuple[int, ...], dtype: np.dtype
     ) -> tuple[int, ...]:
+        # TODO: Ad ddocstring to this once someone understands it better
         # Elevate any overflow warnings to trigger error.
         # This is usually an indicator of something going terribly wrong with the estimation calculations and should be
         # avoided at all costs.
diff --git a/src/neuroconv/tools/testing/mock_interfaces.py b/src/neuroconv/tools/testing/mock_interfaces.py
index 5a96b4b68..0350806bb 100644
--- a/src/neuroconv/tools/testing/mock_interfaces.py
+++ b/src/neuroconv/tools/testing/mock_interfaces.py
@@ -57,31 +57,70 @@ def get_source_schema(cls) -> dict:
 
     def __init__(self, event_times: Optional[ArrayType] = None):
         """
-        Define event times for some behavior.
+        Initialize the interface with event times for behavior.
 
         Parameters
         ----------
         event_times : list of floats, optional
             The event times to set as timestamps for this interface.
-            The default is the array [1.2, 2.3, 3.4] for similarity to the timescale of the MockSpikeGLXNIDQInterface.
+            The default is the array [1.2, 2.3, 3.4] to simulate a time series similar to the
+            MockSpikeGLXNIDQInterface.
         """
         event_times = event_times or [1.2, 2.3, 3.4]
         self.event_times = np.array(event_times)
         self.original_event_times = np.array(event_times)  # Make a copy of the initial loaded timestamps
 
     def get_original_timestamps(self) -> np.ndarray:
+        """
+        Get the original event times before any alignment or transformation.
+
+        Returns
+        -------
+        np.ndarray
+            The original event times as a NumPy array.
+        """
         return self.original_event_times
 
     def get_timestamps(self) -> np.ndarray:
+        """
+        Get the current (possibly aligned) event times.
+
+        Returns
+        -------
+        np.ndarray
+            The current event times as a NumPy array, possibly modified after alignment.
+        """
         return self.event_times
 
     def set_aligned_timestamps(self, aligned_timestamps: np.ndarray):
+        """
+        Set the event times after alignment.
+
+        Parameters
+        ----------
+        aligned_timestamps : np.ndarray
+            The aligned event timestamps to update the internal event times.
+        """
         self.event_times = aligned_timestamps
 
     def add_to_nwbfile(self, nwbfile: NWBFile, metadata: dict):
+        """
+        Add the event times to an NWBFile as a DynamicTable.
+
+        Parameters
+        ----------
+        nwbfile : NWBFile
+            The NWB file to which the event times will be added.
+        metadata : dict
+            Metadata to describe the event times in the NWB file.
+
+        Notes
+        -----
+        This method creates a DynamicTable to store event times and adds it to the NWBFile's acquisition.
+        """
         table = DynamicTable(name="BehaviorEvents", description="Times of various classified behaviors.")
         table.add_column(name="event_time", description="Time of each event.")
-        for timestamp in self.get_timestamps():  # adding data by column gives error
+        for timestamp in self.get_timestamps():
             table.add_row(event_time=timestamp)
         nwbfile.add_acquisition(table)
 
@@ -182,6 +221,9 @@ def __init__(
         )
 
     def get_metadata(self) -> dict:
+        """
+        Returns the metadata dictionary for the current object.
+        """
         metadata = super().get_metadata()
         session_start_time = datetime.now().astimezone()
         metadata["NWBFile"]["session_start_time"] = session_start_time
@@ -229,7 +271,7 @@ def __init__(
             verbose=verbose,
         )
 
-    def get_metadata(self) -> dict:  # noqa D102
+    def get_metadata(self) -> dict:
         metadata = super().get_metadata()
         session_start_time = datetime.now().astimezone()
         metadata["NWBFile"]["session_start_time"] = session_start_time
diff --git a/src/neuroconv/utils/dict.py b/src/neuroconv/utils/dict.py
index f0507b653..a6cef630a 100644
--- a/src/neuroconv/utils/dict.py
+++ b/src/neuroconv/utils/dict.py
@@ -209,12 +209,29 @@ class DeepDict(defaultdict):
     """A defaultdict of defaultdicts"""
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """A defaultdict of defaultdicts"""
         super().__init__(lambda: DeepDict(), *args, **kwargs)
         for key, value in self.items():
             if isinstance(value, dict):
                 self[key] = DeepDict(value)
 
     def deep_update(self, other: Optional[Union[dict, "DeepDict"]] = None, **kwargs) -> None:
+        """
+        Recursively update the DeepDict with another dictionary or DeepDict.
+
+        Parameters
+        ----------
+        other : dict or DeepDict, optional
+            The dictionary or DeepDict to update the current instance with.
+        **kwargs : Any
+            Additional keyword arguments representing key-value pairs to update the DeepDict.
+
+        Notes
+        -----
+        For any keys that exist in both the current instance and the provided dictionary, the values are merged
+        recursively if both are dictionaries. Otherwise, the value from `other` or `kwargs` will overwrite the
+        existing value.
+        """
         for key, value in (other or kwargs).items():
             if key in self and isinstance(self[key], dict) and isinstance(value, dict):
                 self[key].deep_update(value)