From 5f7dc24f815a0c841b5317e07dc483c0d3616546 Mon Sep 17 00:00:00 2001
From: Marcel Zwiers <m.zwiers@donders.ru.nl>
Date: Tue, 17 Sep 2024 15:20:11 +0200
Subject: [PATCH] Refactoring + deepcopy bugfixes

---
 bidscoin/bcoin.py                      |  13 +-
 bidscoin/bids.py                       | 345 +++++++-----
 bidscoin/bidsapps/deface.py            |   4 +-
 bidscoin/bidsapps/echocombine.py       |   4 +-
 bidscoin/bidsapps/fixmeta.py           |  10 +-
 bidscoin/bidsapps/medeface.py          |   4 +-
 bidscoin/bidsapps/skullstrip.py        |   4 +-
 bidscoin/bidsapps/slicereport.py       |  14 +-
 bidscoin/bidscoiner.py                 |  21 +-
 bidscoin/bidseditor.py                 | 370 ++++++-------
 bidscoin/bidsmapper.py                 |  20 +-
 bidscoin/plugins/dcm2niix2bids.py      |  18 +-
 bidscoin/plugins/nibabel2bids.py       |  40 +-
 bidscoin/plugins/spec2nii2bids.py      |  42 +-
 bidscoin/utilities/bidsparticipants.py |  20 +-
 bidscoin/utilities/dicomsort.py        |   4 +-
 bidscoin/utilities/rawmapper.py        |   9 +-
 tests/test_bids.py                     | 740 +++++++++++++------------
 tests/test_bidsmapper.py               |  11 +-
 tests/test_plugins.py                  |   4 +-
 20 files changed, 888 insertions(+), 809 deletions(-)

diff --git a/bidscoin/bcoin.py b/bidscoin/bcoin.py
index 34614e27..a6b746eb 100755
--- a/bidscoin/bcoin.py
+++ b/bidscoin/bcoin.py
@@ -498,11 +498,11 @@ def test_bidsmap(bidsmapfile: str):
     return bidsmap.validate(1)
 
 
-def test_bidscoin(bidsmapfile: Path, options: dict=None, testplugins: bool=True, testgui: bool=True, testtemplate: bool=True) -> int:
+def test_bidscoin(bidsmapfile, options: dict=None, testplugins: bool=True, testgui: bool=True, testtemplate: bool=True) -> int:
     """
     Performs a bidscoin installation test
 
-    :param bidsmapfile: The bidsmap or the full pathname/basename of the bidsmap yaml-file
+    :param bidsmapfile: The full pathname/basename of the bidsmap yaml-file or the bidsmap object itself
     :param options:     The bidscoin options. If empty, the default options are used
     :return:            0 if the test was successful, otherwise 1
     """
@@ -568,8 +568,7 @@ def test_bidscoin(bidsmapfile: Path, options: dict=None, testplugins: bool=True,
     list_executables(True)
 
     # Test the plugins
-    options = bidsmap['Options'] if not options and bidsmap else {}
-    if not options.get('plugins'):
+    if not bidsmap.plugins:
         LOGGER.warning('No plugins found in the bidsmap (BIDScoin will likely not do anything)')
     if testplugins:
 
@@ -577,7 +576,7 @@ def test_bidscoin(bidsmapfile: Path, options: dict=None, testplugins: bool=True,
         list_plugins(True)
         for plugin in pluginfolder.glob('*.py'):
             if plugin.stem != '__init__':
-                errorcode = test_plugin(plugin.stem, options['plugins'].get(plugin.stem,{}) if options else {})
+                errorcode = test_plugin(plugin.stem, bidsmap.plugins.get(plugin.stem, {}))
                 success   = not errorcode and success
                 if errorcode:
                     LOGGER.warning(f"Failed test: {plugin.stem}")
@@ -705,9 +704,9 @@ def main():
         settracking(value=args.tracking)
         reportcredits(args=args.credits)
 
-    except Exception:
+    except Exception as error:
         trackusage('bidscoin_exception')
-        raise
+        raise error
 
 
 if __name__ == "__main__":
diff --git a/bidscoin/bids.py b/bidscoin/bids.py
index 44e2dca9..f0f4a023 100644
--- a/bidscoin/bids.py
+++ b/bidscoin/bids.py
@@ -74,7 +74,7 @@ class DataSource:
 
     def __init__(self, sourcefile: Union[str, Path]='', plugins: Plugins=None, dataformat: str='', options: Options=None):
         """
-        Reads the properties and attributes from a source data file
+        Reads (cached) properties and attributes from a source data file
 
         :param sourcefile:  The full filepath of the data source
         :param plugins:     The plugin dictionaries with their options
@@ -144,20 +144,20 @@ def has_plugin(self) -> bool:
                     LOGGER.exception(f"The {plugin} plugin crashed while reading {self.path}\n{moderror}")
                 if supported:
                     if self.dataformat and self.dataformat != supported:
-                        LOGGER.debug(f"Inconsistent dataformat found, updating: {self.dataformat} -> {supported}")
+                        LOGGER.bcdebug(f"Inconsistent dataformat found, updating: {self.dataformat} -> {supported}")
                     self.dataformat: str = supported
                     return True
 
         return False
 
-    def properties(self, tagname: str, run=None) -> Union[str, int]:
+    def properties(self, tagname: str, runitem=None) -> Union[str, int]:
         """
         Gets the 'filepath[:regex]', 'filename[:regex]', 'filesize' or 'nrfiles' filesystem property. The filepath (with trailing "/")
         and filename can be parsed using an optional regular expression re.findall(regex, filepath/filename). The last match is returned
         for the filepath, the first match for the filename
 
         :param tagname: The name of the filesystem property key, e.g. 'filename', 'filename:sub-(.*?)_' or 'nrfiles'
-        :param run:     If given and tagname == 'nrfiles' then the nrfiles is dependent on the other filesystem matching-criteria
+        :param runitem: If given and tagname == 'nrfiles' then the nrfiles is dependent on the other filesystem matching-criteria
         :return:        The property value (posix with a trailing "/" if tagname == 'filepath') or '' if the property could not be parsed from the datasource
         """
 
@@ -190,10 +190,10 @@ def properties(self, tagname: str, run=None) -> Union[str, int]:
                 return f"{size:.2f} {label[n]}B"
 
             if tagname == 'nrfiles' and self.path.is_file():
-                if run:                                         # Currently not used but keep the option open for future use
-                    def match(file): return ((match_runvalue(file.parent, run['properties']['filepath']) or not run['properties']['filepath']) and
-                                             (match_runvalue(file.name, run['properties']['filename']) or not run['properties']['filename']) and
-                                             (match_runvalue(file.stat().st_size, run['properties']['filesize']) or not run['properties']['filesize']))
+                if runitem:                                         # Currently not used but keep the option open for future use
+                    def match(file): return ((match_runvalue(file.parent,         runitem.properties['filepath']) or not runitem.properties['filepath']) and
+                                             (match_runvalue(file.name,           runitem.properties['filename']) or not runitem.properties['filename']) and
+                                             (match_runvalue(file.stat().st_size, runitem.properties['filesize']) or not runitem.properties['filesize']))
                     return len([file for file in self.path.parent.iterdir() if match(file)])
                 else:
                     return len(list(self.path.parent.iterdir()))
@@ -308,7 +308,7 @@ def subid_sesid(self, subid: str=None, sesid: str=None) -> Tuple[str, str]:
         subid_ = self.dynamicvalue(subid, runtime=True)
         sesid  = self.dynamicvalue(sesid, runtime=True)
         if not subid_:
-            LOGGER.error(f"Could not parse required sub-<label> label from {self.path} using: {subid} -> 'sub-'")
+            LOGGER.error(f"Could not parse required sub-<label> label from {self} using: {subid} -> 'sub-'")
         subid = subid_
 
         # Add sub- and ses- prefixes if they are not there
@@ -372,10 +372,14 @@ def __init__(self, dataformat: str='', datatype: str='', data: dict=None, dataso
         :param plugins:    The plugin dictionaries with their options
         """
 
-        super().__setattr__('_data', data or {'provenance': '', 'properties': {}, 'attributes': {}, 'meta': {}})
+        # Create a YAML data dictionary with all required attribute keys
+        data = {} if data is None else data
+        for key, val in {'provenance': '', 'properties': {}, 'attributes': {}, 'bids': {'suffix':''}, 'meta': {}}.items():
+            if key not in data: data[key] = val
+        super().__setattr__('_data', data)
 
         # Set the regular attributes
-        self.datasource = datasource = copy.deepcopy(datasource) if datasource else DataSource(data.get('provenance') if data else '', plugins, dataformat, options)
+        self.datasource = datasource = copy.deepcopy(datasource) if datasource else DataSource(data['provenance'] if data else '', plugins, dataformat, options)
         """The DataSource object that is deepcopied or created from the run-item provenance"""
         datasource.subprefix = options['subprefix'] if options else datasource.subprefix
         datasource.sesprefix = options['sesprefix'] if options else datasource.sesprefix
@@ -388,23 +392,21 @@ def __init__(self, dataformat: str='', datatype: str='', data: dict=None, dataso
         self.plugins    = plugins or datasource.plugins
         """The plugin dictionaries with their options"""
 
-        # Set the default data attributes
-        self.provenance = data.get('provenance','') if data else str(datasource.path)
+        # Set the data attributes. TODO: create data classes instead?
+        self.provenance = data['provenance'] or str(datasource.path if datasource.path.name else '')
         """The file path of the data source"""
-        self.properties = Properties({'filepath': '', 'filename': '', 'filesize': '', 'nrfiles': None})
+        self.properties = Properties(data['properties'])
         """The file system properties from the data source that can be matched against other data sources"""
-        self.attributes = Attributes({})
+        for key, val in {'filepath': '', 'filename': '', 'filesize': '', 'nrfiles': None}.items():
+            if key not in self.properties:
+                self.properties[key] = val
+        self.attributes = Attributes(data['attributes'])
         """The (header) attributes from the data source that can be matched against other data sources"""
-        self.bids       = Bids({'suffix': ''})
+        self.bids       = Bids(data['bids'])
         """The BIDS output dictionary (used for construting the BIDS filename)"""
-        self.meta       = Meta({})
+        self.meta       = Meta(data['meta'])
         """The meta output dictionary (will be appended to the json sidecar file)"""
 
-        # Populate the data attributes with the given data (except provenance, which was already stored above)
-        for key in data or []:
-            if key != 'provenance':
-                setattr(self, key, copy.copy(data[key]))    # This should remove the YAML comments and bounds
-
     def __getattr__(self, name: str):
 
         _name    = f"_{name}"
@@ -453,11 +455,10 @@ def __eq__(self, other):
         else:
             return NotImplemented
 
-    def check(self, datatype: str, checks: Tuple[bool, bool, bool]=(False, False, False)) -> Tuple[Union[bool, None], Union[bool, None], Union[bool, None]]:
+    def check(self, checks: Tuple[bool, bool, bool]=(False, False, False)) -> Tuple[Union[bool, None], Union[bool, None], Union[bool, None]]:
         """
         Check run for required and optional entities using the BIDS schema files
 
-        :param datatype:    The datatype that is checked, e.g. 'anat'
         :param checks:      Booleans to report if all (bidskeys, bids-suffixes, bids-values) in the run are present according to the BIDS schema specifications
         :return:            True/False if the keys, suffixes or values are bids-valid or None if they cannot be checked
         """
@@ -465,7 +466,7 @@ def check(self, datatype: str, checks: Tuple[bool, bool, bool]=(False, False, Fa
         run_keysok   = None
         run_suffixok = None
         run_valsok   = None
-        datatype     = str(datatype)                            # To support DataType objects
+        datatype     = self.datatype
 
         # Check if we have provenance info
         if all(checks) and not self.provenance:
@@ -525,22 +526,23 @@ def check(self, datatype: str, checks: Tuple[bool, bool, bool]=(False, False, Fa
 
                 break
 
-        # Hack: There are physio, stim and events entities in the 'task'-rules, which can be added to any datatype
+        # Hack: There are physio, stim and events entities in the 'task'-rules, which can be added to any datatype. They can have a `.tsv` or a `.tsv.gz` file extension
         if suffix in datatyperules['task']['events']['suffixes'] + datatyperules['task']['timeseries']['suffixes']:
-            bidsname     = self.bidsname(validkeys=False, runtime=self.datasource.path.is_file())
-            run_suffixok = bids_validator.BIDSValidator().is_bids(f"/sub-foo/{datatype}/{bidsname}.json")  # NB: Using the BIDSValidator sounds nice but doesn't give any control over the BIDS-version
-            run_valsok   = run_suffixok
-            LOGGER.bcdebug(f"bidsname={run_suffixok}: /sub-foo/{datatype}/{bidsname}.json")
+            bidsname = self.bidsname(validkeys=False, runtime=self.datasource.path.is_file())
+            for ext in ('.tsv', '.tsv.gz'):  # NB: `ext` used to be '.json', which is more generic (but see https://github.com/bids-standard/bids-validator/issues/2113)
+                if run_suffixok := bids_validator.BIDSValidator().is_bids(f"/sub-unknown/{datatype}/{bidsname}{ext}"): break    # NB: Using the BIDSValidator sounds nice but doesn't give any control over the BIDS-version
+            run_valsok = run_suffixok
+            LOGGER.bcdebug(f"bidsname={run_suffixok}: /sub-unknown/{datatype}/{bidsname}.*")
 
         if checks[0] and run_keysok in (None, False):
-            LOGGER.bcdebug(f'Invalid "{run_keysok}" key-checks in run-item: "{self.bids["suffix"]}" ({datatype} -> {self.provenance})\nRun["bids"]:\n{self.bids}')
+            LOGGER.bcdebug(f'Invalid "{run_keysok}" key-checks in run-item: "{self.bids["suffix"]}" ({datatype} -> {self.provenance})\nRun["bids"]:\t{self.bids}')
 
         if checks[1] and run_suffixok is False:
             LOGGER.warning(f'Invalid run-item with suffix: "{self.bids["suffix"]}" ({datatype} -> {self.provenance})')
-            LOGGER.bcdebug(f"Run['bids']:\n{self.bids}")
+            LOGGER.bcdebug(f"Run['bids']:\t{self.bids}")
 
         if checks[2] and run_valsok in (None, False):
-            LOGGER.bcdebug(f'Invalid "{run_valsok}" val-checks in run-item: "{self.bids["suffix"]}" ({datatype} -> {self.provenance})\nRun["bids"]:\n{self.bids}')
+            LOGGER.bcdebug(f'Invalid "{run_valsok}" val-checks in run-item: "{self.bids["suffix"]}" ({datatype} -> {self.provenance})\nRun["bids"]:\t{self.bids}')
 
         return run_keysok, run_suffixok, run_valsok
 
@@ -694,7 +696,7 @@ def __init__(self, dataformat: str, datatype: str, data: list, options: Options,
         """The dictionary with the BIDScoin options"""
         self.plugins = plugins
         """The plugin dictionaries with their options"""
-        self._data   = data or []
+        self._data   = data
         """The YAML datatype dictionary, i.e. a list of runitems"""
 
     def __str__(self):
@@ -715,7 +717,7 @@ def __eq__(self, other):
 
     def __hash__(self):
 
-        return hash(self.datatype)
+        return hash(str(self))
 
     @property
     def runitems(self) -> List[RunItem]:
@@ -732,25 +734,22 @@ def delete_run(self, provenance: str):
 
         for index, runitem in enumerate(self.runitems):
             if Path(runitem.provenance) == Path(provenance):
+                LOGGER.bcdebug(f"Deleting run: {runitem}")
                 del self._data[index]
                 return
 
-        LOGGER.error(f"Could not find (and delete) this [{self.dataformat}][{self.datatype}] run: '{provenance}")
-
-    def delete_runs(self):
-        """Delete all run-items from the datatype section"""
-
-        self._data = []
+        LOGGER.error(f"Could not find (and delete) this [{self.dataformat}][{self}] run: '{provenance}")
 
     def insert_run(self, runitem: RunItem, position: int=None):
         """
-        Inserts a run-item to the DataType
+        Inserts a run-item (as is) to the DataType
 
-        :param runitem:     The run item that is appended to the list of run items of its datatype
+        :param runitem:     The run item that is inserted in the list of run items
         :param position:    The position at which the run is inserted. The run is appended at the end if position is None
         """
 
-        self._data.insert(len(self._data) if position is None else position, runitem)
+        LOGGER.bcdebug(f"Inserting run: {runitem}")
+        self._data.insert(len(self._data) if position is None else position, runitem._data)
 
     def replace_run(self, runitem: RunItem):
         """
@@ -759,9 +758,10 @@ def replace_run(self, runitem: RunItem):
         :param runitem: The new run-item
         """
 
-        for index, run in enumerate(self._data):
-            if Path(run.provenance) == Path(runitem.provenance):
-                self._data[index] = runitem
+        for index, rundata in enumerate(self._data):
+            if Path(rundata.get('provenance') or '') == Path(runitem.provenance):
+                LOGGER.bcdebug(f"Replacing run: {runitem} (unchanged = {self._data[index] == runitem._data})")
+                self._data[index] = runitem._data
                 return
 
         LOGGER.error(f"Could not replace {runitem} because it could not be found")
@@ -811,7 +811,7 @@ def __eq__(self, other):
 
     def __hash__(self):
 
-        return hash(self.datatype)
+        return hash(str(self))
 
     @property
     def subject(self) -> str:
@@ -843,16 +843,34 @@ def datatypes(self) -> List[DataType]:
     def datatype(self, datatype: Union[str, DataType]) -> DataType:
         """Gets the DataType object for the dataformat"""
 
-        return DataType(self.dataformat, str(datatype), self._data.get(str(datatype),[]), self.options, self.plugins)
+        return DataType(self.dataformat, str(datatype), self._data[str(datatype)], self.options, self.plugins)
 
     def add_datatype(self, datatype: Union[str, DataType]):
-        """Adds a new empty datatype item to the dataformat"""
+        """Adds a new datatype item to the dataformat"""
+
+        _data    = datatype._data if isinstance(datatype, DataType) else []
+        datatype = str(datatype)
+        if datatype not in self._data:
+            self._data[datatype] = _data
+            LOGGER.bcdebug(f"Adding the '{datatype}' datatype to {self}")
+        else:
+            LOGGER.bcdebug(f"The {self} dataformat already contains the '{datatype}' datatype")
+
+    def remove_datatype(self, datatype: Union[str, DataType]):
+        """Removes a datatype from the dataformat"""
 
         datatype = str(datatype)
         if datatype not in self._data:
-            self._data[datatype] = []
+            LOGGER.bcdebug(f"The '{datatype}' datatype could not be removed from {self}")
+            return
         else:
-            LOGGER.debug(f"The {self.dataformat} dataformat already contains the datatype '{datatype}'")
+            self._data.pop(datatype, None)
+            LOGGER.bcdebug(f"The '{datatype}' datatype was removed from {self}")
+
+    def delete_runs(self, datatype: Union[str, DataType]):
+        """Delete all run-items from the datatype section"""
+
+        self._data[str(datatype)] = []
 
 
 class BidsMap:
@@ -883,10 +901,10 @@ def __init__(self, yamlfile: Path, folder: Path=templatefolder, plugins: Iterabl
         if len(yamlfile.parents) == 1 and not yamlfile.is_file():
             yamlfile = folder/yamlfile                              # Get the full path to the bidsmap yaml-file
         yamlfile = yamlfile.resolve()
-        self.filepath = yamlfile if yamlfile.is_file() else Path()  # Can be used to signal that the bidsmap is empty
+        self.filepath = yamlfile if yamlfile.is_file() else Path()
         """The full path to the bidsmap yaml-file"""
         if not yamlfile.is_file():
-            if yamlfile.name: LOGGER.info(f"No existing bidsmap file found: {yamlfile}")
+            if yamlfile.name: LOGGER.info(f"No bidsmap file found: {yamlfile}")
             return
 
         # Read the heuristics from the bidsmap file
@@ -934,13 +952,10 @@ def __init__(self, yamlfile: Path, folder: Path=templatefolder, plugins: Iterabl
                         LOGGER.info(f"Adding default bidsmappings from the {plugin} plugin")
                         bidsmap[dataformat] = datasection
 
-        self.dataformats = [DataFormat(dataformat, bidsmap[dataformat], self.options, self.plugins) for dataformat in bidsmap if dataformat not in ('$schema', 'Options')]
-        """Gets a list of the DataFormat objects in the bidsmap (e.g. DICOM)"""
-
         # Add missing provenance info, run dictionaries and bids entities
         for dataformat in self.dataformats:
             for datatype in dataformat.datatypes:
-                for index, runitem in enumerate(datatype.runitems or []):
+                for index, runitem in enumerate(datatype.runitems):
 
                     # Add missing provenance info
                     if not runitem.provenance:
@@ -1014,10 +1029,38 @@ def plugins(self, plugins: Plugins):
             self._data['Options'] = {}
         self._data['Options']['plugins'] = plugins
 
+    @property
+    def dataformats(self):
+        """Gets a list of the DataFormat objects in the bidsmap (e.g. DICOM)"""
+
+        return [DataFormat(dataformat, self._data[dataformat], self.options, self.plugins) for dataformat in self._data if dataformat not in ('$schema', 'Options')]
+
     def dataformat(self, dataformat: str) -> DataFormat:
         """Gets the DataFormat object from the bidsmap"""
 
-        return DataFormat(dataformat, self._data.get(dataformat,{}), self.options, self.plugins)
+        return DataFormat(dataformat, self._data[dataformat], self.options, self.plugins)
+
+    def add_dataformat(self, dataformat: Union[str, DataFormat]):
+        """Adds a DataFormat to the bidsmap"""
+
+        _data      = dataformat._data if isinstance(dataformat, DataFormat) else {}
+        dataformat = str(dataformat)
+        if dataformat not in self._data:
+            LOGGER.bcdebug(f"Adding the '{dataformat}' dataformat to {self}")
+            self._data[dataformat] = _data
+        else:
+            LOGGER.bcdebug(f"The {self} bidsmap already contains the '{dataformat}' dataformat")
+
+    def remove_dataformat(self, dataformat: str):
+        """Removes a DataFormat from the bidsmap"""
+
+        dataformat = str(dataformat)
+        if dataformat not in self._data:
+            LOGGER.bcdebug(f"The '{dataformat}' dataformat could not be removed from {self}")
+            return
+        else:
+            self._data.pop(dataformat, None)
+            LOGGER.bcdebug(f"The '{dataformat}' dataformat was removed from {self}")
 
     def save(self, filename: Path=None):
         """
@@ -1032,7 +1075,7 @@ def save(self, filename: Path=None):
 
         filename = filename or self.filepath
         filename.parent.mkdir(parents=True, exist_ok=True)
-        LOGGER.info(f"Writing bidsmap to: {filename}")
+        LOGGER.info(f"Saving bidsmap in: {filename}")
         with filename.open('w') as stream:
             yaml.dump(self._data, stream)
 
@@ -1100,7 +1143,7 @@ def check(self, checks: Tuple[bool, bool, bool]=(True, True, True)) -> Tuple[Uni
                 for runitem in datatype.runitems:
                     bidsname = runitem.bidsname(validkeys=False)
                     if check_ignore(bidsname+'.json', self.options['bidsignore'], 'file'): continue
-                    isvalid = runitem.check(datatype, checks)
+                    isvalid = runitem.check(checks)
                     results = [result and valid for result, valid in zip(results, isvalid)]
 
         if all([result is True for result, check in zip(results, checks) if check is True]):
@@ -1176,7 +1219,7 @@ def dir(self, dataformat: Union[str, DataFormat]) -> List[Path]:
         for datatype in self.dataformat(str(dataformat)).datatypes:
             for runitem in datatype.runitems:
                 if not runitem.provenance:
-                    LOGGER.warning(f'The bidsmap run {datatype} run does not contain provenance data')
+                    LOGGER.warning(f'The bidsmap {datatype} run does not contain provenance data')
                 else:
                     provenance.append(Path(runitem.provenance))
 
@@ -1204,20 +1247,20 @@ def exist_run(self, runitem: RunItem, datatype: Union[str, DataType]='') -> bool
         if datatype not in self.dataformat(runitem.dataformat).datatypes:
             return False
 
-        for run in self.dataformat(runitem.dataformat).datatype(datatype).runitems:
+        for _runitem in self.dataformat(runitem.dataformat).datatype(datatype).runitems:
 
-            # Begin with match = True unless all properties and attributes are empty
-            match = any([getattr(run, attr)[key] not in (None,'') for attr in ('properties','attributes') for key in getattr(run, attr)])
+            # Begin with match = True unless all run properties and attributes are empty
+            match = any([getattr(_runitem, attr)[key] not in (None,'') for attr in ('properties','attributes') for key in getattr(_runitem, attr)])
 
             # TODO: Test if the run has more attributes than the runitem
 
             # Test if all properties and attributes of the runitem match with the run
             for attr in ('properties', 'attributes'):
                 for itemkey, itemvalue in getattr(runitem, attr).items():
-                    value = getattr(run, attr).get(itemkey)     # Matching labels which exist in one datatype but not in the other -> None
+                    value = getattr(_runitem, attr).get(itemkey)     # Matching labels which exist in one datatype but not in the other -> None
                     match = match and match_runvalue(itemvalue, value)
                     if not match:
-                        break                                   # There is no point in searching further within the run now that we've found a mismatch
+                        break                                       # There is no point in searching further within the run now that we've found a mismatch
 
             # Stop searching if we found a matching runitem (i.e. which is the case if match is still True after all run tests)
             if match:
@@ -1233,42 +1276,45 @@ def get_matching_run(self, datasource: DataSource, runtime=False) -> Tuple[RunIt
 
         ignoredatatypes (e.g. 'exclude') -> normal bidsdatatypes (e.g. 'anat') -> unknowndatatypes (e.g. 'extra_data')
 
-        :param datasource:  The data source from which the attributes are read. NB: The datasource.datatype attribute is updated
+        :param datasource:  The data source from which the attributes are read
         :param runtime:     Dynamic <<values>> are expanded if True
-        :return:            (run, provenance) The returned run has all its attributes populated with the source file attributes.
-                            If there is a match, the provenance of the bidsmap entry is returned, otherwise it will be ''.
-                            NB: The run._data dictionary is NOT bounded to the bidsmap._data dictionary!
+        :return:            (run, provenance) A vanilla run that has all its attributes populated with the source file attributes.
+                            If there is a match, the provenance of the bidsmap entry is returned, otherwise it will be ''
         """
 
-        unknowndatatypes = self.options.get('unknowntypes') or []
+        unknowndatatypes = self.options.get('unknowntypes') or ['unknown_data']
         ignoredatatypes  = self.options.get('ignoretypes') or []
         bidsdatatypes    = [dtype.datatype for dtype in self.dataformat(datasource.dataformat).datatypes if dtype not in unknowndatatypes + ignoredatatypes]
-        run_             = RunItem('', '', {}, datasource, self.options, self.plugins)
-        """The cleanly populated output run item"""
+        datasource       = copy.deepcopy(datasource)
+        rundata          = {'provenance': str(datasource.path), 'properties': {}, 'attributes': {}, 'bids': {}, 'meta': {}}
+        """The a run-item data structure. NB: Keep in sync with the RunItem() data attributes"""
 
-        # Loop through all datatypes and runs; all info goes cleanly into run_ (to avoid formatting problem of the CommentedMap)
+        # Loop through all datatypes and runs; all info goes cleanly into runitem (to avoid formatting problem of the CommentedMap)
         if 'fmap' in bidsdatatypes:
             bidsdatatypes.insert(0, bidsdatatypes.pop(bidsdatatypes.index('fmap')))  # Put fmap at the front (to catch inverted polarity scans first
-        for datatype in ignoredatatypes + bidsdatatypes + unknowndatatypes:         # The ordered datatypes in which a matching run is searched for
-
-            for run in self.dataformat(datasource.dataformat).datatype(datatype).runitems:
+        for datatype in ignoredatatypes + bidsdatatypes + unknowndatatypes:                 # The ordered datatypes in which a matching run is searched for
+            if datatype not in self.dataformat(datasource.dataformat).datatypes: continue
+            for runitem in self.dataformat(datasource.dataformat).datatype(datatype).runitems:
 
                 # Begin with match = True unless all properties and attributes are empty
-                match = any([getattr(run, attr)[key] not in (None,'') for attr in ('properties','attributes') for key in getattr(run, attr)])
-                run_  = RunItem('', datatype, {}, datasource, self.options, self.plugins)     # (Re)populate the run item
+                match = any([getattr(runitem, attr)[key] not in (None,'') for attr in ('properties','attributes') for key in getattr(runitem, attr)])
+
+                # Initialize a clean run-item data structure
+                rundata = {'provenance': str(datasource.path), 'properties': {}, 'attributes': {}, 'bids': {}, 'meta': {}}
 
-                # Test if the data source matches all the non-empty run-item properties, but do not populate them
-                for propkey, propvalue in run.properties.items():
+                # Test if the data source matches all the non-empty run-item properties, but do NOT populate them
+                for propkey, propvalue in runitem.properties.items():
 
+                    # Check if the property value matches with the info from the sourcefile
                     if propvalue:
                         sourcevalue = datasource.properties(propkey)
                         match       = match and match_runvalue(sourcevalue, propvalue)
 
-                    # Do not populate the empty attribute with the info from the sourcefile but keep the matching expression
-                    run_.properties[propkey] = propvalue
+                    # Keep the matching expression
+                    rundata['properties'][propkey] = propvalue
 
                 # Test if the data source matches all the run-item attributes and populate all of them
-                for attrkey, attrvalue in run.attributes.items():
+                for attrkey, attrvalue in runitem.attributes.items():
 
                     # Check if the attribute value matches with the info from the sourcefile
                     sourcevalue = datasource.attributes(attrkey, validregexp=True)
@@ -1276,47 +1322,46 @@ def get_matching_run(self, datasource: DataSource, runtime=False) -> Tuple[RunIt
                         match = match and match_runvalue(sourcevalue, attrvalue)
 
                     # Populate the empty attribute with the info from the sourcefile
-                    run_.attributes[attrkey] = sourcevalue
+                    rundata['attributes'][attrkey] = sourcevalue
 
                 # Try to fill the bids-labels
-                for bidskey, bidsvalue in run.bids.items():
-
-                    # NB: bidsvalue can be a (mutable) list
-                    bidsvalue = copy.copy(bidsvalue)
+                for bidskey, bidsvalue in runitem.bids.items():
 
                     # Replace the dynamic bids values, except the dynamic run-index (e.g. <<>>)
                     if bidskey == 'run' and bidsvalue and (bidsvalue.replace('<','').replace('>','').isdecimal() or bidsvalue == '<<>>'):
-                        run_.bids[bidskey] = bidsvalue
+                        rundata['bids'][bidskey] = bidsvalue
                     else:
-                        run_.bids[bidskey] = datasource.dynamicvalue(bidsvalue, runtime=runtime)
-
-                    # SeriesDescriptions (and ProtocolName?) may get a suffix like '_SBRef' from the vendor, try to strip it off
-                    run_ = run_.strip_suffix()
+                        rundata['bids'][bidskey] = datasource.dynamicvalue(bidsvalue, runtime=runtime)
 
                 # Try to fill the meta-data
-                for metakey, metavalue in run.meta.items():
-
-                    # NB: metavalue can be a (mutable) list
-                    metavalue = copy.copy(metavalue)
+                for metakey, metavalue in runitem.meta.items():
 
                     # Replace the dynamic meta values, except the IntendedFor value (e.g. <<task>>)
                     if metakey == 'IntendedFor':
-                        run_.meta[metakey] = metavalue
+                        rundata['meta'][metakey] = metavalue
                     elif metakey in ('B0FieldSource', 'B0FieldIdentifier') and fnmatch(str(metavalue), '*<<session*>>*'):
-                        run_.meta[metakey] = metavalue
+                        rundata['meta'][metakey] = metavalue
                     else:
-                        run_.meta[metakey] = datasource.dynamicvalue(metavalue, cleanup=False, runtime=runtime)
+                        rundata['meta'][metakey] = datasource.dynamicvalue(metavalue, cleanup=False, runtime=runtime)
 
                 # Stop searching the bidsmap if we have a match
                 if match:
-                    LOGGER.bcdebug(f"Found bidsmap match: {run} -> {run_}")
-                    return run_, run.provenance
+                    LOGGER.bcdebug(f"Found bidsmap match: {runitem} -> {runitem}")
+                    runitem = RunItem('', datatype, copy.deepcopy(rundata), datasource, self.options, self.plugins)
+
+                    # SeriesDescriptions (and ProtocolName?) may get a suffix like '_SBRef' from the vendor, try to strip it off
+                    runitem.strip_suffix()
+
+                    return runitem, runitem.provenance
 
         # We don't have a match (all tests failed, so datatype should be the *last* one, e.g. unknowndatatype)
-        LOGGER.bcdebug(f"Found no bidsmap match for: {run_.provenance}")
-        if run_.datatype not in unknowndatatypes:
-            LOGGER.warning(f"Datatype was expected to be in {unknowndatatypes}, instead it is {run_.datatype} -> {run_.provenance}")
-        return run_, ''
+        LOGGER.bcdebug(f"Found no bidsmap match for: {datasource.path}")
+        if datatype not in unknowndatatypes:
+            LOGGER.warning(f"Datatype was expected to be in {unknowndatatypes}, instead it is '{datatype}' -> {datasource.path}")
+
+        runitem = RunItem('', datatype, copy.deepcopy(rundata), datasource, self.options, self.plugins)
+        runitem.strip_suffix()
+        return runitem, ''
 
     def get_run(self, datatype: Union[str, DataType], suffix_idx: Union[int, str], datasource: DataSource) -> RunItem:
         """
@@ -1325,14 +1370,17 @@ def get_run(self, datatype: Union[str, DataType], suffix_idx: Union[int, str], d
         :param datatype:    The datatype in which a matching run is searched for (e.g. 'anat')
         :param suffix_idx:  The name of the suffix that is searched for (e.g. 'bold') or the datatype index number
         :param datasource:  The datasource with the provenance file from which the properties, attributes and dynamic values are read
-        :return:            The clean (filled) run item in the bidsmap[dataformat][bidsdatatype] with the matching suffix_idx,
+        :return:            A populated run-item that is deepcopied from bidsmap[dataformat][bidsdatatype] with the matching suffix_idx,
                             otherwise an empty dict
         """
 
         datatype = str(datatype)
 
-        for index, runitem in enumerate(self.dataformat(datasource.dataformat).datatype(datatype).runitems):
-            if index == suffix_idx or runitem.bids['suffix'] == suffix_idx:
+        for index, _runitem in enumerate(self.dataformat(datasource.dataformat).datatype(datatype).runitems):
+            if index == suffix_idx or _runitem.bids['suffix'] == suffix_idx:
+
+                runitem = copy.deepcopy(_runitem)
+                runitem.provenance = str(datasource.path)
 
                 for propkey, propvalue in runitem.properties.items():
                     runitem.properties[propkey] = propvalue
@@ -1346,8 +1394,6 @@ def get_run(self, datatype: Union[str, DataType], suffix_idx: Union[int, str], d
                 # Replace the dynamic bids values, except the dynamic run-index (e.g. <<>>)
                 for bidskey, bidsvalue in runitem.bids.items():
 
-                    # NB: bidsvalue can be a (mutable) list
-                    bidsvalue = copy.copy(bidsvalue)
                     if bidskey == 'run' and bidsvalue and (bidsvalue.replace('<','').replace('>','').isdecimal() or bidsvalue == '<<>>'):
                         runitem.bids[bidskey] = bidsvalue
                     else:
@@ -1356,8 +1402,6 @@ def get_run(self, datatype: Union[str, DataType], suffix_idx: Union[int, str], d
                 # Replace the dynamic meta values, except the IntendedFor value (e.g. <<task>>)
                 for metakey, metavalue in runitem.meta.items():
 
-                    # NB: metavalue can be a (mutable) list
-                    metavalue = copy.copy(metavalue)
                     if metakey == 'IntendedFor':
                         runitem.meta[metakey] = metavalue
                     elif metakey in ('B0FieldSource', 'B0FieldIdentifier') and fnmatch(str(metavalue), '*<<session*>>*'):
@@ -1376,14 +1420,14 @@ def find_run(self, provenance: str, dataformat: Union[str, DataFormat]='', datat
         :param provenance:  The unique provenance that is used to identify the run
         :param dataformat:  The dataformat section in the bidsmap in which a matching run is searched for, e.g. 'DICOM'. Otherwise, all dataformats are searched
         :param datatype:    The datatype in which a matching run is searched for (e.g. 'anat'). Otherwise, all datatypes are searched
-        :return:            The (unfilled) run item from the bidsmap[dataformat][bidsdatatype]
+        :return:            The unpopulated run-item that is taken as is from the bidsmap[dataformat][bidsdatatype]
         """
 
         dataformat = str(dataformat)
         datatype   = str(datatype)
 
         for dataformat in [self.dataformat(dataformat)] if dataformat else self.dataformats:
-            datatypes = [dataformat.datatype(datatype)] if datatype else dataformat.datatypes
+            datatypes = [dataformat.datatype(datatype)] if datatype in dataformat.datatypes else [] if datatype else dataformat.datatypes
             for dtype in datatypes:
                 for runitem in dtype.runitems:
                     if Path(runitem.provenance) == Path(provenance):
@@ -1393,7 +1437,7 @@ def find_run(self, provenance: str, dataformat: Union[str, DataFormat]='', datat
 
     def delete_run(self, provenance: Union[RunItem, str], datatype: Union[str, DataType]='', dataformat: Union[str, DataFormat]=''):
         """
-        Delete the first matching run from the BIDS map
+        Delete the first matching run from the BIDS map using its provenance
 
         :param provenance:  The provenance identifier of/or the run-item that is deleted
         :param datatype:    The datatype that of the deleted runitem, e.g. 'anat'
@@ -1415,22 +1459,24 @@ def delete_run(self, provenance: Union[RunItem, str], datatype: Union[str, DataT
 
     def insert_run(self, runitem: RunItem, position: int=None):
         """
-        Inserts a run-item to the BIDS map (e.g. allowing you to insert a run-item from another bidsmap).
+        Inserts a run-item (as is) to the BIDS map (e.g. allowing you to insert a run-item from another bidsmap).
         Optionally, a copy of the datasource is stored in the provenance store
 
-        :param runitem:     The (cleaned orphan) run item that is appended to the list of run items of its datatype
+        :param runitem:     The (typically cleaned orphan) run item that is appended to the list of run items of its datatype
         :param position:    The position at which the run is inserted. The run is appended at the end if position is None
         """
 
         # Work from the provenance store if given (the store source and target are set during bidsmapper runtime)
-        if self.store and runitem.datasource.path.is_file():
-            targetfile = self.store['target']/runitem.datasource.path.relative_to(self.store['source'])
+        sourcefile = Path(runitem.provenance)
+        if self.store and sourcefile.is_file():
+            targetfile = self.store['target']/sourcefile.relative_to(self.store['source'])
             if not targetfile.is_file():
                 targetfile.parent.mkdir(parents=True, exist_ok=True)
                 LOGGER.verbose(f"Storing a copy of the discovered sample: {targetfile}")
-                runitem.provenance = str(shutil.copyfile(runitem.datasource.path, targetfile))
+                runitem.provenance = str(shutil.copyfile(sourcefile, targetfile))
 
         # Insert the run item
+        self.add_dataformat(runitem.dataformat)                             # Add the dataformat if it doesn't exist
         self.dataformat(runitem.dataformat).add_datatype(runitem.datatype)  # Add the datatype if it doesn't exist
         self.dataformat(runitem.dataformat).datatype(runitem.datatype).insert_run(runitem, position)
 
@@ -1448,27 +1494,28 @@ def update(self, source_datatype: Union[str, DataType], runitem: RunItem):
         :param runitem:         The run item that is being moved to its new runitem.datatype
         """
 
-        dataformat   = runitem.dataformat
         new_datatype = runitem.datatype
-        num_runs_in  = len(self.dir(dataformat))
+        num_runs_in  = len(self.dir(runitem.dataformat))
 
-        # Warn the user if the target run already exists when the run is moved to another datatype
         if source_datatype != new_datatype:
-            if self.exist_run(runitem, new_datatype):
-                LOGGER.error(f'The "{source_datatype}" run already exists in {new_datatype}...')
+
+            # Warn the user if the target run already exists when the run is moved to another datatype
+            if self.find_run(runitem.provenance, runitem.dataformat, new_datatype):
+                LOGGER.error(f'The "{source_datatype}" run already exists in {runitem}')
 
             # Delete the source run
-            self.delete_run(runitem, source_datatype)
+            self.delete_run(runitem, source_datatype, runitem.dataformat)
 
             # Append the (cleaned-up) target run
             self.insert_run(runitem)
 
         else:
-            self.dataformat(dataformat).datatype(new_datatype).replace_run(runitem)
 
-        num_runs_out = len(self.dir(dataformat))
+            self.dataformat(runitem.dataformat).datatype(new_datatype).replace_run(runitem)
+
+        num_runs_out = len(self.dir(runitem.dataformat))
         if num_runs_out != num_runs_in:
-            LOGGER.error(f"Number of runs in bidsmap['{dataformat}'] changed unexpectedly: {num_runs_in} -> {num_runs_out}")
+            LOGGER.error(f"Number of runs in bidsmap['{runitem.dataformat}'] changed unexpectedly: {num_runs_in} -> {num_runs_out}")
 
 
 def unpack(sesfolder: Path, wildcard: str='', workfolder: Path='', _subprefix: Union[str,None]='') -> Tuple[Set[Path], bool]:
@@ -1643,15 +1690,15 @@ def get_datasource(sourcedir: Path, plugins: Plugins, recurse: int=8) -> DataSou
 
     datasource = DataSource()
     if sourcedir.is_dir():
-        for item in sorted(sourcedir.iterdir()):
-            if item.name.startswith('.'):
-                LOGGER.verbose(f"Ignoring hidden data-source: {item}")
+        for sourcepath in sorted(sourcedir.iterdir()):
+            if sourcepath.name.startswith('.'):
+                LOGGER.verbose(f"Ignoring hidden data-source: {sourcepath}")
                 continue
-            if item.is_dir() and recurse:
-                datasource = get_datasource(item, plugins, recurse-1)
-            elif item.is_file():
-                datasource = DataSource(item, plugins)
-            if datasource.dataformat:
+            if sourcepath.is_dir() and recurse:
+                datasource = get_datasource(sourcepath, plugins, recurse-1)
+            elif sourcepath.is_file():
+                datasource = DataSource(sourcepath, plugins)
+            if datasource.has_plugin():
                 return datasource
 
     return datasource
@@ -2217,9 +2264,9 @@ def insert_bidskeyval(bidsfile: Union[str, Path], bidskey: str, newvalue: str, v
     bidsext  = ''.join(Path(bidsfile).suffixes)
 
     # Parse the key-value pairs and store all the run info
-    run   = RunItem()
-    subid = ''
-    sesid = ''
+    runitem = RunItem()
+    subid   = ''
+    sesid   = ''
     for keyval in bidsname.split('_'):
         if '-' in keyval:
             key, val = keyval.split('-', 1)
@@ -2228,11 +2275,11 @@ def insert_bidskeyval(bidsfile: Union[str, Path], bidskey: str, newvalue: str, v
             elif key == 'ses':
                 sesid = keyval
             else:
-                run.bids[key] = val
+                runitem.bids[key] = val
         else:
-            run.bids['suffix'] = f"{run.bids.get('suffix','')}_{keyval}"     # account for multiple suffixes (e.g. _bold_e1_ph from dcm2niix)
-    if run.bids.get('suffix','').startswith('_'):
-        run.bids['suffix'] = run.bids['suffix'][1:]
+            runitem.bids['suffix'] = f"{runitem.bids.get('suffix','')}_{keyval}"     # account for multiple suffixes (e.g. _bold_e1_ph from dcm2niix)
+    if runitem.bids.get('suffix','').startswith('_'):
+        runitem.bids['suffix'] = runitem.bids['suffix'][1:]
 
     # Insert the key-value pair in the run
     if bidskey == 'sub':
@@ -2240,10 +2287,10 @@ def insert_bidskeyval(bidsfile: Union[str, Path], bidskey: str, newvalue: str, v
     elif bidskey == 'ses':
         sesid = newvalue
     else:
-        run.bids[bidskey] = newvalue
+        runitem.bids[bidskey] = newvalue
 
     # Compose the new filename
-    newbidsfile = (bidspath / run.bidsname(subid, sesid, validkeys, cleanup=False)).with_suffix(bidsext)
+    newbidsfile = (bidspath/runitem.bidsname(subid, sesid, validkeys, cleanup=False)).with_suffix(bidsext)
 
     if isinstance(bidsfile, str):
         newbidsfile = str(newbidsfile)
diff --git a/bidscoin/bidsapps/deface.py b/bidscoin/bidsapps/deface.py
index 6aba53d2..10a68418 100755
--- a/bidscoin/bidsapps/deface.py
+++ b/bidscoin/bidsapps/deface.py
@@ -167,9 +167,9 @@ def main():
     try:
         deface(**vars(args))
 
-    except Exception:
+    except Exception as error:
         trackusage('deface_exception')
-        raise
+        raise error
 
 
 if __name__ == '__main__':
diff --git a/bidscoin/bidsapps/echocombine.py b/bidscoin/bidsapps/echocombine.py
index 9d766ee3..a2aee9f6 100755
--- a/bidscoin/bidsapps/echocombine.py
+++ b/bidscoin/bidsapps/echocombine.py
@@ -213,9 +213,9 @@ def main():
     try:
         echocombine(**vars(args))
 
-    except Exception:
+    except Exception as error:
         trackusage('echocombine_exception')
-        raise
+        raise error
 
 
 if __name__ == '__main__':
diff --git a/bidscoin/bidsapps/fixmeta.py b/bidscoin/bidsapps/fixmeta.py
index a7c03c1d..2e5fe86a 100755
--- a/bidscoin/bidsapps/fixmeta.py
+++ b/bidscoin/bidsapps/fixmeta.py
@@ -53,9 +53,9 @@ def fixmeta(bidsfolder: str, pattern: str, metadata: dict, participant: list, bi
     LOGGER.info(f"Command: fixmeta {' '.join(sys.argv[1:])}")
 
     # Load the bidsmap data (-> plugins)
-    bidsmap, _ = bids.BidsMap(Path(bidsmap or 'bidsmap.yaml'), bidsdir/'code'/'bidscoin', checks=(False, False, False))
-    if not bidsmap:
-        bidsmap, _ = bids.BidsMap(bidsmap_template, checks=(False, False, False))
+    bidsmap = bids.BidsMap(Path(bidsmap or 'bidsmap.yaml'), bidsdir/'code'/'bidscoin', checks=(False, False, False))
+    if not bidsmap.filepath:
+        bidsmap = bids.BidsMap(bidsmap_template, checks=(False, False, False))
     plugins  = bidsmap.plugins
     provdata = bids.bidsprov(bidsdir)
 
@@ -117,9 +117,9 @@ def main():
     try:
         fixmeta(**vars(args))
 
-    except Exception:
+    except Exception as error:
         trackusage('fixmeta_exception')
-        raise
+        raise error
 
 
 if __name__ == '__main__':
diff --git a/bidscoin/bidsapps/medeface.py b/bidscoin/bidsapps/medeface.py
index e21d7802..4f893f9f 100755
--- a/bidscoin/bidsapps/medeface.py
+++ b/bidscoin/bidsapps/medeface.py
@@ -215,9 +215,9 @@ def main():
     try:
         medeface(**vars(args))
 
-    except Exception:
+    except Exception as error:
         trackusage('medeface_exception')
-        raise
+        raise error
 
 
 if __name__ == '__main__':
diff --git a/bidscoin/bidsapps/skullstrip.py b/bidscoin/bidsapps/skullstrip.py
index e8f253de..5c2d9f97 100755
--- a/bidscoin/bidsapps/skullstrip.py
+++ b/bidscoin/bidsapps/skullstrip.py
@@ -245,9 +245,9 @@ def main():
     try:
         skullstrip(**vars(args))
 
-    except Exception:
+    except Exception as error:
         trackusage('skullstrip_exception')
-        raise
+        raise error
 
 
 if __name__ == '__main__':
diff --git a/bidscoin/bidsapps/slicereport.py b/bidscoin/bidsapps/slicereport.py
index 4ddd094a..b67bedbb 100755
--- a/bidscoin/bidsapps/slicereport.py
+++ b/bidscoin/bidsapps/slicereport.py
@@ -50,7 +50,7 @@ def parse_options(options: list) -> str:
     for n, option in enumerate(options):
         if options[n-1] == 'l': continue                  # Skip checking the LUT string
         if not (option in ('L','l','i','e','t','n','u','s','c') or option.replace('.','').replace('-','').isdecimal()):
-            print(f"Invalid OPTIONS: {' '.join(options)}"); sys.exit(2)
+            raise SystemExit(f"[ERROR] Invalid OPTIONS: {' '.join(options)}")
         if option.isalpha():
             options[n] = '-' + options[n]
 
@@ -68,18 +68,18 @@ def parse_outputs(outputargs: list, name: str) -> tuple:
     isnumber = lambda arg: arg.replace('.','').replace('-','').isdecimal()
     for n, outputarg in enumerate(outputargs):
         if not (outputarg in ('x', 'y', 'z', 'a', 'A', 'S', 'LF') or isnumber(outputarg)):
-            print(f"Invalid {name}: '{outputarg}' in '{' '.join(outputargs)}'"); sys.exit(2)
+            raise SystemExit(f"[ERROR] Invalid {name}: '{outputarg}' in '{' '.join(outputargs)}'")
         if outputarg.isalpha() and outputarg != 'LF':
             slices += f"{'' if n==0 else '-' if outputargs[n-1]=='LF' else '+'} slice_tmp{n}.png "
             if outputarg == 'a':
                 outputs += f"-{outputarg} slice_tmp{n}.png "
             elif outputarg in ('x', 'y', 'z', 'A'):
                 if not isnumber(outputargs[n+1]):
-                    print(f"Invalid {name}: '{outputargs[n+1]}' in '{' '.join(outputargs)}'"); sys.exit(2)
+                    raise SystemExit(f"[ERROR] Invalid {name}: '{outputargs[n+1]}' in '{' '.join(outputargs)}'")
                 outputs += f"-{outputarg} {outputargs[n+1]} slice_tmp{n}.png "
             elif outputarg == 'S':
                 if not (isnumber(outputargs[n+1]) and isnumber(outputargs[n+2])):
-                    print(f"Invalid {name}: {outputarg} >> '{' '.join(outputargs)}'"); sys.exit(2)
+                    raise SystemExit(f"[ERROR] Invalid {name}: {outputarg} >> '{' '.join(outputargs)}'")
                 outputs += f"-{outputarg} {outputargs[n+1]} {outputargs[n+2]} slice_tmp{n}.png "
 
     return outputs, slices
@@ -135,7 +135,7 @@ def slicer_append(inputimage: Path, operations: str, outlineimage: Path, mainopt
         if process.stderr or process.returncode != 0:
             LOGGER.warning(f"{command}\nErrorcode {process.returncode}:\n{process.stdout}\n{process.stderr}")
         if process.returncode != 0:
-            sys.exit(process.returncode)
+            raise SystemExit(process.returncode)
 
 
 def slicereport(bidsfolder: str, pattern: str, outlinepattern: str, outlineimage: str, participant: list, reportfolder: str, xlinkfolder: str, qcscores: list, cluster: str, operations: str, suboperations: str, options: list, outputs: list, suboptions: list, suboutputs: list):
@@ -330,9 +330,9 @@ def main():
     try:
         slicereport(**vars(args))
 
-    except Exception:
+    except Exception as error:
         trackusage('slicereport_exception')
-        raise
+        raise error
 
 
 if __name__ == '__main__':
diff --git a/bidscoin/bidscoiner.py b/bidscoin/bidscoiner.py
index 4bc47761..fb056a5a 100755
--- a/bidscoin/bidscoiner.py
+++ b/bidscoin/bidscoiner.py
@@ -44,8 +44,7 @@ def bidscoiner(sourcefolder: str, bidsfolder: str, participant: list=(), force:
     bidscoinfolder = bidsfolder/'code'/'bidscoin'
     bidscoinfolder.mkdir(parents=True, exist_ok=True)
     if not rawfolder.is_dir():
-        print(f"Rawfolder '{rawfolder}' not found")
-        return
+        raise SystemExit(f"\n[ERROR] Exiting the program because your sourcefolder argument '{sourcefolder}' was not found")
 
     # Start logging
     bcoin.setup_logging(bidscoinfolder/'bidscoiner.log')
@@ -81,7 +80,7 @@ def bidscoiner(sourcefolder: str, bidsfolder: str, participant: list=(), force:
 
     # Create a README file if it does not exist
     readme_file = bidsfolder/'README'
-    if not (readme_file.is_file() or next(bidsfolder.glob('README.*'))):
+    if not (readme_file.is_file() or next(bidsfolder.glob('README.*'), None)):
         LOGGER.info(f"Creating a template README file (adjust it to your needs): {readme_file}")
         try:
             urllib.request.urlretrieve('https://raw.githubusercontent.com/bids-standard/bids-starter-kit/main/templates/README.MD', readme_file)
@@ -150,7 +149,7 @@ def bidscoiner(sourcefolder: str, bidsfolder: str, participant: list=(), force:
 
                 # Check if we should skip the session-folder
                 datasource = bids.get_datasource(subject, bidsmap.plugins)
-                subid,_    = datasource.subid_sesid(bidsmap[datasource.dataformat]['subject'], bidsmap[datasource.dataformat]['session'])
+                subid,_    = datasource.subid_sesid(bidsmap.dataformat(datasource.dataformat).subject, bidsmap.dataformat(datasource.dataformat).session)
                 if (bidsfolder/subid).is_dir() and not force:
                     LOGGER.info(f">>> Skipping already processed subject: {bidsfolder/subid} (you can use the -f option to overrule)")
                     continue
@@ -263,15 +262,15 @@ def bidscoiner(sourcefolder: str, bidsfolder: str, participant: list=(), force:
                     if not datasource.dataformat:
                         LOGGER.info(f">>> No datasources found in '{sesfolder}'")
                         continue
-                    subid        = bidsmap[datasource.dataformat]['subject']
-                    sesid        = bidsmap[datasource.dataformat]['session']
+                    subid        = bidsmap.dataformat(datasource.dataformat).subject
+                    sesid        = bidsmap.dataformat(datasource.dataformat).session
                     subid, sesid = datasource.subid_sesid(subid, sesid or '')
                     bidssession  = bidsfolder/subid/sesid       # TODO: Support DICOMDIR with multiple subjects (as in PYDICOMDIR)
                     if not force and bidssession.is_dir():
                         datatypes = set()
-                        for dataformat in dataformats:
-                            for datatype in lsdirs(bidssession):                               # See what datatypes we already have in the bids session-folder
-                                if list(datatype.iterdir()) and bidsmap[dataformat].get(datatype.name): # See if we are going to add data for this datatype
+                        for datatype in [dtype for dtype in lsdirs(bidssession) if next(dtype.iterdir())]:  # See what non-empty datatypes we already have in the bids session-folder
+                            for dataformat in bidsmap.dataformats:
+                                if datatype.name in dataformat.datatypes:                                   # See if we are going to add data for this datatype
                                     datatypes.add(datatype.name)
                         if datatypes:
                             LOGGER.info(f">>> Skipping processed session: {bidssession} already has {datatypes} data (you can carefully use the -f option to overrule)")
@@ -320,9 +319,9 @@ def main():
     try:
         bidscoiner(**vars(args))
 
-    except Exception:
+    except Exception as error:
         trackusage('bidscoiner_exception')
-        raise
+        raise error
 
 
 if __name__ == "__main__":
diff --git a/bidscoin/bidseditor.py b/bidscoin/bidseditor.py
index 8edb76ea..2ca984ee 100755
--- a/bidscoin/bidseditor.py
+++ b/bidscoin/bidseditor.py
@@ -95,17 +95,23 @@ def __init__(self, bidsfolder: Path, input_bidsmap: BidsMap, template_bidsmap: B
                 input_bidsmap = copy.deepcopy(template_bidsmap)
                 for dataformat in input_bidsmap.dataformats:
                     for datatype in dataformat.datatypes:
-                        datatype.delete_runs()
+                        dataformat.delete_runs(datatype)
 
         # Keep track of the EditWindow status
-        self.editwindow_opened: Union[str,None] = None                   # The provenance string of the run-item that is opened in the EditWindow
+        self.editwindow_opened: Union[str,None] = None
+        """The provenance of the run-item that is opened in the EditWindow"""
 
         # Set the input data
-        self.bidsfolder: Path            = Path(bidsfolder)              # The folder where the bids data is / will be stored
-        self.input_bidsmap               = input_bidsmap                 # The original/unedited bidsmap
-        self.output_bidsmap              = copy.deepcopy(input_bidsmap)  # The edited bidsmap
-        self.template_bidsmap            = template_bidsmap              # The bidsmap from which new data type run-items are taken
-        self.datasaved: bool             = datasaved                     # True if data has been saved on disk
+        self.bidsfolder                  = Path(bidsfolder)
+        """The folder where the bids data is / will be stored"""
+        self.input_bidsmap               = input_bidsmap
+        """The original/unedited bidsmap"""
+        self.output_bidsmap              = copy.deepcopy(input_bidsmap)
+        """The edited bidsmap"""
+        self.template_bidsmap            = template_bidsmap
+        """The bidsmap from which new data type run-items are taken"""
+        self.datasaved                   = datasaved
+        """True if data has been saved on disk"""
         self.dataformats                 = [dataformat.dataformat for dataformat in input_bidsmap.dataformats if input_bidsmap.dir(dataformat)]
         self.bidsignore: List[str]       = input_bidsmap.options['bidsignore']
         self.unknowndatatypes: List[str] = input_bidsmap.options['unknowntypes']
@@ -116,17 +122,20 @@ def __init__(self, bidsfolder: Path, input_bidsmap: BidsMap, template_bidsmap: B
         tabwidget.setTabPosition(QtWidgets.QTabWidget.TabPosition.North)
         tabwidget.setTabShape(QtWidgets.QTabWidget.TabShape.Rounded)
 
-        self.subses_table: dict       = {}
-        self.samples_table: dict      = {}
-        self.options_label: dict      = {}
-        self.options_table: dict      = {}
-        self.ordered_file_index: dict = {}  # The mapping between the ordered provenance and an increasing file-index
+        self.subses_table       = {}
+        self.samples_table      = {}
+        self.options_label      = {}
+        self.options_table      = {}
+        self.ordered_file_index = {}
+        """The mapping between the ordered provenance and an increasing file-index"""
         for dataformat in self.dataformats:
             self.set_tab_bidsmap(dataformat)
         self.set_tab_options()
         self.set_tab_filebrowser()
 
-        self.datachanged: bool = False      # Keep track of the bidsmap data status -> True if data has been edited. Do this after updating all the tables (which assigns datachanged = True)
+        # Set datachanged = False only after all the tables are updated (which assigns datachanged = True)
+        self.datachanged: bool = False
+        """Keeps track of the bidsmap data status -> True if data has been edited"""
 
         # Set up the buttons
         buttonbox = QDialogButtonBox()
@@ -191,40 +200,35 @@ def show_contextmenu(self, pos):
         dataformat = self.tabwidget.widget(self.tabwidget.currentIndex()).objectName()
         table      = self.samples_table[dataformat]
         colindex   = table.currentColumn()
-        rowindex   = [index.row() for index in table.selectedIndexes() if index.column() == colindex]
-        if rowindex and colindex in (-1, 0, 4):      # User clicked the index, the edit-button or elsewhere (i.e. not on an activated widget)
+        rowindexes = [index.row() for index in table.selectedIndexes() if index.column() == colindex]
+        if rowindexes and colindex in (-1, 0, 4):      # User clicked the index, the edit-button or elsewhere (i.e. not on an activated widget)
             return
-        runs: List[RunItem] = []
+        runitems: List[RunItem] = []
         subids: List[str]   = []
         sesids: List[str]   = []
-        for index in rowindex:
+        for index in rowindexes:
             datatype   = table.item(index, 2).text()
             provenance = table.item(index, 5).text()
-            runs.append(self.output_bidsmap.find_run(provenance, dataformat, datatype))
+            runitems.append(self.output_bidsmap.find_run(provenance, dataformat, datatype))
             subids.append(bids.get_bidsvalue(table.item(index, 3).text(), 'sub'))
             sesids.append(bids.get_bidsvalue(table.item(index, 3).text(), 'ses'))
 
-        # Get the datatypes for the dataformat(s)
-        datatypes = set()
-        for dtype in self.template_bidsmap.dataformat(dataformat).datatypes:
-            datatypes.add(dtype.datatype)
-        datatypes = sorted(datatypes)
-
         # Pop-up the context-menu
         menu    = QtWidgets.QMenu(self)
         compare = menu.addAction('Compare')
-        compare.setEnabled(len(rowindex) > 1)
+        compare.setEnabled(len(rowindexes) > 1)
         compare.setToolTip('Compare the BIDS mappings of multiple run-items')
         edit    = menu.addAction('Edit')
-        edit.setEnabled(len(rowindex) > 0)
+        edit.setEnabled(len(rowindexes) > 0)
         edit.setToolTip('Edit a single run-item in detail or edit the data type of multiple run-items')
         add     = menu.addAction('Add')
         add.setToolTip('Add a run-item (expert usage)')
         delete  = menu.addAction('Remove')
-        delete.setEnabled(len(rowindex) > 0)
+        delete.setEnabled(len(rowindexes) > 0)
         delete.setToolTip('Delete run-items (expert usage)')
         action  = menu.exec(table.viewport().mapToGlobal(pos))
 
+        datatypes = [dtype.datatype for dtype in self.template_bidsmap.dataformat(dataformat).datatypes]    # Get the datatypes for the dataformat(s)
         if action == add:
             filenames, _ = QFileDialog.getOpenFileNames(self, 'Select the data source(s) for which you want to add a run-item(s)', str(self.bidsfolder))
             if filenames:
@@ -234,23 +238,23 @@ def show_contextmenu(self, pos):
                     for filename in filenames:
                         datasource = bids.DataSource(filename, self.output_bidsmap.plugins, dataformat, self.output_bidsmap.options)
                         if datasource.has_plugin():
-                            run = self.template_bidsmap.get_run(datatype, 0, datasource)
-                            run.properties['filepath'] = datasource.properties('filepath')   # Make the added run a strict match (i.e. an exception)
-                            run.properties['filename'] = datasource.properties('filename')   # Make the added run a strict match (i.e. an exception)
+                            runitem = self.template_bidsmap.get_run(datatype, 0, datasource)
+                            runitem.properties['filepath'] = datasource.properties('filepath')      # Make the added run a strict match (i.e. an exception)
+                            runitem.properties['filename'] = datasource.properties('filename')      # Make the added run a strict match (i.e. an exception)
                             LOGGER.verbose(f"Expert usage: User adds run-item {dataformat}[{datatype}]: {filename}")
                             if Path(filename) in self.output_bidsmap.dir(dataformat):
                                 LOGGER.warning(f"Added run-item {dataformat}[{datatype}]: {filename} already exists")
-                            self.output_bidsmap.insert_run(run, 0)                        # Put the run at the front (so it gets matching priority)
+                            self.output_bidsmap.insert_run(runitem, 0)                      # Put the run at the front (so it gets matching priority)
                             if dataformat not in self.ordered_file_index:
                                 self.ordered_file_index[dataformat] = {datasource.path: 0}
                             else:
                                 self.ordered_file_index[dataformat][datasource.path] = max(self.ordered_file_index[dataformat][fname] for fname in self.ordered_file_index[dataformat]) + 1
                     if datasource.has_plugin():
-                        self.update_subses_samples(self.output_bidsmap, dataformat)
+                        self.update_subses_samples(dataformat)
 
         elif action == delete:
             deleted = False
-            for index in rowindex:
+            for index in rowindexes:
                 datatype   = table.item(index, 2).text()
                 provenance = table.item(index, 5).text()
                 if Path(provenance).is_file():
@@ -259,16 +263,16 @@ def show_contextmenu(self, pos):
                                                   QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.Cancel, QMessageBox.StandardButton.Cancel)
                     if answer != QMessageBox.StandardButton.Yes: continue
                 LOGGER.verbose(f"Expert usage: User removes run-item {dataformat}[{datatype}]: {provenance}")
-                self.output_bidsmap.delete_run(self.output_bidsmap.find_run(provenance, dataformat, datatype))
+                self.output_bidsmap.delete_run(provenance, datatype, dataformat)
                 deleted = True
             if deleted:
-                self.update_subses_samples(self.output_bidsmap, dataformat)
+                self.update_subses_samples(dataformat)
 
         elif action == compare:
-            CompareWindow(runs, subids, sesids)
+            CompareWindow(runitems, subids, sesids)
 
         elif action == edit:
-            if len(rowindex) == 1:
+            if len(rowindexes) == 1:
                 datatype   = table.item(table.currentRow(), 2).text()
                 provenance = table.item(table.currentRow(), 5).text()
                 self.open_editwindow(provenance, datatype)
@@ -278,7 +282,7 @@ def show_contextmenu(self, pos):
                     return
 
                 # Change the datatype for the selected run-items
-                for index in rowindex:
+                for index in rowindexes:
                     datatype   = table.item(index, 2).text()
                     provenance = table.item(index, 5).text()
                     if not Path(provenance).is_file():
@@ -286,17 +290,17 @@ def show_contextmenu(self, pos):
                         continue
 
                     # Get the new run from the template
-                    oldrun = self.output_bidsmap.find_run(provenance, dataformat, datatype)
-                    newrun = self.template_bidsmap.get_run(newdatatype, 0, oldrun.datasource)
-                    if not newrun:
+                    oldrun      = self.output_bidsmap.find_run(provenance, dataformat, datatype)
+                    templaterun = self.template_bidsmap.get_run(newdatatype, 0, oldrun.datasource)
+                    if not templaterun:
                         QMessageBox.warning(self, 'Edit BIDS mapping', f"Cannot find the '{newdatatype}' data type in your template")
                         continue
 
                     # Insert the new run in our output bidsmap
-                    self.output_bidsmap.update(datatype, newrun)
-                    LOGGER.verbose(f"User sets run-item {dataformat}[{datatype} -> {newdatatype}]: {provenance}")
+                    self.output_bidsmap.update(datatype, templaterun)
+                    LOGGER.verbose(f"User sets run-item {datatype} -> {templaterun}")
 
-                self.update_subses_samples(self.output_bidsmap, dataformat)
+                self.update_subses_samples(dataformat)
 
     def set_menu_statusbar(self):
         """Set up the menu and statusbar"""
@@ -418,7 +422,7 @@ def set_tab_bidsmap(self, dataformat: str):
         self.tabwidget.addTab(tab, f"{dataformat} mappings")
         self.tabwidget.setCurrentWidget(tab)
 
-        self.update_subses_samples(self.output_bidsmap, dataformat)
+        self.update_subses_samples(dataformat)
 
     def set_tab_options(self):
         """Set the options tab"""
@@ -504,11 +508,11 @@ def set_tab_filebrowser(self):
 
         self.tabwidget.addTab(tab, 'Data browser')
 
-    def update_subses_samples(self, output_bidsmap: BidsMap, dataformat: str):
+    def update_subses_samples(self, dataformat: str):
         """(Re)populates the sample list with bidsnames according to the bidsmap"""
 
-        self.datachanged    = True
-        self.output_bidsmap = output_bidsmap  # input main window / output from edit window -> output main window
+        self.datachanged = True
+        output_bidsmap   = self.output_bidsmap
 
         # Update the subject/session table
         subitem = MyWidgetItem('subject', iseditable=False)
@@ -530,19 +534,19 @@ def update_subses_samples(self, output_bidsmap: BidsMap, dataformat: str):
         samples_table.setSortingEnabled(False)
         samples_table.clearContents()
         for datatype in output_bidsmap.dataformat(dataformat).datatypes:
-            for run in datatype.runitems:
+            for runitem in datatype.runitems:
 
-                # Check the run and get some data
+                # Check the runitem and get some data
                 dtype        = datatype.datatype
-                validrun     = all(run.check(dtype, checks=(False, False, False))[1:3])
-                provenance   = Path(run.provenance)
+                validrun     = all(runitem.check(checks=(False, False, False))[1:3])
+                provenance   = Path(runitem.provenance)
                 subid        = output_bidsmap.dataformat(dataformat).subject
                 sesid        = output_bidsmap.dataformat(dataformat).session
-                subid, sesid = run.datasource.subid_sesid(subid, sesid or '')
-                bidsname     = run.bidsname(subid, sesid, not bids.check_ignore(datatype,self.bidsignore) and dtype not in self.ignoredatatypes)
+                subid, sesid = runitem.datasource.subid_sesid(subid, sesid or '')
+                bidsname     = runitem.bidsname(subid, sesid, not bids.check_ignore(datatype,self.bidsignore) and dtype not in self.ignoredatatypes)
                 ignore       = bids.check_ignore(datatype, self.bidsignore) or bids.check_ignore(bidsname+'.json', self.bidsignore, 'file')
                 exceptions   = self.output_bidsmap.options['notderivative']
-                if run.datasource.dynamicvalue(run.bids['suffix'], True, True) in bids.get_derivatives(dtype, exceptions):
+                if runitem.datasource.dynamicvalue(runitem.bids['suffix'], True, True) in bids.get_derivatives(dtype, exceptions):
                     session  = self.bidsfolder/'derivatives'/'[manufacturer]'/subid/sesid
                 else:
                     session  = self.bidsfolder/subid/sesid
@@ -550,9 +554,9 @@ def update_subses_samples(self, output_bidsmap: BidsMap, dataformat: str):
 
                 samples_table.setItem(idx, 0, MyWidgetItem(f"{row_index+1:03d}", iseditable=False))
                 samples_table.setItem(idx, 1, MyWidgetItem(provenance.name))
-                samples_table.setItem(idx, 2, MyWidgetItem(dtype))                           # Hidden column
+                samples_table.setItem(idx, 2, MyWidgetItem(dtype))                          # Hidden column
                 samples_table.setItem(idx, 3, MyWidgetItem(Path(dtype)/(bidsname + '.*')))
-                samples_table.setItem(idx, 5, MyWidgetItem(provenance))                         # Hidden column
+                samples_table.setItem(idx, 5, MyWidgetItem(provenance))                     # Hidden column
 
                 samples_table.item(idx, 0).setFlags(QtCore.Qt.ItemFlag.NoItemFlags)
                 samples_table.item(idx, 1).setFlags(QtCore.Qt.ItemFlag.ItemIsEnabled)
@@ -569,9 +573,9 @@ def update_subses_samples(self, output_bidsmap: BidsMap, dataformat: str):
                     elif dtype in self.ignoredatatypes:
                         samples_table.item(idx, 1).setForeground(QtGui.QColor('gray'))
                         samples_table.item(idx, 3).setForeground(QtGui.QColor('gray'))
-                        f = samples_table.item(idx, 3).font()
-                        f.setStrikeOut(True)
-                        samples_table.item(idx, 3).setFont(f)
+                        font = samples_table.item(idx, 3).font()
+                        font.setStrikeOut(True)
+                        samples_table.item(idx, 3).setFont(font)
                         samples_table.item(idx, 3).setToolTip('Gray/Strike-out: This imaging data type will be ignored and not converted BIDS')
                     elif not validrun or dtype in self.unknowndatatypes:
                         samples_table.item(idx, 3).setForeground(QtGui.QColor('red'))
@@ -628,7 +632,7 @@ def subsescell2bidsmap(self, rowindex: int, colindex: int):
             if key and value != oldvalue:
                 LOGGER.verbose(f"User sets {dataformat}['{key}'] from '{oldvalue}' to '{value}'")
                 setattr(self.output_bidsmap.dataformat(dataformat), key, value)
-                self.update_subses_samples(self.output_bidsmap, dataformat)
+                self.update_subses_samples(dataformat)
 
     def open_editwindow(self, provenance: Path=Path(), datatype: str=''):
         """Make sure that index map has been updated"""
@@ -646,17 +650,17 @@ def open_editwindow(self, provenance: Path=Path(), datatype: str=''):
 
         # Check for open edit window, find the right data type index and open the edit window
         if not self.editwindow_opened:
-            # Find the source index of the run in the list of runs (using the provenance) and open the edit window
-            for run in self.output_bidsmap.dataformat(dataformat).datatype(datatype).runitems:
-                if Path(run.provenance) == Path(provenance):
+            # Find the source index of the runitem in the list of runitemss (using the provenance) and open the edit window
+            for runitem in self.output_bidsmap.dataformat(dataformat).datatype(datatype).runitems:
+                if Path(runitem.provenance) == Path(provenance):
                     LOGGER.verbose(f'User is editing {provenance}')
-                    self.editwindow        = EditWindow(run, self.output_bidsmap, self.template_bidsmap)
+                    self.editwindow        = EditWindow(runitem, self.output_bidsmap, self.template_bidsmap)
                     self.editwindow_opened = str(provenance)
                     self.editwindow.done_edit.connect(self.update_subses_samples)
                     self.editwindow.finished.connect(self.release_editwindow)
                     self.editwindow.show()
                     return
-            LOGGER.error(f"Could not find {provenance} run-item")
+            LOGGER.error(f"Could not find [{datatype}] {provenance} run-item")
 
         else:
             # Ask the user if he wants to save his results first before opening a new edit window
@@ -674,7 +678,7 @@ def plugin_table(self, name: str, plugin: dict) -> tuple:
 
         self.options_label[name] = plugin_label = QLabel(f"{name} - plugin")
         self.options_table[name] = plugin_table = MyQTableWidget()
-        plugin_table.setRowCount(max(len(plugin.keys()) + 1, 2))           # Add an extra row for new key-value pairs
+        plugin_table.setRowCount(max(len(plugin.keys()) + 1, 2))            # Add an extra row for new key-value pairs
         plugin_table.setColumnCount(3)                                      # columns: [key] [value] [testbutton]
         horizontal_header = plugin_table.horizontalHeader()
         horizontal_header.setSectionResizeMode(0, QHeaderView.ResizeMode.ResizeToContents)
@@ -703,7 +707,7 @@ def plugin_table(self, name: str, plugin: dict) -> tuple:
     def options2bidsmap(self, rowindex: int, colindex: int):
         """Saves all Options tables to the bidsmap and add an extra row to the plugin_table if it is full"""
 
-        for plugin,table in self.options_table.items():
+        for plugin, table in self.options_table.items():
             if plugin == 'bidscoin':
                 oldoptions = self.output_bidsmap.options
             else:
@@ -729,7 +733,7 @@ def options2bidsmap(self, rowindex: int, colindex: int):
                 self.ignoredatatypes   = newoptions.get('ignoretypes', [])
                 self.bidsignore        = newoptions.get('bidsignore', [])
                 for dataformat in self.dataformats:
-                    self.update_subses_samples(self.output_bidsmap, dataformat)
+                    self.update_subses_samples(dataformat)
             else:
                 self.output_bidsmap.plugins[plugin] = newoptions
 
@@ -835,11 +839,7 @@ def reset(self):
             self.editwindow.reject(confirm=False)
 
         LOGGER.info('User resets the bidsmap')
-        self.__init__(self.bidsfolder,
-                      self.input_bidsmap,
-                      self.template_bidsmap,
-                      self.datasaved,
-                      reset=True)
+        self.__init__(self.bidsfolder, self.input_bidsmap, self.template_bidsmap, self.datasaved, reset=True)
 
         # Start with a fresh errorlog
         for filehandler in LOGGER.handlers:
@@ -869,9 +869,9 @@ def save_bidsmap(self):
         """Check and save the bidsmap to file"""
 
         for dataformat in self.dataformats:
-            for run in self.output_bidsmap.dataformat(dataformat).datatype('fmap').runitems:
-                if not (run.meta.get('B0FieldSource') or run.meta.get('B0FieldIdentifier') or run.meta.get('IntendedFor')):
-                    LOGGER.warning(f"B0FieldIdentifier/IntendedFor fieldmap value is empty for {dataformat} run-item: {run}")
+            for runitem in self.output_bidsmap.dataformat(dataformat).datatype('fmap').runitems:
+                if not (runitem.meta.get('B0FieldSource') or runitem.meta.get('B0FieldIdentifier') or runitem.meta.get('IntendedFor')):
+                    LOGGER.warning(f"B0FieldIdentifier/IntendedFor fieldmap value is empty for {dataformat} run-item: {runitem}")
 
         filename,_ = QFileDialog.getSaveFileName(self, 'Save File',  str(self.bidsfolder/'code'/'bidscoin'/'bidsmap.yaml'), 'YAML Files (*.yaml *.yml);;All Files (*)')
         if filename:
@@ -944,44 +944,35 @@ def get_bids_help():
 
 class EditWindow(QDialog):
     """
-    EditWindow().result() == 1: done with result, i.e. done_edit -> new bidsmap
+    EditWindow().result() == 1: done with result, i.e. done_edit -> edited dataformat
     EditWindow().result() == 2: done without result
     """
 
     # Emit the new bidsmap when done (see docstring)
-    done_edit = QtCore.pyqtSignal(BidsMap, str)
+    done_edit = QtCore.pyqtSignal(str)
 
-    def __init__(self, run: RunItem, bidsmap: BidsMap, template_bidsmap: BidsMap):
+    def __init__(self, runitem: RunItem, bidsmap: BidsMap, template_bidsmap: BidsMap):
         super().__init__()
 
         # Set the data
-        datasource             = run.datasource
-        self.datasource        = datasource
-        self.dataformat        = run.dataformat
+        self.datasource        = runitem.datasource
+        self.dataformat        = runitem.dataformat
         """The data format of the run-item being edited (bidsmap[dataformat][datatype][run-item])"""
-        self.source_datatype   = run.datatype
-        """The BIDS data type of the original run-item"""
-        self.target_datatype   = run.datatype
-        """The BIDS data type that the edited run-item is being changed into"""
-        self.current_datatype  = run.datatype
-        """The BIDS datatype of the run-item just before it is being changed (again)"""
         self.unknowndatatypes: List[str] = [datatype for datatype in bidsmap.options['unknowntypes'] if datatype in template_bidsmap.dataformat(self.dataformat).datatypes]
         self.ignoredatatypes: List[str]  = [datatype for datatype in bidsmap.options['ignoretypes']  if datatype in template_bidsmap.dataformat(self.dataformat).datatypes]
         self.bidsdatatypes     = [str(datatype) for datatype in template_bidsmap.dataformat(self.dataformat).datatypes if datatype not in self.unknowndatatypes + self.ignoredatatypes + ['subject', 'session']]
         self.bidsignore        = bidsmap.options['bidsignore']
-        self.source_bidsmap    = bidsmap
+        self.output_bidsmap    = bidsmap
         """The bidsmap at the start of the edit = output_bidsmap in the MainWindow"""
-        self.target_bidsmap    = copy.deepcopy(bidsmap)
-        """The edited bidsmap -> will be returned as output_bidsmap in the MainWindow"""
         self.template_bidsmap  = template_bidsmap
         """The bidsmap from which new datatype run-items are taken"""
-        self.source_run        = run
+        self.source_run        = runitem
         """The original run-item from the source bidsmap"""
-        self.target_run        = copy.deepcopy(run)
+        self.target_run        = copy.deepcopy(runitem)
         """The edited run-item that is inserted in the target_bidsmap"""
         self.allowed_suffixes  = self.get_allowed_suffixes()
         """Set the possible suffixes the user can select for a given datatype"""
-        self.subid, self.sesid = datasource.subid_sesid(bidsmap.dataformat(run.dataformat).subject, bidsmap.dataformat(run.dataformat).session or '')
+        self.subid, self.sesid = runitem.datasource.subid_sesid(bidsmap.dataformat(runitem.dataformat).subject, bidsmap.dataformat(runitem.dataformat).session or '')
 
         # Set up the window
         self.setWindowIcon(QtGui.QIcon(str(BIDSCOIN_ICON)))
@@ -1012,7 +1003,7 @@ def __init__(self, run: RunItem, bidsmap: BidsMap, template_bidsmap: BidsMap):
         self.datatype_label.setToolTip(f"The BIDS data type and entities for constructing the BIDS output filename. You are encouraged to change their default values to be more meaningful and readable")
         self.datatype_dropdown = QComboBox()
         self.datatype_dropdown.addItems(self.bidsdatatypes + self.unknowndatatypes + self.ignoredatatypes)
-        self.datatype_dropdown.setCurrentIndex(self.datatype_dropdown.findText(self.target_datatype))
+        self.datatype_dropdown.setCurrentIndex(self.datatype_dropdown.findText(self.target_run.datatype))
         self.datatype_dropdown.currentIndexChanged.connect(self.datatype_dropdown_change)
         self.datatype_dropdown.setToolTip('The BIDS data type. First make sure this one is correct, then choose the right suffix')
         for n, datatype in enumerate(self.bidsdatatypes + self.unknowndatatypes):
@@ -1178,8 +1169,8 @@ def get_allowed_suffixes(self) -> Dict[str, set]:
         allowed_suffixes = {}
         for datatype in self.bidsdatatypes + self.unknowndatatypes + self.ignoredatatypes:
             allowed_suffixes[datatype] = set()
-            for run in self.template_bidsmap.dataformat(self.dataformat).datatype(datatype).runitems:
-                suffix = self.datasource.dynamicvalue(run.bids['suffix'], True)
+            for runitem in self.template_bidsmap.dataformat(self.dataformat).datatype(datatype).runitems:
+                suffix = self.datasource.dynamicvalue(runitem.bids['suffix'], True)
                 if suffix:
                     allowed_suffixes[str(datatype)].add(suffix)
 
@@ -1190,39 +1181,39 @@ def run2data(self) -> tuple:
         :return: (data_properties, data_attributes, data_bids, data_meta)
         """
 
-        run      = self.target_run
+        runitem  = self.target_run
         filepath = self.datasource.properties('filepath')
         filename = self.datasource.properties('filename')
         filesize = self.datasource.properties('filesize')
         nrfiles  = self.datasource.properties('nrfiles')
-        data_properties = [[{'value': 'filepath',                     'iseditable': False},
-                            {'value': run.properties.get('filepath'), 'iseditable': True},
-                            {'value': filepath,                       'iseditable': False}],
-                           [{'value': 'filename',                     'iseditable': False},
-                            {'value': run.properties.get('filename'), 'iseditable': True},
-                            {'value': filename,                       'iseditable': False}],
-                           [{'value': 'filesize',                     'iseditable': False},
-                            {'value': run.properties.get('filesize'), 'iseditable': True},
-                            {'value': filesize,                       'iseditable': False}],
-                           [{'value': 'nrfiles',                      'iseditable': False},
-                            {'value': run.properties.get('nrfiles'),  'iseditable': True},
-                            {'value': nrfiles,                        'iseditable': False}]]
+        data_properties = [[{'value': 'filepath',                         'iseditable': False},
+                            {'value': runitem.properties.get('filepath'), 'iseditable': True},
+                            {'value': filepath,                           'iseditable': False}],
+                           [{'value': 'filename',                         'iseditable': False},
+                            {'value': runitem.properties.get('filename'), 'iseditable': True},
+                            {'value': filename,                           'iseditable': False}],
+                           [{'value': 'filesize',                         'iseditable': False},
+                            {'value': runitem.properties.get('filesize'), 'iseditable': True},
+                            {'value': filesize,                           'iseditable': False}],
+                           [{'value': 'nrfiles',                          'iseditable': False},
+                            {'value': runitem.properties.get('nrfiles'),  'iseditable': True},
+                            {'value': nrfiles,                            'iseditable': False}]]
 
         data_attributes = []
-        for key, value in run.attributes.items():
+        for key, value in runitem.attributes.items():
             data_attributes.append([{'value': key,   'iseditable': False},
                                     {'value': value, 'iseditable': True}])
 
         data_bids = []
-        bidsname  = run.bidsname(self.subid, self.sesid, False) + '.json'
-        if bids.check_ignore(self.target_datatype, self.bidsignore) or bids.check_ignore(bidsname, self.bidsignore, 'file') or self.target_datatype in self.ignoredatatypes:
-            bidskeys = run.bids.keys()
+        bidsname  = runitem.bidsname(self.subid, self.sesid, False) + '.json'
+        if bids.check_ignore(runitem.datatype, self.bidsignore) or bids.check_ignore(bidsname, self.bidsignore, 'file') or runitem.datatype in self.ignoredatatypes:
+            bidskeys = runitem.bids.keys()
         else:
             bidskeys = [bids.entities[entity]['name'] for entity in bids.entitiesorder if entity not in ('subject','session')] + ['suffix']   # Impose the BIDS-specified order + suffix
         for key in bidskeys:
-            if key in run.bids:
-                value = run.bids.get(key)
-                if (self.target_datatype in self.bidsdatatypes and key=='suffix') or isinstance(value, list):
+            if key in runitem.bids:
+                value = runitem.bids.get(key)
+                if (runitem.datatype in self.bidsdatatypes and key=='suffix') or isinstance(value, list):
                     iseditable = False
                 else:
                     iseditable = True
@@ -1230,7 +1221,7 @@ def run2data(self) -> tuple:
                                   {'value': value, 'iseditable': iseditable}])          # NB: This can be a (menu) list
 
         data_meta = []
-        for key, value in run.meta.items():
+        for key, value in runitem.meta.items():
             data_meta.append([{'value': key,   'iseditable': True},
                               {'value': value, 'iseditable': True}])
 
@@ -1265,17 +1256,17 @@ def fill_table(self, table: QTableWidget, data: list):
 
         for i, row in enumerate(data + addrow):
             key = row[0]['value']
-            if table.objectName() == 'bids' and key == 'suffix' and self.target_datatype in self.bidsdatatypes:
+            if table.objectName() == 'bids' and key == 'suffix' and self.target_run.datatype in self.bidsdatatypes:
                 table.setItem(i, 0, MyWidgetItem('suffix', iseditable=False))
                 suffix   = self.datasource.dynamicvalue(self.target_run.bids.get('suffix',''))
-                suffixes = sorted(self.allowed_suffixes.get(self.target_datatype, set()), key=str.casefold)
+                suffixes = sorted(self.allowed_suffixes.get(self.target_run.datatype, set()), key=str.casefold)
                 suffix_dropdown = self.suffix_dropdown = QComboBox()
                 suffix_dropdown.addItems(suffixes)
                 suffix_dropdown.setCurrentIndex(suffix_dropdown.findText(suffix))
                 suffix_dropdown.currentIndexChanged.connect(self.suffix_dropdown_change)
                 suffix_dropdown.setToolTip('The suffix that sets the different run types apart. First make sure the "Data type" dropdown-menu is set correctly before choosing the right suffix here')
                 for n, suffix in enumerate(suffixes):
-                    suffix_dropdown.setItemData(n, get_suffixhelp(suffix, self.target_datatype), QtCore.Qt.ItemDataRole.ToolTipRole)
+                    suffix_dropdown.setItemData(n, get_suffixhelp(suffix, self.target_run.datatype), QtCore.Qt.ItemDataRole.ToolTipRole)
                 table.setCellWidget(i, 1, self.spacedwidget(suffix_dropdown))
                 continue
             for j, item in enumerate(row):
@@ -1322,7 +1313,7 @@ def propertiescell2run(self, rowindex: int, colindex: int):
                                               f'It is discouraged to change {self.dataformat} property values unless you are an expert user. Do you really want to change "{oldvalue}" to "{value}"?',
                                               QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No, QMessageBox.StandardButton.No)
                 if answer == QMessageBox.StandardButton.Yes:
-                    LOGGER.verbose(f"Expert usage: User sets {self.dataformat}['{key}'] from '{oldvalue}' to '{value}' for {self.target_run.provenance}")
+                    LOGGER.verbose(f"Expert usage: User sets ['{key}'] from '{oldvalue}' to '{value}' for {self.target_run}")
                     self.target_run.properties[key] = value
                 else:
                     self.properties_table.blockSignals(True)
@@ -1341,12 +1332,12 @@ def attributescell2run(self, rowindex: int, colindex: int):
                 oldvalue = ''
 
             # Only if cell was changed, update
-            if key and value!=oldvalue:
+            if key and value != oldvalue:
                 answer = QMessageBox.question(self, f"Edit {self.dataformat} attributes",
                                               f'It is discouraged to change {self.dataformat} attribute values unless you are an expert user. Do you really want to change "{oldvalue}" to "{value}"?',
                                               QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No, QMessageBox.StandardButton.No)
                 if answer == QMessageBox.StandardButton.Yes:
-                    LOGGER.verbose(f"Expert usage: User sets {self.dataformat}['{key}'] from '{oldvalue}' to '{value}' for {self.target_run.provenance}")
+                    LOGGER.verbose(f"Expert usage: User sets ['{key}'] from '{oldvalue}' to '{value}' for {self.target_run}")
                     self.target_run.attributes[key] = value
                 else:
                     self.attributes_table.blockSignals(True)
@@ -1381,13 +1372,13 @@ def bidscell2run(self, rowindex: int, colindex: int):
                                                   f'It is discouraged to remove the <<dynamic>> run-index. Do you really want to change "{oldvalue}" to "{value}"?',
                                                   QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No, QMessageBox.StandardButton.No)
                     if answer == QMessageBox.StandardButton.Yes:
-                        LOGGER.verbose(f"Expert usage: User sets bids['{key}'] from '{oldvalue}' to '{value}' for {self.target_run.provenance}")
+                        LOGGER.verbose(f"Expert usage: User sets bids['{key}'] from '{oldvalue}' to '{value}' for {self.target_run}")
                     else:
                         value = oldvalue
                         self.bids_table.item(rowindex, 1).setText(oldvalue)
-                        LOGGER.verbose(f"User sets bids['{key}'] from '{oldvalue}' to '{value}' for {self.target_run.provenance}")
+                        LOGGER.verbose(f"User sets bids['{key}'] from '{oldvalue}' to '{value}' for {self.target_run}")
                 else:
-                    LOGGER.verbose(f"User sets bids['{key}'] from '{oldvalue}' to '{value}' for {self.target_run.provenance}")
+                    LOGGER.verbose(f"User sets bids['{key}'] from '{oldvalue}' to '{value}' for {self.target_run}")
                 self.bids_table.blockSignals(False)
                 self.target_run.bids[key] = value
                 self.refresh_bidsname()
@@ -1407,7 +1398,7 @@ def metacell2run(self, rowindex: int, colindex: int):
                 self.meta_table.blockSignals(True)
                 self.meta_table.item(rowindex, 1).setText(value)
                 self.meta_table.blockSignals(False)
-            LOGGER.verbose(f"User sets meta['{key}'] from '{oldvalue}' to '{value}' for {self.target_run.provenance}")
+            LOGGER.verbose(f"User sets meta['{key}'] from '{oldvalue}' to '{value}' for {self.target_run}")
 
         # Read all the meta-data from the table and store it in the target_run
         self.target_run.meta = {}
@@ -1433,31 +1424,29 @@ def change_run(self, suffix_idx):
         """
 
         # Add a check to see if we can still read the source data
-        if not Path(self.target_run.provenance).is_file():
-            LOGGER.warning(f"Can no longer find the source file: {self.target_run.provenance}")
-            QMessageBox.warning(self, 'Edit BIDS mapping', f"Cannot reliably change the datatype and/or suffix because the source file '{self.target_run.provenance}' can no longer be found.\n\nPlease restore the source data or use the `bidsmapper -s` option to solve this issue. Resetting the run-item now...")
+        provenance = self.target_run.provenance
+        if not Path(provenance).is_file():
+            LOGGER.warning(f"Can no longer find the source file: {provenance}")
+            QMessageBox.warning(self, 'Edit BIDS mapping', f"Cannot reliably change the datatype and/or suffix because the source file '{provenance}' can no longer be found.\n\nPlease restore the source data or use the `bidsmapper -s` option to solve this issue. Resetting the run-item now...")
             self.reset()
             return
 
         # Get the new target_run from the template
-        new_target_run = self.template_bidsmap.get_run(self.target_datatype, suffix_idx, self.datasource)
-        if not new_target_run:
-            QMessageBox.warning(self, 'Edit BIDS mapping', f"Cannot find the {self.target_datatype}[{suffix_idx}] datatype in your template. Resetting the run-item now...")
+        template_run = self.template_bidsmap.get_run(self.target_run.datatype, suffix_idx, self.datasource)
+        if not template_run:
+            QMessageBox.warning(self, 'Edit BIDS mapping', f"Cannot find the {self.target_run.datatype}[{suffix_idx}] datatype in your template. Resetting the run-item now...")
             self.reset()
             return
-        old_entities    = self.target_run.bids
-        self.target_run = copy.deepcopy(new_target_run)
 
-        # Transfer the old entity data to the new run-item if possible and if it's not there yet
+        # Transfer the old provenance and entity data to the new run-item if it is missing
+        old_entities               = self.target_run.bids.copy()
+        self.target_run.properties = template_run.properties.copy()
+        self.target_run.attributes = template_run.attributes.copy()
+        self.target_run.bids       = template_run.bids.copy()
         for key, val in old_entities.items():
             if val and key in self.target_run.bids and not self.target_run.bids[key]:
                 self.target_run.bids[key] = val
-
-        # Insert the new target_run in our target_bidsmap
-        self.target_bidsmap.update(self.current_datatype, self.target_run)
-
-        # Now that we have updated the bidsmap, we can also update the current_datatype
-        self.current_datatype = self.target_datatype
+        self.target_run.meta       = template_run.meta.copy()
 
         # Reset the edit window with the new target_run
         self.reset(refresh=True)
@@ -1465,9 +1454,9 @@ def change_run(self, suffix_idx):
     def datatype_dropdown_change(self):
         """Update the BIDS values and BIDS output name section when the dropdown selection has been taking place"""
 
-        self.target_datatype = self.datatype_dropdown.currentText()
+        self.target_run.datatype = self.datatype_dropdown.currentText()
 
-        LOGGER.verbose(f"User changes the BIDS data type from '{self.current_datatype}' to '{self.target_datatype}' for {self.target_run.provenance}")
+        LOGGER.verbose(f"User changes the BIDS data type from '{self.source_run.datatype}' to '{self.target_run.datatype}' for {self.target_run}")
 
         self.change_run(0)
 
@@ -1476,35 +1465,36 @@ def suffix_dropdown_change(self):
 
         target_suffix = self.suffix_dropdown.currentText()
 
-        LOGGER.verbose(f"User changes the BIDS suffix from '{self.target_run.bids.get('suffix')}' to '{target_suffix}' for {self.target_run.provenance}")
+        LOGGER.verbose(f"User changes the BIDS suffix from '{self.target_run.bids.get('suffix')}' to '{target_suffix}' for {self.target_run}")
 
         self.change_run(target_suffix)
 
     def refresh_bidsname(self):
         """Updates the bidsname with the current (edited) bids values"""
 
-        ignore   = bids.check_ignore(self.target_datatype,self.bidsignore) or self.target_datatype in self.ignoredatatypes
-        bidsname = (Path(self.target_datatype)/self.target_run.bidsname(self.subid, self.sesid, not ignore)).with_suffix('.*')
+        datatype = self.target_run.datatype
+        ignore   = bids.check_ignore(datatype,self.bidsignore) or datatype in self.ignoredatatypes
+        bidsname = (Path(datatype)/self.target_run.bidsname(self.subid, self.sesid, not ignore)).with_suffix('.*')
 
         font = self.bidsname_textbox.font()
-        if bids.check_ignore(self.target_datatype, self.bidsignore) or bids.check_ignore(bidsname.name, self.bidsignore, 'file'):
-            self.bidsname_textbox.setToolTip(f"Orange: This '{self.target_datatype}' data type is ignored by BIDS-apps and BIDS-validators")
+        if bids.check_ignore(datatype, self.bidsignore) or bids.check_ignore(bidsname.name, self.bidsignore, 'file'):
+            self.bidsname_textbox.setToolTip(f"Orange: This '{datatype}' data type is ignored by BIDS-apps and BIDS-validators")
             self.bidsname_textbox.setTextColor(QtGui.QColor('darkorange'))
             font.setStrikeOut(False)
-        elif self.target_datatype in self.unknowndatatypes:
-            self.bidsname_textbox.setToolTip(f"Red: This '{self.target_datatype}' data type is not part of BIDS but will be converted to a BIDS-like entry in the {self.unknowndatatypes} folder. Click 'OK' if you want your BIDS output data to look like this")
+        elif datatype in self.unknowndatatypes:
+            self.bidsname_textbox.setToolTip(f"Red: This '{datatype}' data type is not part of BIDS but will be converted to a BIDS-like entry in the {self.unknowndatatypes} folder. Click 'OK' if you want your BIDS output data to look like this")
             self.bidsname_textbox.setTextColor(QtGui.QColor('red'))
             font.setStrikeOut(False)
-        elif self.target_datatype in self.ignoredatatypes:
-            self.bidsname_textbox.setToolTip(f"Gray/Strike-out: This '{self.target_datatype}' data type will be ignored and not converted BIDS. Click 'OK' if you want your BIDS output data to look like this")
+        elif datatype in self.ignoredatatypes:
+            self.bidsname_textbox.setToolTip(f"Gray/Strike-out: This '{datatype}' data type will be ignored and not converted BIDS. Click 'OK' if you want your BIDS output data to look like this")
             self.bidsname_textbox.setTextColor(QtGui.QColor('gray'))
             font.setStrikeOut(True)
-        elif not all(self.target_run.check(self.target_datatype, checks=(False, True, True))[1:3]):
+        elif not all(self.target_run.check(checks=(False, True, True))[1:3]):
             self.bidsname_textbox.setToolTip(f"Red: This name is not valid according to the BIDS standard -- see terminal output for more info")
             self.bidsname_textbox.setTextColor(QtGui.QColor('red'))
             font.setStrikeOut(False)
         else:
-            self.bidsname_textbox.setToolTip(f"Green: This '{self.target_datatype}' data type is part of BIDS. Click 'OK' if you want your BIDS output data to look like this")
+            self.bidsname_textbox.setToolTip(f"Green: This '{datatype}' data type is part of BIDS. Click 'OK' if you want your BIDS output data to look like this")
             self.bidsname_textbox.setTextColor(QtGui.QColor('green'))
             font.setStrikeOut(False)
         self.bidsname_textbox.setFont(font)
@@ -1517,14 +1507,11 @@ def reset(self, refresh: bool=False):
         # Reset the target_run to the source_run
         if not refresh:
             LOGGER.verbose('User resets the BIDS mapping')
-            self.current_datatype = self.source_datatype
-            self.target_datatype  = self.source_datatype
-            self.target_run       = copy.deepcopy(self.source_run)
-            self.target_bidsmap   = copy.deepcopy(self.source_bidsmap)
+            self.target_run = copy.deepcopy(self.source_run)
 
             # Reset the datatype dropdown menu
             self.datatype_dropdown.blockSignals(True)
-            self.datatype_dropdown.setCurrentIndex(self.datatype_dropdown.findText(self.target_datatype))
+            self.datatype_dropdown.setCurrentIndex(self.datatype_dropdown.findText(self.target_run.datatype))
             self.datatype_dropdown.blockSignals(False)
 
         # Refresh the source attributes and BIDS values with data from the target_run
@@ -1544,9 +1531,10 @@ def accept_run(self):
 
         # Check if the bidsname is valid
         bidsname  = Path(self.bidsname_textbox.toPlainText())
-        validrun  = False not in self.target_run.check(self.target_datatype, checks=(False, False, False))[1:3]
+        validrun  = False not in self.target_run.check(checks=(False, False, False))[1:3]
         bidsvalid = validrun
-        if not (bids.check_ignore(self.target_datatype,self.bidsignore) or bids.check_ignore(bidsname.name,self.bidsignore,'file') or self.target_datatype in self.ignoredatatypes):
+        datatype  = self.target_run.datatype
+        if not (bids.check_ignore(datatype,self.bidsignore) or bids.check_ignore(bidsname.name,self.bidsignore,'file') or datatype in self.ignoredatatypes):
             for ext in extensions:      # NB: `ext` used to be '.json', which is more generic (but see https://github.com/bids-standard/bids-validator/issues/2113)
                 if bidsvalid := BIDSValidator().is_bids((Path('/')/self.subid/self.sesid/bidsname).with_suffix(ext).as_posix()): break
 
@@ -1558,9 +1546,9 @@ def accept_run(self):
             message = f'The run-item does not seem to be valid but the "{bidsname}" name does pass the bids-validator test'
         elif not validrun:
             message = f'The "{bidsname}" name is not valid according to the BIDS standard'
-        elif self.target_datatype=='fmap' and not (self.target_run.meta.get('B0FieldSource') or
-                                                   self.target_run.meta.get('B0FieldIdentifier') or
-                                                   self.target_run.meta.get('IntendedFor')):
+        elif datatype=='fmap' and not (self.target_run.meta.get('B0FieldSource') or
+                                       self.target_run.meta.get('B0FieldIdentifier') or
+                                       self.target_run.meta.get('IntendedFor')):
             message = f'The "B0FieldIdentifier/IntendedFor" meta-data is left empty for {bidsname} (not recommended)'
         if message:
             answer = QMessageBox.question(self, 'Edit BIDS mapping', f'WARNING:\n{message}\n\nDo you want to go back and edit the run?',
@@ -1570,8 +1558,8 @@ def accept_run(self):
 
         LOGGER.verbose(f'User approves the edit')
         if self.target_run != self.source_run:
-            self.target_bidsmap.update(self.current_datatype, self.target_run)
-            self.done_edit.emit(self.target_bidsmap, self.dataformat)
+            self.output_bidsmap.update(self.source_run.datatype, self.target_run)
+            self.done_edit.emit(self.dataformat)
             self.done(1)
         else:
             self.done(2)
@@ -1582,11 +1570,11 @@ def export_run(self):
         yamlfile, _ = QFileDialog.getOpenFileName(self, 'Export run item to (template) bidsmap',
                                                   str(bidsmap_template), 'YAML Files (*.yaml *.yml);;All Files (*)')
         if yamlfile:
-            LOGGER.info(f'Exporting run item: bidsmap[{self.dataformat}][{self.target_datatype}] -> {yamlfile}')
+            LOGGER.info(f'Exporting run item {self.target_run} -> {yamlfile}')
             bidsmap = BidsMap(Path(yamlfile), checks=(False, False, False))
             bidsmap.insert_run(self.target_run)
             bidsmap.save()
-            QMessageBox.information(self, 'Edit BIDS mapping', f"Successfully exported:\n\nbidsmap[{self.dataformat}][{self.target_datatype}] -> {yamlfile}")
+            QMessageBox.information(self, 'Edit BIDS mapping', f"Successfully exported:\n\n{self.target_run} -> {yamlfile}")
 
     def inspect_sourcefile(self, rowindex: int=None, colindex: int=None):
         """When double-clicked, show popup window"""
@@ -1618,13 +1606,13 @@ def spacedwidget(alignedwidget, align='left'):
 
     def get_help(self):
         """Open web page for help"""
-        help_url = HELP_URLS.get(self.target_datatype, HELP_URL_DEFAULT)
+        help_url = HELP_URLS.get(self.target_run.datatype, HELP_URL_DEFAULT)
         webbrowser.open(help_url)
 
 
 class CompareWindow(QDialog):
 
-    def __init__(self, runs: List[RunItem], subid: List[str], sesid: List[str]):
+    def __init__(self, runitems: List[RunItem], subid: List[str], sesid: List[str]):
         super().__init__()
 
         # Set up the window
@@ -1635,17 +1623,17 @@ def __init__(self, runs: List[RunItem], subid: List[str], sesid: List[str]):
 
         layout_main = QHBoxLayout(self)
 
-        for index, run in enumerate(runs):
+        for index, runitem in enumerate(runitems):
 
             # Get data for the tables
-            data_properties, data_attributes, data_bids, data_meta = self.run2data(run)
+            data_properties, data_attributes, data_bids, data_meta = self.run2data(runitem)
 
             # Set up the properties table
             properties_label = QLabel('Properties')
             properties_label.setToolTip('The filesystem properties that match with (identify) the source file')
             properties_table = self.fill_table(data_properties, 'properties')
             properties_table.setToolTip('The filesystem property that matches with the source file')
-            properties_table.cellDoubleClicked.connect(partial(self.inspect_sourcefile, run.provenance))
+            properties_table.cellDoubleClicked.connect(partial(self.inspect_sourcefile, runitem.provenance))
 
             # Set up the attributes table
             attributes_label = QLabel('Attributes')
@@ -1665,8 +1653,8 @@ def __init__(self, runs: List[RunItem], subid: List[str], sesid: List[str]):
             meta_table = self.fill_table(data_meta, 'meta', minimum=False)
             meta_table.setToolTip('The key-value pair that will be appended to the (e.g. dcm2niix-produced) json sidecar file')
 
-            bidsname = run.bidsname(subid[index], sesid[index], False) + '.*'
-            groupbox = QGroupBox(f"{run.datatype}/{bidsname}")
+            bidsname = runitem.bidsname(subid[index], sesid[index], False) + '.*'
+            groupbox = QGroupBox(f"{runitem.datatype}/{bidsname}")
             layout   = QVBoxLayout()
             layout.addWidget(properties_label)
             layout.addWidget(properties_table)
@@ -1684,33 +1672,33 @@ def __init__(self, runs: List[RunItem], subid: List[str], sesid: List[str]):
         self.show()
 
     @staticmethod
-    def run2data(run) -> tuple:
+    def run2data(runitem: RunItem) -> tuple:
         """Derive the tabular data from the target_run, needed to render the compare window
         :return: (data_properties, data_attributes, data_bids, data_meta)
         """
 
-        data_properties = [['filepath', run.properties.get('filepath'), run.datasource.properties('filepath')],
-                           ['filename', run.properties.get('filename'), run.datasource.properties('filename')],
-                           ['filesize', run.properties.get('filesize'), run.datasource.properties('filesize')],
-                           ['nrfiles',  run.properties.get('nrfiles'),  run.datasource.properties('nrfiles')]]
+        data_properties = [['filepath', runitem.properties.get('filepath'), runitem.datasource.properties('filepath')],
+                           ['filename', runitem.properties.get('filename'), runitem.datasource.properties('filename')],
+                           ['filesize', runitem.properties.get('filesize'), runitem.datasource.properties('filesize')],
+                           ['nrfiles',  runitem.properties.get('nrfiles'),  runitem.datasource.properties('nrfiles')]]
 
         data_attributes = []
-        for key in sorted(run.attributes.keys()):
-            value = run.attributes.get(key)
+        for key in sorted(runitem.attributes.keys()):
+            value = runitem.attributes.get(key)
             data_attributes.append([key, value])
 
         data_bids = []
         bidskeys = [bids.entities[entity]['name'] for entity in bids.entitiesorder if entity not in ('subject','session')] + ['suffix']   # Impose the BIDS-specified order + suffix
         for key in bidskeys:
-            if key in run.bids:
-                value = run.bids.get(key)
+            if key in runitem.bids:
+                value = runitem.bids.get(key)
                 if isinstance(value, list):
                     value = value[value[-1]]
                 data_bids.append([key, value])
 
         data_meta = []
-        for key in sorted(run.meta.keys()):
-            value = run.meta.get(key)
+        for key in sorted(runitem.meta.keys()):
+            value = runitem.meta.get(key)
             data_meta.append([key, value])
 
         return data_properties, data_attributes, data_bids, data_meta
@@ -2036,9 +2024,9 @@ def main():
     try:
         bidseditor(**vars(args))
 
-    except Exception:
+    except Exception as error:
         trackusage('bidseditor_exception')
-        raise
+        raise error
 
 
 if __name__ == '__main__':
diff --git a/bidscoin/bidsmapper.py b/bidscoin/bidsmapper.py
index 87aeb228..35a99361 100755
--- a/bidscoin/bidsmapper.py
+++ b/bidscoin/bidsmapper.py
@@ -55,8 +55,9 @@ def bidsmapper(sourcefolder: str, bidsfolder: str, bidsmap: str, template: str,
     if [char for char in sesprefix or '' if char in ('^', '$', '+', '{', '}', '[', ']', '\\', '|', '(', ')')]:
         LOGGER.bcdebug(f"Regular expression metacharacters found in {sesprefix}, this may cause errors later on...")
     if not rawfolder.is_dir():
-        print(f"Rawfolder '{rawfolder}' not found")
-        exit(1)
+        raise SystemExit(f"\n[ERROR] Exiting the program because your sourcefolder argument '{sourcefolder}' was not found")
+    if not templatefile.is_file():
+        raise SystemExit(f"\n[ERROR] Exiting the program because your template bidsmap '{templatefile}' was not found")
 
     # Start logging
     if force:
@@ -75,21 +76,22 @@ def bidsmapper(sourcefolder: str, bidsfolder: str, bidsmap: str, template: str,
     template    = BidsMap(templatefile, plugins=plugins, checks=(True, True, False))
     template.check_template()
 
-    # Create the new bidsmap as a copy / bidsmap skeleton with no data type entries (i.e. bidsmap with empty lists)
+    # Create the new bidsmap as a copy / bidsmap skeleton with only data types without run-items (i.e. empty lists)
     if force and bidsmap_old.filepath.name:
         LOGGER.info(f"Deleting previous bidsmap: {bidsmap_old.filepath}")
         bidsmap_old.filepath.unlink()
         bidsmap_old.filepath = Path()
-    bidsmap_new      = copy.deepcopy(bidsmap_old if bidsmap_old.filepath.name else template)
-    template.options = bidsmap_new.options              # Always use the options of the new bidsmap
-    template.plugins = bidsmap_new.plugins              # Always use the plugins of the new bidsmap
+    bidsmap_new          = copy.deepcopy(bidsmap_old if bidsmap_old.filepath.name else template)
+    bidsmap_new.filepath = bidsmapfile
+    template.options     = bidsmap_new.options      # Always use the options of the new bidsmap
+    template.plugins     = bidsmap_new.plugins      # Always use the plugins of the new bidsmap
     if unzip:
         bidsmap_new.options['unzip'] = unzip
     else:
         unzip = bidsmap_new.options.get('unzip','')
     for dataformat in bidsmap_new.dataformats:
         for datatype in dataformat.datatypes:
-            datatype.delete_runs()
+            dataformat.delete_runs(datatype)
 
     # Store/retrieve the empty or user-defined sub-/ses-prefix. The new bidsmap is now ready to be populated
     subprefix, sesprefix = setprefix(bidsmap_new, subprefix, sesprefix, rawfolder, update = not no_update)
@@ -236,9 +238,9 @@ def main():
     try:
         bidsmapper(**vars(args))
 
-    except Exception:
+    except Exception as error:
         trackusage('bidsmapper_exception')
-        raise
+        raise error
 
 
 if __name__ == "__main__":
diff --git a/bidscoin/plugins/dcm2niix2bids.py b/bidscoin/plugins/dcm2niix2bids.py
index 8635d347..33397f9b 100644
--- a/bidscoin/plugins/dcm2niix2bids.py
+++ b/bidscoin/plugins/dcm2niix2bids.py
@@ -15,7 +15,7 @@
 from pathlib import Path
 from bidscoin import bcoin, bids, lsdirs, due, Doi
 from bidscoin.utilities import physio
-from bidscoin.bids import BidsMap, Plugin, Plugins, DataFormat
+from bidscoin.bids import BidsMap, DataFormat, Plugin, Plugins
 try:
     from nibabel.testing import data_path
 except ImportError:
@@ -91,7 +91,7 @@ def has_support(file: Path, dataformat: Union[DataFormat, str]='') -> str:
     return ''
 
 
-def get_attribute(dataformat: str, sourcefile: Path, attribute: str, options) -> Union[str, int]:
+def get_attribute(dataformat: Union[DataFormat, str], sourcefile: Path, attribute: str, options) -> Union[str, int]:
     """
     This plugin supports reading attributes from DICOM and PAR dataformats
 
@@ -168,7 +168,7 @@ def bidsmapper_plugin(session: Path, bidsmap_new: BidsMap, bidsmap_old: BidsMap,
 
                 # Try to automagically set the {part: phase/imag/real} (should work for Siemens data)
                 if not run.datatype == '' and 'part' in run.bids and not run.bids['part'][-1] and run.attributes.get('ImageType'):    # part[-1]==0 -> part is not specified
-                    imagetype = ast.literal_eval(run['attributes']['ImageType'])                            # E.g. ImageType = "['ORIGINAL', 'PRIMARY', 'M', 'ND']"
+                    imagetype = ast.literal_eval(run.attributes['ImageType'])                               # E.g. ImageType = "['ORIGINAL', 'PRIMARY', 'M', 'ND']"
                     if 'P' in imagetype:
                         run.bids['part'][-1] = run.bids['part'].index('phase')                              # E.g. part = ['', mag, phase, real, imag, 0]
                     # elif 'M' in imagetype:
@@ -178,7 +178,7 @@ def bidsmapper_plugin(session: Path, bidsmap_new: BidsMap, bidsmap_old: BidsMap,
                     elif 'R' in imagetype:
                         run.bids['part'][-1] = run.bids['part'].index('real')
                     if run.bids['part'][-1]:
-                        LOGGER.verbose(f"Updated {dataformat}/{datasource.datatype} entity: 'part' -> '{run.bids['part'][run.bids['part'][-1]]}' ({imagetype})")
+                        LOGGER.verbose(f"Updated {run} entity: 'part' -> '{run.bids['part'][run.bids['part'][-1]]}' ({imagetype})")
 
             else:
                 LOGGER.bcdebug(f"Known sample: {datasource}")
@@ -441,7 +441,7 @@ def bidscoiner_plugin(session: Path, bidsmap: BidsMap, bidsses: Path) -> Union[N
                         LOGGER.warning(f"The {newbidsname} image is a derivate / not BIDS-compliant -- you can probably delete it safely and update {scans_tsv}")
 
                 # Save the NIfTI file with the newly constructed name
-                newbidsname = bids.increment_runindex(outfolder, newbidsname, run, scans_table, targets)        # Update the runindex now that the name has changed
+                newbidsname = run.increment_runindex(outfolder, newbidsname, scans_table, targets)        # Update the runindex now that the name has changed
                 newbidsfile = outfolder/newbidsname
                 LOGGER.verbose(f"Found dcm2niix {postfixes} postfixes, renaming\n{dcm2niixfile} ->\n{newbidsfile}")
                 if newbidsfile.is_file():
@@ -454,7 +454,7 @@ def bidscoiner_plugin(session: Path, bidsmap: BidsMap, bidsses: Path) -> Union[N
                     oldfile.replace(newbidsfile.with_suffix('').with_suffix(''.join(oldfile.suffixes)))
 
         # Write out provenance data
-        bids.bidsprov(bidsses, source, runid, datasource.datatype, targets)
+        bids.bidsprov(bidsses, source, runid, run.datatype, targets)
 
         # Loop over all non-derivative targets (i.e. the produced output files) and edit the json sidecar data
         for target in sorted(targets):
@@ -470,9 +470,9 @@ def bidscoiner_plugin(session: Path, bidsmap: BidsMap, bidsses: Path) -> Union[N
             metadata = bids.updatemetadata(datasource, jsonfile, run.meta, options.get('meta',[]))
 
             # Remove the bval/bvec files of sbref- and inv-images (produced by dcm2niix but not allowed by the BIDS specifications)
-            if ((datasource.datatype == 'dwi'  and suffix == 'sbref') or
-                (datasource.datatype == 'fmap' and suffix == 'epi')   or
-                (datasource.datatype == 'anat' and suffix == 'MP2RAGE')):
+            if ((run.datatype == 'dwi'  and suffix == 'sbref') or
+                (run.datatype == 'fmap' and suffix == 'epi')   or
+                (run.datatype == 'anat' and suffix == 'MP2RAGE')):
                 for ext in ('.bval', '.bvec'):
                     bfile = target.with_suffix('').with_suffix(ext)
                     if bfile.is_file() and not bids.check_ignore(bfile.name, bidsignore, 'file'):
diff --git a/bidscoin/plugins/nibabel2bids.py b/bidscoin/plugins/nibabel2bids.py
index bcef792d..5e295aad 100644
--- a/bidscoin/plugins/nibabel2bids.py
+++ b/bidscoin/plugins/nibabel2bids.py
@@ -11,7 +11,7 @@
 from typing import Union
 from pathlib import Path
 from bidscoin import bids
-from bidscoin.bids import BidsMap, Plugin, Plugins
+from bidscoin.bids import BidsMap, DataFormat, Plugin, Plugins
 
 try:
     from nibabel.testing import data_path
@@ -79,7 +79,7 @@ def has_support(file: Path, dataformat: Union[DataFormat, str]='') -> str:
     return ''
 
 
-def get_attribute(dataformat: str, sourcefile: Path, attribute: str, options: Plugin) -> Union[str, int, float, list]:
+def get_attribute(dataformat: Union[DataFormat, str], sourcefile: Path, attribute: str, options: Plugin) -> Union[str, int, float, list]:
     """
     This plugin supports reading attributes from DICOM and PAR dataformats
 
@@ -121,8 +121,8 @@ def bidsmapper_plugin(session: Path, bidsmap_new: BidsMap, bidsmap_old: BidsMap,
     datasource = bids.get_datasource(session, plugins, recurse=2)
     if not datasource.dataformat:
         return
-    if not (template.dataformat(datasource.dataformat) or bidsmap_old[datasource.dataformat]):
-        LOGGER.error(f"No {datasource.dataformat} source information found in the bidsmap and template")
+    if datasource.dataformat not in template.dataformats + bidsmap_old.dataformats:
+        LOGGER.error(f"No {datasource} source information found in the bidsmap and template")
         return
 
     # Collect the different DICOM/PAR source files for all runs in the session
@@ -168,9 +168,7 @@ def bidscoiner_plugin(session: Path, bidsmap: BidsMap, bidsses: Path) -> None:
     sesid = bidsses.name if bidsses.name.startswith('ses-') else ''
 
     # Get started
-    options     = bidsmap._data['Options']['plugins']['nibabel2bids']
-    ext         = options.get('ext', '')
-    meta        = options.get('meta', [])
+    options     = bidsmap.plugins['nibabel2bids']
     sourcefiles = [file for file in session.rglob('*') if has_support(file)]
     if not sourcefiles:
         LOGGER.info(f"--> No {__name__} sourcedata found in: {session}")
@@ -187,36 +185,36 @@ def bidscoiner_plugin(session: Path, bidsmap: BidsMap, bidsses: Path) -> None:
     # Collect the different Nibabel source files for all files in the session
     for source in sourcefiles:
 
-        datasource = bids.DataSource(source, {'nibabel2bids':options})
+        datasource = bids.DataSource(source, {'nibabel2bids': options})
         run, runid = bidsmap.get_matching_run(datasource, runtime=True)
 
         # Check if we should ignore this run
-        if datasource.datatype in bidsmap.options['ignoretypes']:
+        if run.datatype in bidsmap.options['ignoretypes']:
             LOGGER.info(f"--> Leaving out: {datasource}")
-            bids.bidsprov(bidsses, source, runid, datasource.datatype)              # Write out empty provenance data
+            bids.bidsprov(bidsses, source, runid, run.datatype)     # Write out empty provenance data
             continue
 
         # Check if we already know this run
         if not runid:
-            LOGGER.error(f"Skipping unknown '{datasource.datatype}' run: {source}\n-> Re-run the bidsmapper and delete {bidsses} to solve this warning")
-            bids.bidsprov(bidsses, source)                      # Write out empty provenance data
+            LOGGER.error(f"Skipping unknown '{run.datatype}' run: {source}\n-> Re-run the bidsmapper and delete {bidsses} to solve this warning")
+            bids.bidsprov(bidsses, source)                          # Write out empty provenance data
             continue
 
         LOGGER.info(f"--> Coining: {datasource}")
 
         # Create the BIDS session/datatype output folder
-        outfolder = bidsses/datasource.datatype
+        outfolder = bidsses/run.datatype
         outfolder.mkdir(parents=True, exist_ok=True)
 
         # Compose the BIDS filename using the matched run
-        bidsignore = bids.check_ignore(datasource.datatype, bidsmap.options['bidsignore'])
-        bidsname   = bids.get_bidsname(subid, sesid, run, not bidsignore, runtime=True)
+        bidsignore = bids.check_ignore(run.datatype, bidsmap.options['bidsignore'])
+        bidsname   = run.bidsname(subid, sesid, not bidsignore, runtime=True)
         bidsignore = bidsignore or bids.check_ignore(bidsname+'.json', bidsmap.options['bidsignore'], 'file')
-        bidsname   = bids.increment_runindex(outfolder, bidsname, run, scans_table)
-        target     = (outfolder/bidsname).with_suffix(ext)
+        bidsname   = run.increment_runindex(outfolder, bidsname, scans_table)
+        target     = (outfolder/bidsname).with_suffix(options.get('ext', ''))
 
         # Check if the bidsname is valid
-        bidstest = (Path('/')/subid/sesid/datasource.datatype/bidsname).with_suffix('.nii').as_posix()
+        bidstest = (Path('/')/subid/sesid/run.datatype/bidsname).with_suffix('.nii').as_posix()
         isbids   = BIDSValidator().is_bids(bidstest)
         if not isbids and not bidsignore:
             LOGGER.warning(f"The '{bidstest}' output name did not pass the bids-validator test")
@@ -226,9 +224,9 @@ def bidscoiner_plugin(session: Path, bidsmap: BidsMap, bidsses: Path) -> None:
             LOGGER.warning(f"{target} already exists and will be deleted -- check your results carefully!")
             target.unlink()
 
-        # Save the sourcefile as a BIDS NIfTI file and out provenance data
+        # Save the sourcefile as a BIDS NIfTI file and write out provenance data
         nib.save(nib.load(source), target)
-        bids.bidsprov(bidsses, source, runid, datasource.datatype, [target] if target.is_file() else [])
+        bids.bidsprov(bidsses, source, runid, run.datatype, [target] if target.is_file() else [])
 
         # Check the output
         if not target.is_file():
@@ -237,7 +235,7 @@ def bidscoiner_plugin(session: Path, bidsmap: BidsMap, bidsses: Path) -> None:
 
         # Load/copy over the source meta-data
         sidecar  = target.with_suffix('').with_suffix('.json')
-        metadata = bids.updatemetadata(datasource, sidecar, run['meta'], meta)
+        metadata = bids.updatemetadata(datasource, sidecar, run.meta, options.get('meta', []))
         if metadata:
             with sidecar.open('w') as json_fid:
                 json.dump(metadata, json_fid, indent=4)
diff --git a/bidscoin/plugins/spec2nii2bids.py b/bidscoin/plugins/spec2nii2bids.py
index df022eb8..83b0c325 100644
--- a/bidscoin/plugins/spec2nii2bids.py
+++ b/bidscoin/plugins/spec2nii2bids.py
@@ -4,7 +4,6 @@
 in conjunction with BIDS sidecar files"""
 
 import logging
-import shutil
 import json
 import pandas as pd
 import dateutil.parser
@@ -12,7 +11,7 @@
 from bids_validator import BIDSValidator
 from pathlib import Path
 from bidscoin import bcoin, bids, due, Doi
-from bidscoin.bids import BidsMap, Plugin
+from bidscoin.bids import BidsMap, DataFormat, Plugin, Plugins
 
 LOGGER = logging.getLogger(__name__)
 
@@ -70,7 +69,7 @@ def has_support(file: Path, dataformat: Union[DataFormat, str]='') -> str:
     return ''
 
 
-def get_attribute(dataformat: str, sourcefile: Path, attribute: str, options: Plugin) -> str:
+def get_attribute(dataformat: Union[DataFormat, str], sourcefile: Path, attribute: str, options: Plugin) -> str:
     """
     This plugin function reads attributes from the supported sourcefile
 
@@ -103,7 +102,7 @@ def get_attribute(dataformat: str, sourcefile: Path, attribute: str, options: Pl
     LOGGER.error(f"Unsupported MRS data-format: {dataformat}")
 
 
-def bidsmapper_plugin(session: Path, bidsmap_new: BidsMap, bidsmap_old: BidsMap, template: BidsMap, store: dict) -> None:
+def bidsmapper_plugin(session: Path, bidsmap_new: BidsMap, bidsmap_old: BidsMap, template: BidsMap) -> None:
     """
     All the heuristics spec2nii2bids attributes and properties onto bids labels and meta-data go into this plugin function.
     The function is expected to update/append new runs to the bidsmap_new data structure. The bidsmap options for this plugin
@@ -115,25 +114,20 @@ def bidsmapper_plugin(session: Path, bidsmap_new: BidsMap, bidsmap_old: BidsMap,
     :param bidsmap_new: The new study bidsmap that we are building
     :param bidsmap_old: The previous study bidsmap that has precedence over the template bidsmap
     :param template:    The template bidsmap with the default heuristics
-    :param store:       The paths of the source- and target-folder
     :return:
     """
 
     # Get the plugin settings
-    plugins = {'spec2nii2bids': Plugin(bidsmap_new['Options']['plugins']['spec2nii2bids'])}
+    plugins = Plugins({'spec2nii2bids': bidsmap_new.plugins['spec2nii2bids']})
 
     # Update the bidsmap with the info from the source files
     for sourcefile in [file for file in session.rglob('*') if has_support(file)]:
 
         datasource = bids.DataSource(sourcefile, plugins)
-        dataformat = datasource.dataformat
 
         # Input checks
-        if not template[dataformat] and not bidsmap_old[dataformat]:
-            LOGGER.error(f"No {dataformat} source information found in the bidsmap and template for: {sourcefile}")
-            return
-        if not template.get(dataformat) and not bidsmap_old.get(dataformat):
-            LOGGER.error(f"No {dataformat} source information found in the bidsmap and template for: {sourcefile}")
+        if datasource.dataformat not in template.dataformats + bidsmap_old.dataformats:
+            LOGGER.error(f"No {datasource} information found in the bidsmap and template for: {sourcefile}")
             return
 
         # See if we can find a matching run in the old bidsmap
@@ -179,7 +173,7 @@ def bidscoiner_plugin(session: Path, bidsmap: BidsMap, bidsses: Path) -> Union[N
 
     # Get started and see what dataformat we have
     options     = bidsmap.plugins['spec2nii2bids']
-    datasource  = bids.get_datasource(session, {'spec2nii2bids':options})
+    datasource  = bids.get_datasource(session, {'spec2nii2bids': options})
     dataformat  = datasource.dataformat
     sourcefiles = [file for file in session.rglob('*') if has_support(file)]
     if not sourcefiles:
@@ -202,32 +196,32 @@ def bidscoiner_plugin(session: Path, bidsmap: BidsMap, bidsses: Path) -> Union[N
         run, runid = bidsmap.get_matching_run(datasource, runtime=True)
 
         # Check if we should ignore this run
-        if datasource.datatype in bidsmap.options['ignoretypes']:
+        if run.datatype in bidsmap.options['ignoretypes']:
             LOGGER.info(f"--> Leaving out: {source}")
-            bids.bidsprov(bidsses, source, runid, datasource.datatype)              # Write out empty provenance data
+            bids.bidsprov(bidsses, source, runid, run.datatype)              # Write out empty provenance data
             continue
 
         # Check that we know this run
         if not runid:
-            LOGGER.error(f"Skipping unknown '{datasource.datatype}' run: {source}\n-> Re-run the bidsmapper and delete the MRS output data in {bidsses} to solve this warning")
+            LOGGER.error(f"Skipping unknown '{run.datatype}' run: {source}\n-> Re-run the bidsmapper and delete the MRS output data in {bidsses} to solve this warning")
             bids.bidsprov(bidsses, source)                  # Write out empty provenance data
             continue
 
         LOGGER.info(f"--> Coining: {source}")
 
         # Create the BIDS session/datatype output folder
-        outfolder = bidsses/datasource.datatype
+        outfolder = bidsses/run.datatype
         outfolder.mkdir(parents=True, exist_ok=True)
 
         # Compose the BIDS filename using the matched run
-        bidsignore = bids.check_ignore(datasource.datatype, bidsmap.options['bidsignore'])
-        bidsname   = bids.get_bidsname(subid, sesid, run, not bidsignore, runtime=True)
+        bidsignore = bids.check_ignore(run.datatype, bidsmap.options['bidsignore'])
+        bidsname   = run.get_bidsname(subid, sesid, not bidsignore, runtime=True)
         bidsignore = bidsignore or bids.check_ignore(bidsname+'.json', bidsmap.options['bidsignore'], 'file')
-        bidsname   = bids.increment_runindex(outfolder, bidsname, run, scans_table)
+        bidsname   = run.increment_runindex(outfolder, bidsname, scans_table)
         target     = (outfolder/bidsname).with_suffix('.nii.gz')
 
         # Check if the bidsname is valid
-        bidstest = (Path('/')/subid/sesid/datasource.datatype/bidsname).with_suffix('.nii').as_posix()
+        bidstest = (Path('/')/subid/sesid/run.datatype/bidsname).with_suffix('.nii').as_posix()
         isbids   = BIDSValidator().is_bids(bidstest)
         if not isbids and not bidsignore:
             LOGGER.warning(f"The '{bidstest}' output name did not pass the bids-validator test")
@@ -254,7 +248,7 @@ def bidscoiner_plugin(session: Path, bidsmap: BidsMap, bidsses: Path) -> Union[N
             return
         command = options.get('command', 'spec2nii')
         errcode = bcoin.run_command(f'{command} {dformat} -j -f "{bidsname}" -o "{outfolder}" {args} {arg} "{source}"')
-        bids.bidsprov(bidsses, source, runid, datasource.datatype, [target] if target.is_file() else [])
+        bids.bidsprov(bidsses, source, runid, run.datatype, [target] if target.is_file() else [])
         if not target.is_file():
             if not errcode:
                 LOGGER.error(f"Output file not found: {target}")
@@ -262,7 +256,7 @@ def bidscoiner_plugin(session: Path, bidsmap: BidsMap, bidsses: Path) -> Union[N
 
         # Load/copy over and adapt the newly produced json sidecar-file
         sidecar  = target.with_suffix('').with_suffix('.json')
-        metadata = bids.updatemetadata(datasource, sidecar, run['meta'], options.get('meta',[]))
+        metadata = bids.updatemetadata(datasource, sidecar, run.meta, options.get('meta',[]))
         if metadata:
             with sidecar.open('w') as json_fid:
                 json.dump(metadata, json_fid, indent=4)
@@ -290,7 +284,7 @@ def bidscoiner_plugin(session: Path, bidsmap: BidsMap, bidsses: Path) -> Union[N
 
     # Write the scans_table to disk
     LOGGER.verbose(f"Writing acquisition time data to: {scans_tsv}")
-    scans_table.sort_values(by=['acq_time','filename'], inplace=True)
+    scans_table.sort_values(by=['acq_time', 'filename'], inplace=True)
     scans_table.replace('','n/a').to_csv(scans_tsv, sep='\t', encoding='utf-8', na_rep='n/a')
 
     # Collect personal data for the participants.tsv file
diff --git a/bidscoin/utilities/bidsparticipants.py b/bidscoin/utilities/bidsparticipants.py
index 70aede9b..96e94102 100755
--- a/bidscoin/utilities/bidsparticipants.py
+++ b/bidscoin/utilities/bidsparticipants.py
@@ -11,10 +11,10 @@
     import sys
     sys.path.append(str(Path(__file__).parents[2]))
 from bidscoin import bcoin, bids, lsdirs, trackusage, __version__
-from bidscoin.bids import Bidsmap
+from bidscoin.bids import BidsMap
 
 
-def scanpersonals(bidsmap: Bidsmap, session: Path, personals: dict, keys: list) -> bool:
+def scanpersonals(bidsmap: BidsMap, session: Path, personals: dict, keys: list) -> bool:
     """
     Converts the session source-files into BIDS-valid NIfTI-files in the corresponding bidsfolder and
     extracts personals (e.g. Age, Sex) from the source header
@@ -69,11 +69,9 @@ def bidsparticipants(sourcefolder: str, bidsfolder: str, keys: list, bidsmap: st
     rawfolder  = Path(sourcefolder).resolve()
     bidsfolder = Path(bidsfolder).resolve()
     if not rawfolder.is_dir():
-        print(f"Rawfolder '{rawfolder}' not found")
-        return
+        raise SystemExit(f"\n[ERROR] Exiting the program because your sourcefolder argument '{sourcefolder}' was not found")
     if not bidsfolder.is_dir():
-        print(f"Bidsfolder '{bidsfolder}' not found")
-        return
+        raise SystemExit(f"\n[ERROR] Exiting the program because your bidsfolder argument '{bidsfolder}' was not found")
 
     # Start logging
     if dryrun:
@@ -85,8 +83,8 @@ def bidsparticipants(sourcefolder: str, bidsfolder: str, keys: list, bidsmap: st
     LOGGER.info(f">>> bidsparticipants sourcefolder={rawfolder} bidsfolder={bidsfolder} bidsmap={bidsmap}")
 
     # Get the bidsmap sub-/ses-prefix from the bidsmap YAML-file
-    bidsmap,_ = bids.load_bidsmap(Path(bidsmap), bidsfolder/'code'/'bidscoin', checks=(False, False, False))
-    if not bidsmap:
+    bidsmap = BidsMap(Path(bidsmap), bidsfolder/'code'/'bidscoin', checks=(False, False, False))
+    if not bidsmap.filepath.name:
         LOGGER.info('Make sure to run "bidsmapper" first, exiting now')
         return
     subprefix = bidsmap.options['subprefix']
@@ -122,7 +120,7 @@ def bidsparticipants(sourcefolder: str, bidsfolder: str, keys: list, bidsmap: st
             for session in sessions:
 
                 success      = False            # Only take data from the first session -> BIDS specification
-                subid, sesid = bids.DataSource(session/'dum.my', subprefix=subprefix, sesprefix=sesprefix).subid_sesid()
+                subid, sesid = bids.DataSource(session/'dum.my', bidsmap.plugins, '', bidsmap.options).subid_sesid()
 
                 # Unpack the data in a temporary folder if it is tarballed/zipped and/or contains a DICOMDIR file
                 sesfolders, unpacked = bids.unpack(session, bidsmap.options.get('unzip',''))
@@ -163,9 +161,9 @@ def main():
     try:
         bidsparticipants(**vars(args))
 
-    except Exception:
+    except Exception as error:
         trackusage('bidsparticipants_exception')
-        raise
+        raise error
 
 
 if __name__ == "__main__":
diff --git a/bidscoin/utilities/dicomsort.py b/bidscoin/utilities/dicomsort.py
index e61700da..dafcb829 100755
--- a/bidscoin/utilities/dicomsort.py
+++ b/bidscoin/utilities/dicomsort.py
@@ -216,9 +216,9 @@ def main():
     try:
         sortsessions(**vars(args))
 
-    except Exception:
+    except Exception as error:
         trackusage('dicomsort_exception')
-        raise
+        raise error
 
 
 if __name__ == "__main__":
diff --git a/bidscoin/utilities/rawmapper.py b/bidscoin/utilities/rawmapper.py
index 5e8ee01f..f98a1bbe 100755
--- a/bidscoin/utilities/rawmapper.py
+++ b/bidscoin/utilities/rawmapper.py
@@ -29,8 +29,7 @@ def rawmapper(sourcefolder, outfolder: str='', sessions: tuple=(), rename: bool=
     # Input checking
     rawfolder = Path(sourcefolder).resolve()
     if not rawfolder.is_dir():
-        print(f"Rawfolder '{rawfolder}' not found")
-        return
+        raise SystemExit(f"\n[ERROR] Exiting the program because your sourcefolder argument '{sourcefolder}' was not found")
     print(f"Mapping: {rawfolder}")
     if not outfolder or not Path(outfolder).name:
         outfolder = rawfolder
@@ -68,7 +67,7 @@ def rawmapper(sourcefolder, outfolder: str='', sessions: tuple=(), rename: bool=
     for session in sorted(sessions):
 
         # Get the (uncleaned) subject and session identifiers from the sourcefolder
-        datasource = bids.DataSource(session/'dum.my', subprefix=subprefix, sesprefix=sesprefix)
+        datasource = bids.DataSource(session/'dum.my', options={'subprefix': subprefix, 'sesprefix': sesprefix})
         subid      = datasource.dynamicvalue(f"<filepath:/{datasource.resubprefix}(.*?)/>", cleanup=False)
         sesid      = datasource.dynamicvalue(f"<filepath:/{datasource.resubprefix}.*?/{datasource.resesprefix}(.*?)/>", cleanup=False) if sesprefix else ''
 
@@ -147,9 +146,9 @@ def main():
     try:
         rawmapper(**vars(args))
 
-    except Exception:
+    except Exception as error:
         trackusage('rawmapper_exception')
-        raise
+        raise error
 
 
 if __name__ == "__main__":
diff --git a/tests/test_bids.py b/tests/test_bids.py
index fd70f178..6c34f0cc 100644
--- a/tests/test_bids.py
+++ b/tests/test_bids.py
@@ -4,14 +4,13 @@
 import shutil
 import re
 import json
-import ruamel.yaml.comments
 from datetime import datetime, timedelta
 from importlib.util import find_spec
 from pathlib import Path
 from nibabel.testing import data_path
 from pydicom.data import get_testdata_file
 from bidscoin import bcoin, bids, bidsmap_template
-from bidscoin.bids import Run, Plugin, Meta
+from bidscoin.bids import BidsMap, RunItem, DataSource, Plugin, Meta
 
 bcoin.setup_logging()
 
@@ -47,14 +46,14 @@ class TestDataSource:
 
     @pytest.fixture()
     def datasource(self, dcm_file):
-        return bids.DataSource(dcm_file, {'dcm2niix2bids': Plugin({})}, 'DICOM')
+        return DataSource(dcm_file, {'dcm2niix2bids': Plugin({})}, 'DICOM')
 
     @pytest.fixture()
     def extdatasource(self, dcm_file, tmp_path):
         ext_dcm_file = shutil.copyfile(dcm_file, tmp_path/dcm_file.name)
         with ext_dcm_file.with_suffix('.json').open('w') as sidecar:
             json.dump({'PatientName': 'ExtendedAttributesTest'}, sidecar)
-        return bids.DataSource(ext_dcm_file, {'dcm2niix2bids': Plugin({})}, 'DICOM')
+        return DataSource(ext_dcm_file, {'dcm2niix2bids': Plugin({})}, 'DICOM')
 
     def test_is_datasource(self, datasource):
         assert datasource.has_plugin()
@@ -78,7 +77,8 @@ def test_subid_sesid(self, subid, sesid, subprefix, sesprefix, tmp_path, dcm_fil
         subsesdir     = tmp_path/'data'/subid/sesid
         subsesdir.mkdir(parents=True)
         subses_file   = shutil.copy(dcm_file, subsesdir)
-        subses_source = bids.DataSource(subses_file, {'dcm2niix2bids': Plugin({})}, 'DICOM', subprefix=subprefix, sesprefix=sesprefix)
+        options       = {'subprefix': subprefix, 'sesprefix': sesprefix}
+        subses_source = DataSource(subses_file, {'dcm2niix2bids': Plugin({})}, 'DICOM', options)
         sub, ses      = subses_source.subid_sesid(f"<<filepath:/data/{subses_source.resubprefix}(.*?)/>>", f"<<filepath:/data/{subses_source.resubprefix}.*?/{subses_source.resesprefix}(.*?)/>>")
         expected_sub  = 'sub-' + bids.sanitize(re.sub(f"^{subses_source.resubprefix}", '', subid)  if subid.startswith(subprefix) or subprefix=='*' else '')  # NB: this expression is too complicated/resembles the actual code too much :-/
         expected_ses  = 'ses-' + bids.sanitize(re.sub(f"^{subses_source.resesprefix}", '', sesid)) if (subid.startswith(subprefix) or subprefix=='*') and (sesid.startswith(sesprefix) or sesprefix=='*') and sesid else ''
@@ -99,6 +99,396 @@ def test_dynamicvalue(self, datasource):
         assert datasource.dynamicvalue(r'<(0x10, 0x10)>')                                        == 'CompressedSamplesMR1'
         assert datasource.dynamicvalue(r'<(0010, 0010)>')                                        == 'CompressedSamplesMR1'
 
+
+class TestRunItem:
+    """Test the bids.RunItem class"""
+
+    def test_check_run(self):
+
+        # Create a valid func run-item (NB: this is dependent on the BIDS version)
+        runitem = RunItem('DICOM', 'func', {'bids': {'task':'rest', 'acq':'', 'ce':'', 'dir':'', 'rec':'', 'run':'<<>>', 'echo':'1', 'part': ['','mag','phase','real','imag',0], 'chunk':'', 'suffix':'bold'}})
+        checks  = (True, True, True)             # = (keys, suffixes, values)
+
+        # Check various data types
+        runitem.datatype = 'foo';  assert runitem.check(checks) == (None, None,  None)
+        runitem.datatype = 'anat'; assert runitem.check(checks) == (None, False, None)
+        runitem.datatype = 'func'; assert runitem.check(checks) == (True, True,  True)
+
+        # Check bids-keys
+        runitem.bids['flip'] = 'foo'    # Add a false key
+        assert runitem.check(checks) == (False, True, None)
+        del runitem.bids['flip']        # Remove the false key
+        del runitem.bids['acq']         # Remove a valid key
+        assert runitem.check(checks) == (False, True, True)
+        runitem.bids['acq'] = 'foo'     # Restore the valid key
+
+        # Check bids-suffix
+        runitem.bids['suffix'] = 'T1w'  # Set an invalid suffix
+        assert runitem.check(checks) == (None, False, None)
+        runitem.bids['suffix'] = 'bold' # Restore the suffix
+
+        # Check bids-values
+        runitem.bids['task'] = ''       # Remove a required value
+        assert runitem.check(checks) == (True, True, False)
+        runitem.bids['task'] = 'f##'    # Add invalid characters
+        assert runitem.check(checks) == (True, True, False)
+        runitem.bids['task'] = 'rest'   # Restore the value
+        runitem.bids['run']  = 'a'      # Add an invalid (non-numeric) index
+        assert runitem.check(checks) == (True, True, False)
+
+    def test_get_bidsname(self, raw_dicomdir):
+
+        dicomfile = raw_dicomdir/'Doe^Archibald'/'01-XR C Spine Comp Min 4 Views'/'001-Cervical LAT'/'6154'
+
+        # Get a run-item from a bidsmap
+        datasource = DataSource(dicomfile, {'dcm2niix2bids': Plugin({})}, 'DICOM')
+        runitem    = RunItem('DICOM', '', {'bids': {'acq':'py#dicom', 'foo@':'bar#123', 'run':'<<SeriesNumber>>', 'suffix':'T0w'}}, datasource)
+        
+        bidsname = runitem.bidsname('sub-001', 'ses-01', validkeys=False, cleanup=False)  # Test default: runtime=False
+        assert bidsname == 'sub-001_ses-01_acq-py#dicom_run-<<SeriesNumber>>_foo@-bar#123_T0w'
+
+        bidsname = runitem.bidsname('sub-001', 'ses-01', validkeys=False, runtime=False, cleanup=True)
+        assert bidsname == 'sub-001_ses-01_acq-pydicom_run-SeriesNumber_foo@-bar123_T0w'
+
+        bidsname = runitem.bidsname('sub-001', 'ses-01', validkeys=False, runtime=True,  cleanup=False)
+        assert bidsname == 'sub-001_ses-01_acq-py#dicom_run-1_foo@-bar#123_T0w'
+
+        bidsname = runitem.bidsname('sub-001', 'ses-01', validkeys=True,  runtime=True,  cleanup=False)
+        assert bidsname == 'sub-001_ses-01_acq-py#dicom_run-1_T0w'
+
+        runitem.bids['run'] = '<<1>>'
+        bidsname = runitem.bidsname('sub-001', '', validkeys=True, runtime=True)          # Test default: cleanup=True
+        assert bidsname == 'sub-001_acq-pydicom_run-1_T0w'
+
+        runitem.bids['run'] = '<<>>'
+        bidsname = runitem.bidsname('sub-001', '', validkeys=True, runtime=True)          # Test default: cleanup=True
+        assert bidsname == 'sub-001_acq-pydicom_T0w'
+
+    def test_increment_runindex(self, tmp_path):
+        """Test if run-index is preserved or added to the bidsname, files are renamed and scans-table updated"""
+
+        # Define the test data
+        outfolder = tmp_path/'bids'/'sub-01'/'anat'
+        outfolder.mkdir(parents=True)
+        runless   = 'sub-01_T1w'
+        run1      = 'sub-01_run-1_T1w'
+        run2      = 'sub-01_run-2_T1w'
+        run3      = 'sub-01_run-3_T1w'
+
+        # ------- Tests with no existing output files -------
+
+        runitem  = RunItem('', '', {'bids': {'run': '<<>>'}})
+        bidsname = runitem.increment_runindex(outfolder, runless)
+        assert bidsname == runless
+
+        runitem  = RunItem('', '', {'bids': {'run': '<<1>>'}})
+        bidsname = runitem.increment_runindex(outfolder, run1 + '.nii')
+        assert bidsname == run1 + '.nii'
+
+        runitem  = RunItem('', '', {'bids': {'run': '<<2>>'}})
+        bidsname = runitem.increment_runindex(outfolder, run2 + '.nii.gz')
+        assert bidsname == run2 + '.nii.gz'
+
+        # ------- Tests with run-less output files -------
+
+        # Create run-less output files
+        for suffix in ('.nii.gz', '.json'):
+            (outfolder/runless).with_suffix(suffix).touch()
+
+        # Test renaming of run-less to run-1 + updating scans_table
+        runitem  = RunItem('', '', {'bids': {'run': '<<>>'}})
+        bidsname = runitem.increment_runindex(outfolder, runless)
+        assert bidsname == run2
+        for suffix in ('.nii.gz', '.json'):
+            assert (outfolder/runless).with_suffix(suffix).is_file() is False
+            assert (outfolder/run1   ).with_suffix(suffix).is_file() is True
+
+        # We now have run-1 files only
+        runitem  = RunItem('', '', {'bids': {'run': '<<1>>'}})
+        bidsname = runitem.increment_runindex(outfolder, run1)
+        assert bidsname == run2
+
+        # ------- Tests with run-1 & run-2 output files -------
+
+        # Create run-2 output files
+        for suffix in ('.nii.gz', '.json'):
+            (outfolder/run2).with_suffix(suffix).touch()
+
+        runitem  = RunItem('', '', {'bids': {'run': '<<>>'}})
+        bidsname = runitem.increment_runindex(outfolder, runless + '.nii.gz')
+        assert bidsname == run3 + '.nii.gz'
+
+        runitem  = RunItem('', '', {'bids': {'run': '<<1>>'}})
+        bidsname = runitem.increment_runindex(outfolder, run1)
+        assert bidsname == run3
+
+        runitem  = RunItem('', '', {'bids': {'run': '<<AttrKey>>'}})
+        bidsname = runitem.increment_runindex(outfolder, run1)
+        assert bidsname == run1                         # -> Must remain untouched
+
+        runitem  = RunItem('', '', {'bids': {'run': '2'}})
+        bidsname = runitem.increment_runindex(outfolder, run1)
+        assert bidsname == run1                         # -> Must remain untouched
+
+    def test_strip_suffix(self):
+        pass
+
+
+class TestDataType:
+    """Test the bids.DataType class"""
+
+    def test_runitems(self):
+        pass
+
+    def test_delete_runs(self):
+        pass
+
+    def test_isert_run(self):
+        pass
+
+    def test_replace_run(self):
+        pass
+
+
+class TestDataFormat:
+    """Test the bids.DataFormat class"""
+
+    def test_subject(self):
+        pass
+
+    def test_session(self):
+        pass
+
+    def test_datatypes(self):
+        pass
+
+    def test_datatype(self):
+        pass
+
+    def test_add_datatype(self):
+        pass
+
+    def test_delete_run(self):
+        pass
+
+
+class TestBidsMap:
+    """Test the bids.BidsMap class"""
+
+    def test_init(self, study_bidsmap):
+
+        # Test loading with standard arguments
+        bidsmap = BidsMap(Path(study_bidsmap.name), study_bidsmap.parent)
+        assert bidsmap.filepath == study_bidsmap
+        assert bidsmap.dataformat('DICOM').datatype('anat').runitems[0].provenance == '/Users/galassiae/Projects/bidscoin/bidscointutorial/raw/sub-001/ses-01/007-t1_mprage_sag_ipat2_1p0iso/00001_1.3.12.2.1107.5.2.43.66068.2020042808523182387402502.IMA'
+        assert bidsmap.dataformat('DICOM').datatype('func').runitems[0].bids['part'] == ['', 'mag', 'phase', 'real', 'imag', 0]
+        assert bidsmap.dataformat('DICOM').datatype('func').runitems[1].bids['part'] == ['', 'mag', 'phase', 'real', 'imag', 3]
+        assert bidsmap.dataformat('DICOM').datatype('func').runitems[2].bids['part'] == ['', 'mag', 'phase', 'real', 'imag', 0]
+
+        # Test loading with fullpath argument
+        bidsmap = BidsMap(study_bidsmap)
+        assert bidsmap.dataformat('DICOM').datatype('anat').runitems[0].provenance == '/Users/galassiae/Projects/bidscoin/bidscointutorial/raw/sub-001/ses-01/007-t1_mprage_sag_ipat2_1p0iso/00001_1.3.12.2.1107.5.2.43.66068.2020042808523182387402502.IMA'
+
+        # Test loading with standard argument for the template bidsmap
+        bidsmap = BidsMap(Path('bidsmap_dccn'))
+        assert bidsmap.dataformat('DICOM').datatype('anat').runitems[0].provenance == str(Path('sub-unknown/ses-unknown/DICOM_anat_id001'))     # Account for Windows paths
+
+        # Test loading with a dummy argument
+        bidsmap = BidsMap(Path('dummy'))
+        assert len(bidsmap.dataformats) == 0
+        assert bidsmap.filepath.name    == ''
+
+    @pytest.mark.parametrize('template', bcoin.list_plugins()[1])   # Pass the default template bidsmaps
+    def test_check_templates(self, template: Path):
+
+        # Load a valid template
+        bidsmap = BidsMap(template, checks=(False, False, False))
+        assert bidsmap.check_template() is True
+
+        # Add and remove an invalid data type
+        bidsmap.dataformats[0].add_datatype('foo')
+        assert bidsmap.check_template() is False
+        bidsmap.dataformats[0].remove_datatype('foo')
+        assert bidsmap.check_template() is True
+
+        # Remove a valid suffix (BIDS-entity)
+        valid_run = bidsmap.dataformats[0].datatype('anat').runitems[-2].provenance     # NB: [-2] -> The first item(s) can be non-unique, the last item can be a non-BIDS entity, i.e. CT
+        bidsmap.dataformats[0].datatype('anat').delete_run(valid_run)
+        assert bidsmap.check_template() is False
+
+    def test_dataformat(self):
+        pass
+
+    def test_add_dataformat(self):
+        pass
+
+    def test_remove_dataformat(self):
+        pass
+
+    def test_validate(self, study_bidsmap):
+
+        # Load a BIDS-valid study bidsmap
+        bidsmap = BidsMap(study_bidsmap)
+        assert bidsmap.validate() is True
+
+        # Validate the bids-keys
+        runitem = bidsmap.dataformat('DICOM').datatype('func').runitems[0]
+        runitem.bids['flip'] = 'foo'     # Add a false key
+        assert bidsmap.validate() is False
+        del runitem.bids['flip']
+        del runitem.bids['task']         # Remove a required key
+        assert bidsmap.validate() is False
+        runitem.bids['task'] = 'foo'
+
+        # Check bids-suffix
+        runitem.bids['suffix'] = 'T1w'   # Set an invalid suffix
+        assert bidsmap.validate() is False
+        runitem.bids['suffix'] = 'bold'
+
+        # Check bids-values
+        runitem.bids['task'] = ''        # Remove a required value
+        assert bidsmap.validate() is False
+        runitem.bids['task'] = 'f##'     # Add invalid characters (they are cleaned out)
+        assert bidsmap.validate() is True
+        runitem.bids['task'] = 'foo'
+        runitem.bids['run']  = 'a'       # Add an invalid (non-numeric) index
+        assert bidsmap.validate() is False
+
+
+    def test_check(self, study_bidsmap):
+
+        # Load a template and a study bidsmap
+        templatebidsmap = BidsMap(bidsmap_template, checks=(True, True, False))
+        studybidsmap    = BidsMap(study_bidsmap)
+
+        # Test the output of the template bidsmap
+        checks   = (True, True, False)              # Check keys and suffixes, but not the values (as that makes no sense for a template bidsmap)
+        is_valid = templatebidsmap.check(checks)
+        for valid, check in zip(is_valid, checks):
+            assert valid in (None, True, False)
+            if check:
+                assert valid in (None, True)
+
+        # Test the output of the study bidsmap
+        checks   = (True, True, True)               # Check keys, suffixes and values (should all be checked for a study bidsmap)
+        is_valid = studybidsmap.check(checks)
+        for valid, check in zip(is_valid, checks):
+            assert valid in (None, True, False)
+            if check:
+                assert valid is True
+
+    def test_find_run(self, study_bidsmap):
+
+        # Load a bidsmap and create a duplicate dataformat section named PET
+        bidsmap = BidsMap(study_bidsmap)
+        dformat = copy.deepcopy(bidsmap.dataformat('DICOM'))
+        dformat.dataformat = 'PET'
+        bidsmap.add_dataformat(dformat)
+
+        # Collect provenance of the first anat run-item
+        provenance = bidsmap.dataformat('DICOM').datatype('anat').runitems[0].provenance
+        provtag    = '123456789'
+        bidsmap.dataformat('PET').datatype('anat').runitems[0].provenance = provtag
+
+        # Find run with the wrong dataformat
+        run = bidsmap.find_run(provenance, dataformat='PET')
+        assert run is None
+
+        # Find run with the wrong data type
+        run = bidsmap.find_run(provenance, datatype='func')
+        assert run is None
+
+        # Find run with partial provenance
+        run = bidsmap.find_run('sub-001')
+        assert run is None
+
+        # Find run with full provenance
+        run = bidsmap.find_run(provenance)
+        assert isinstance(run, RunItem)
+        run = bidsmap.find_run(provtag, dataformat='PET', datatype='anat')
+        assert run.provenance == provtag
+
+
+    def test_delete_run(self, study_bidsmap):
+
+        # Load a study bidsmap and delete one anat run
+        bidsmap    = BidsMap(study_bidsmap)
+        nritems    = len(bidsmap.dataformat('DICOM').datatype('anat').runitems)
+        provenance = bidsmap.dataformat('DICOM').datatype('anat').runitems[0].provenance
+        bidsmap.delete_run(provenance)
+
+        assert len(bidsmap.dataformat('DICOM').datatype('anat').runitems) == nritems - 1
+        assert bidsmap.find_run(provenance) is None
+
+
+    def test_insert_run(self, study_bidsmap):
+
+        # Load a study bidsmap and delete one anat run
+        bidsmap = BidsMap(study_bidsmap)
+
+        # Get and modify the first anat run-item
+        runitem              = copy.deepcopy(bidsmap.dataformat('DICOM').datatype('anat').runitems[0])
+        runitem.dataformat   = 'Foo'
+        runitem.datatype     = 'Bar'
+        runitem.bids['part'] = ['', 'mag', 'phase', 'real', 'imag', 3]
+
+        # Insert the run elsewhere in the bidsmap
+        bidsmap.insert_run(runitem)
+        assert Path(bidsmap.dataformat(  'Foo').datatype( 'Bar').runitems[0].provenance) == Path(runitem.provenance)
+        assert Path(bidsmap.dataformat('DICOM').datatype('anat').runitems[0].provenance) == Path(runitem.provenance)
+        assert bidsmap.dataformat(  'Foo').datatype( 'Bar').runitems[0].bids['part']     == ['', 'mag', 'phase', 'real', 'imag', 3]
+        assert bidsmap.dataformat('DICOM').datatype('anat').runitems[0].bids['part']     == ['', 'mag', 'phase', 'real', 'imag', 0]
+
+        # Insert another run at the end and at the front of the list
+        runitem = copy.deepcopy(runitem)
+        runitem.bids['part'] = ['', 'mag', 'phase', 'real', 'imag', 4]
+        bidsmap.insert_run(runitem)
+        bidsmap.insert_run(runitem, 0)
+        assert bidsmap.dataformat('Foo').datatype('Bar').runitems[0].bids['part'] == ['', 'mag', 'phase', 'real', 'imag', 4]
+        assert bidsmap.dataformat('Foo').datatype('Bar').runitems[1].bids['part'] == ['', 'mag', 'phase', 'real', 'imag', 3]
+        assert bidsmap.dataformat('Foo').datatype('Bar').runitems[2].bids['part'] == ['', 'mag', 'phase', 'real', 'imag', 4]
+
+    def test_update_bidsmap(self, study_bidsmap):
+
+        # Load a study bidsmap and move the first run-item from func to anat
+        bidsmap = BidsMap(study_bidsmap)
+
+        # Collect and modify the first func run-item
+        runitem          = copy.deepcopy(bidsmap.dataformat('DICOM').datatype('func').runitems[0])
+        runitem.datatype = 'anat'
+
+        # Update the bidsmap
+        bidsmap.update('func', runitem)
+        assert Path(bidsmap.dataformat('DICOM').datatype('anat').runitems[-1].provenance) == Path(runitem.provenance)
+        assert Path(bidsmap.dataformat('DICOM').datatype('func').runitems[ 0].provenance) != Path(runitem.provenance)
+
+        # Modify the last anat run-item and update the bidsmap
+        runitem.bids['foo'] = 'bar'
+        bidsmap.update('anat', runitem)
+        assert bidsmap.dataformat('DICOM').datatype('anat').runitems[-1].bids['foo'] == 'bar'
+
+    def test_exist_run(self, study_bidsmap):
+
+        # Load a bidsmap
+        bidsmap = BidsMap(study_bidsmap)
+
+        # Collect the first anat run-item
+        runitem = copy.deepcopy(bidsmap.dataformat('DICOM').datatype('anat').runitems[0])
+
+        # Find the run in the wrong data type
+        assert bidsmap.exist_run(runitem, 'func') is False
+
+        # Find run with in the right data type and in all datatypes
+        assert bidsmap.exist_run(runitem, 'anat') is True
+        assert bidsmap.exist_run(runitem) is True
+
+        # Find the wrong run in all datatypes
+        runitem.attributes['ProtocolName'] = 'abcdefg'
+        assert bidsmap.exist_run(runitem) is False
+        runitem.attributes['ProtocolName'] = ''
+        assert bidsmap.exist_run(runitem) is False
+
+
 def test_unpack(dicomdir, tmp_path):
     sessions, unpacked = bids.unpack(dicomdir.parent, '', tmp_path, None)   # None -> simulate commandline usage of dicomsort()
     assert unpacked
@@ -121,7 +511,7 @@ def test_get_dicomfile(dcm_file, dicomdir):
 
 
 def test_get_datasource(dicomdir):
-    datasource = bids.get_datasource(dicomdir.parent, {'dcm2niix2bids': Plugin({})})
+    datasource = bids.get_datasource(dicomdir.parent, {'dcm2niix2bids': {}})
     assert datasource.has_plugin()
     assert datasource.dataformat == 'DICOM'
 
@@ -169,26 +559,6 @@ def test_get_dicomfield(dcm_file_csa):
         assert value == 'N4_VB17A_LATEST_20090307'
 
 
-@pytest.mark.parametrize('template', bcoin.list_plugins()[1])
-def test_load_check_template(template: Path):
-
-    # Load a valid template
-    bidsmap, _ = bids.load_bidsmap(template, checks=(False, False, False))
-    for dataformat in bidsmap:
-        if dataformat not in ('$schema', 'Options'): break
-    assert isinstance(bidsmap, dict) and bidsmap
-    assert bids.check_template(bidsmap) is True
-
-    # Add an invalid data type
-    bidsmap[dataformat]['foo'] = bidsmap[dataformat]['extra_data']
-    assert bids.check_template(bidsmap) is False
-    del bidsmap[dataformat]['foo']
-
-    # Remove a valid suffix (BIDS-entity)
-    bidsmap[dataformat]['anat'].pop(-2)        # NB: Assumes CT is the last item, MTR the second last
-    assert bids.check_template(bidsmap) is False
-
-
 def test_match_runvalue():
     assert bids.match_runvalue('my_pulse_sequence_name', '_name')      is False
     assert bids.match_runvalue('my_pulse_sequence_name', '^my.*name$') is True
@@ -207,125 +577,6 @@ def test_match_runvalue():
     assert bids.match_runvalue(r'\[1, 2, 3\]',  [1, 2, 3])             is False
 
 
-def test_load_bidsmap(study_bidsmap):
-
-    # Test loading with standard arguments for load_bidsmap
-    bidsmap, filepath = bids.load_bidsmap(Path(study_bidsmap.name), study_bidsmap.parent)
-    assert type(bidsmap) == ruamel.yaml.comments.CommentedMap
-    assert bidsmap != {}
-    assert filepath == study_bidsmap
-    assert bidsmap['DICOM']['anat'][0]['provenance'] == '/Users/galassiae/Projects/bidscoin/bidscointutorial/raw/sub-001/ses-01/007-t1_mprage_sag_ipat2_1p0iso/00001_1.3.12.2.1107.5.2.43.66068.2020042808523182387402502.IMA'
-    assert bidsmap['DICOM']['func'][0]['bids']['part'] == ['', 'mag', 'phase', 'real', 'imag', 0]
-    assert bidsmap['DICOM']['func'][1]['bids']['part'] == ['', 'mag', 'phase', 'real', 'imag', 3]
-    assert bidsmap['DICOM']['func'][2]['bids']['part'] == ['', 'mag', 'phase', 'real', 'imag', 0]
-
-    # Test loading with fullpath argument
-    bidsmap, _ = bids.load_bidsmap(study_bidsmap)
-    assert type(bidsmap) == ruamel.yaml.comments.CommentedMap
-    assert bidsmap != {}
-    assert bidsmap['DICOM']['anat'][0]['provenance'] == '/Users/galassiae/Projects/bidscoin/bidscointutorial/raw/sub-001/ses-01/007-t1_mprage_sag_ipat2_1p0iso/00001_1.3.12.2.1107.5.2.43.66068.2020042808523182387402502.IMA'
-
-    # Test loading with standard argument for the template bidsmap
-    bidsmap, _ = bids.load_bidsmap(Path('bidsmap_dccn'))
-    assert type(bidsmap) == ruamel.yaml.comments.CommentedMap
-    assert bidsmap != {}
-    assert bidsmap['DICOM']['anat'][0]['provenance'] == str(Path('sub--unknown/ses--unknown/DICOM_anat_id001'))     # Account for Windows paths
-
-    # Test loading with a dummy argument
-    bidsmap, filepath = bids.load_bidsmap(Path('dummy'))
-    assert bidsmap  == {}
-    assert filepath == bids.templatefolder/'dummy.yaml'
-
-
-def test_validate_bidsmap(study_bidsmap):
-
-    # Load a BIDS-valid study bidsmap
-    bidsmap, _ = bids.load_bidsmap(study_bidsmap)
-    run        = bidsmap['DICOM']['func'][0]
-    assert bids.validate_bidsmap(bidsmap) is True
-
-    # Validate the bids-keys
-    run['bids']['flip'] = 'foo'     # Add a false key
-    assert bids.validate_bidsmap(bidsmap) is False
-    del run['bids']['flip']
-    del run['bids']['task']         # Remove a required key
-    assert bids.validate_bidsmap(bidsmap) is False
-    run['bids']['task'] = 'foo'
-
-    # Check bids-suffix
-    run['bids']['suffix'] = 'T1w'   # Set an invalid suffix
-    assert bids.validate_bidsmap(bidsmap) is False
-    run['bids']['suffix'] = 'bold'
-
-    # Check bids-values
-    run['bids']['task'] = ''        # Remove a required value
-    assert bids.validate_bidsmap(bidsmap) is False
-    run['bids']['task'] = 'f##'     # Add invalid characters (they are cleaned out)
-    assert bids.validate_bidsmap(bidsmap) is True
-    run['bids']['task'] = 'foo'
-    run['bids']['run']  = 'a'       # Add an invalid (non-numeric) index
-    assert bids.validate_bidsmap(bidsmap) is False
-
-
-def test_check_bidsmap(study_bidsmap):
-
-    # Load a template and a study bidsmap
-    templatebidsmap, _ = bids.load_bidsmap(bidsmap_template, checks=(True, True, False))
-    studybidsmap, _    = bids.load_bidsmap(study_bidsmap)
-
-    # Test the output of the template bidsmap
-    checks   = (True, True, False)
-    is_valid = bids.check_bidsmap(templatebidsmap, checks)
-    for each, check in zip(is_valid, checks):
-        assert each in (None, True, False)
-        if check:
-            assert each in (None, True)
-
-    # Test the output of the study bidsmap
-    is_valid = bids.check_bidsmap(studybidsmap, checks)
-    for each, check in zip(is_valid, checks):
-        assert each in (None, True, False)
-        if check:
-            assert each is True
-
-
-def test_check_run(study_bidsmap):
-
-    # Load a bidsmap
-    bidsmap, _ = bids.load_bidsmap(study_bidsmap)
-
-    # Collect the first func run-item
-    checks = (True, True, True)             # = (keys, suffixes, values)
-    run    = bidsmap['DICOM']['func'][0]
-
-    # Check data type
-    assert bids.check_run('func', run, checks) == (True, True, True)
-    assert bids.check_run('anat', run, checks) == (None, False, None)
-    assert bids.check_run('foo',  run, checks) == (None, None, None)
-
-    # Check bids-keys
-    run['bids']['flip'] = 'foo'     # Add a false key
-    assert bids.check_run('func', run, checks) == (False, True, None)
-    del run['bids']['flip']
-    del run['bids']['acq']          # Remove a valid key
-    assert bids.check_run('func', run, checks) == (False, True, True)
-    run['bids']['acq'] = 'foo'
-
-    # Check bids-suffix
-    run['bids']['suffix'] = 'T1w'   # Set an invalid suffix
-    assert bids.check_run('func', run, checks) == (None, False, None)
-    run['bids']['suffix'] = 'bold'
-
-    # Check bids-values
-    run['bids']['task'] = ''        # Remove a required value
-    assert bids.check_run('func', run, checks) == (True, True, False)
-    run['bids']['task'] = 'f##'     # Add invalid characters
-    assert bids.check_run('func', run, checks) == (True, True, False)
-    run['bids']['task'] = 'foo'
-    run['bids']['run']  = 'a'       # Add an invalid (non-numeric) index
-    assert bids.check_run('func', run, checks) == (True, True, False)
-
-
 def test_check_ignore():
 
     bidsignore = ['mrs/', 'sub-*_foo.*', '*foo/sub-*_bar.*']
@@ -348,118 +599,6 @@ def test_sanitize():
     assert bids.sanitize("Joe's reward_task") == 'Joesrewardtask'
 
 
-def test_find_run(study_bidsmap):
-
-    # Load a bidsmap and create a duplicate dataformat section
-    bidsmap, _     = bids.load_bidsmap(study_bidsmap)
-    bidsmap['PET'] = copy.deepcopy(bidsmap['DICOM'])
-
-    # Collect provenance of the first anat run-item
-    provenance                              = bidsmap['DICOM']['anat'][0]['provenance']
-    tag                                     = '123456789'
-    bidsmap['PET']['anat'][0]['provenance'] = tag
-
-    # Find run with the wrong dataformat
-    run = bids.find_run(bidsmap, provenance, dataformat='PET')
-    assert run == {}
-
-    # Find run with the wrong data type
-    run = bids.find_run(bidsmap, provenance, datatype='func')
-    assert run == {}
-
-    # Find run with partial provenance
-    run = bids.find_run(bidsmap, 'sub-001')
-    assert run == {}
-
-    # Find run with full provenance
-    run = bids.find_run(bidsmap, provenance)
-    assert isinstance(run, dict)
-    run = bids.find_run(bidsmap, tag, dataformat='PET', datatype='anat')
-    assert run.get('provenance') == tag
-
-
-def test_delete_run(study_bidsmap):
-
-    # Load a study bidsmap and delete one anat run
-    bidsmap, _ = bids.load_bidsmap(study_bidsmap)
-    nritems    = len(bidsmap['DICOM']['anat'])
-    provenance = bidsmap['DICOM']['anat'][0]['provenance']
-    bids.delete_run(bidsmap, provenance)
-
-    assert len(bidsmap['DICOM']['anat']) == nritems - 1
-    assert bids.find_run(bidsmap, provenance) == {}
-
-
-def test_insert_run(study_bidsmap):
-
-    # Load a study bidsmap and delete one anat run
-    bidsmap, _ = bids.load_bidsmap(study_bidsmap)
-
-    # Collect and modify the first anat run-item
-    datasource                   = bidsmap['DICOM']['anat'][0]['datasource']
-    run                          = bids.create_run(datasource, bidsmap)
-    run['datasource'].dataformat = 'Foo'
-    run['datasource'].datatype   = 'Bar'
-    run['bids']['part']          = ['', 'mag', 'phase', 'real', 'imag', 3]
-
-    # Insert the run elsewhere in the bidsmap
-    bids.insert_run(bidsmap, run)
-    assert Path(bidsmap['Foo']['Bar'][0]['provenance'])     == Path(run['provenance'])
-    assert Path(bidsmap['DICOM']['anat'][0]['provenance'])  == Path(run['provenance'])
-    assert bidsmap['Foo']['Bar'][0]['bids']['part']         == ['', 'mag', 'phase', 'real', 'imag', 3]
-    assert bidsmap['DICOM']['anat'][0]['bids']['part']      == ['', 'mag', 'phase', 'real', 'imag', 0]
-
-    # Insert another run at the end and at the front of the list
-    run['bids']['part']          = ['', 'mag', 'phase', 'real', 'imag', 4]
-    bids.insert_run(bidsmap, run)
-    bids.insert_run(bidsmap, run, 0)
-    assert bidsmap['Foo']['Bar'][0]['bids']['part']         == ['', 'mag', 'phase', 'real', 'imag', 4]
-    assert bidsmap['Foo']['Bar'][1]['bids']['part']         == ['', 'mag', 'phase', 'real', 'imag', 3]
-    assert bidsmap['Foo']['Bar'][2]['bids']['part']         == ['', 'mag', 'phase', 'real', 'imag', 4]
-
-
-def test_update_bidsmap(study_bidsmap):
-
-    # Load a study bidsmap and move the first run-item from func to anat
-    bidsmap, _ = bids.load_bidsmap(study_bidsmap)
-
-    # Collect and modify the first func run-item
-    run                        = copy.deepcopy(bidsmap['DICOM']['func'][0])
-    run['datasource'].datatype = 'anat'
-
-    # Update the bidsmap
-    bids.update_bidsmap(bidsmap, 'func', run)
-    assert Path(bidsmap['DICOM']['anat'][-1]['provenance']) == Path(run['provenance'])
-    assert Path(bidsmap['DICOM']['func'] [0]['provenance']) != Path(run['provenance'])
-
-    # Modify the last anat run-item and update the bidsmap
-    run['bids']['foo'] = 'bar'
-    bids.update_bidsmap(bidsmap, 'anat', run)
-    assert bidsmap['DICOM']['anat'][-1]['bids']['foo'] == 'bar'
-
-
-def test_exist_run(study_bidsmap):
-
-    # Load a bidsmap
-    bidsmap, _ = bids.load_bidsmap(study_bidsmap)
-
-    # Collect the first anat run-item
-    run = copy.deepcopy(bidsmap['DICOM']['anat'][0])
-
-    # Find the run in the wrong data type
-    assert bids.exist_run(bidsmap, 'func', run) is False
-
-    # Find run with in the right data type and in all datatypes
-    assert bids.exist_run(bidsmap, 'anat', run) is True
-    assert bids.exist_run(bidsmap, '',     run) is True
-
-    # Find the wrong run in all datatypes
-    run['attributes']['ProtocolName'] = 'abcdefg'
-    assert bids.exist_run(bidsmap, '', run)     is False
-    run['attributes']['ProtocolName'] = ''
-    assert bids.exist_run(bidsmap, '', run)     is False
-
-
 def test_insert_bidskeyval():
 
     bidsname = bids.insert_bidskeyval(Path('bids')/'sub-01'/'anat'/'sub-01_T1w', 'run', '1', True)
@@ -475,64 +614,6 @@ def test_insert_bidskeyval():
     assert bidsname == str(Path('anat/sub-01_foo-baz_T1w.nii'))
 
 
-def test_increment_runindex(tmp_path):
-    """Test if run-index is preserved or added to the bidsname, files are renamed and scans-table updated"""
-
-    # Define the test data
-    outfolder = tmp_path/'bids'/'sub-01'/'anat'
-    outfolder.mkdir(parents=True)
-    runless   = 'sub-01_T1w'
-    run1      = 'sub-01_run-1_T1w'
-    run2      = 'sub-01_run-2_T1w'
-    run3      = 'sub-01_run-3_T1w'
-
-    # ------- Tests with no existing data -------
-
-    bidsname = bids.increment_runindex(outfolder, runless, Run({'bids': {'run': '<<>>'}}))
-    assert bidsname == runless
-
-    bidsname = bids.increment_runindex(outfolder, run1 + '.nii', Run({'bids': {'run': '<<1>>'}}))
-    assert bidsname == run1 + '.nii'
-
-    bidsname = bids.increment_runindex(outfolder, run2 + '.nii.gz', Run({'bids': {'run': '<<2>>'}}))
-    assert bidsname == run2 + '.nii.gz'
-
-    # ------- Tests with run-less data -------
-
-    # Create the run-less files
-    for suffix in ('.nii.gz', '.json'):
-        (outfolder/runless).with_suffix(suffix).touch()
-
-    # Test renaming of run-less to run-1 + updating scans_table
-    bidsname = bids.increment_runindex(outfolder, runless, Run({'bids': {'run': '<<>>'}}))
-    assert bidsname == run2
-    for suffix in ('.nii.gz', '.json'):
-        assert (outfolder/runless).with_suffix(suffix).is_file() is False
-        assert (outfolder/run1   ).with_suffix(suffix).is_file() is True
-
-    # We now have run-1 files only
-    bidsname = bids.increment_runindex(outfolder, run1, Run({'bids': {'run': '<<1>>'}}))
-    assert bidsname == run2
-
-    # ------- Tests with run-1 & run-2 data -------
-
-    # Create the run-2 files
-    for suffix in ('.nii.gz', '.json'):
-        (outfolder/run2).with_suffix(suffix).touch()
-
-    bidsname = bids.increment_runindex(outfolder, runless + '.nii.gz', Run({'bids': {'run': '<<>>'}}))
-    assert bidsname == run3 + '.nii.gz'
-
-    bidsname = bids.increment_runindex(outfolder, run1, Run({'bids': {'run': '<<1>>'}}))
-    assert bidsname == run3
-
-    bidsname = bids.increment_runindex(outfolder, run1, Run({'bids': {'run': '<<AttrKey>>'}}))
-    assert bidsname == run1                         # -> Must remain untouched
-
-    bidsname = bids.increment_runindex(outfolder, run1, Run({'bids': {'run': '2'}}))
-    assert bidsname == run1                         # -> Must remain untouched
-
-
 def test_check_runindices(tmp_path):
 
     scans_file = tmp_path/f"sub-01_scans.tsv"
@@ -561,33 +642,6 @@ def test_check_runindices(tmp_path):
     assert bids.check_runindices(tmp_path) is False
 
 
-def test_get_bidsname(raw_dicomdir):
-
-    dicomfile   = raw_dicomdir/'Doe^Archibald'/'01-XR C Spine Comp Min 4 Views'/'001-Cervical LAT'/'6154'
-    run         = {'datasource': bids.DataSource(dicomfile, {'dcm2niix2bids': Plugin({})}, 'DICOM')}
-    run['bids'] = {'acq':'py#dicom', 'foo@':'bar#123', 'run':'<<SeriesNumber>>', 'suffix':'T0w'}
-
-    bidsname = bids.get_bidsname('sub-001', 'ses-01', run, validkeys=False, cleanup=False)  # Test default: runtime=False
-    assert bidsname == 'sub-001_ses-01_acq-py#dicom_run-<<SeriesNumber>>_foo@-bar#123_T0w'
-
-    bidsname = bids.get_bidsname('sub-001', 'ses-01', run, validkeys=False, runtime=False, cleanup=True)
-    assert bidsname == 'sub-001_ses-01_acq-pydicom_run-SeriesNumber_foo@-bar123_T0w'
-
-    bidsname = bids.get_bidsname('sub-001', 'ses-01', run, validkeys=False, runtime=True,  cleanup=False)
-    assert bidsname == 'sub-001_ses-01_acq-py#dicom_run-1_foo@-bar#123_T0w'
-
-    bidsname = bids.get_bidsname('sub-001', 'ses-01', run, validkeys=True,  runtime=True,  cleanup=False)
-    assert bidsname == 'sub-001_ses-01_acq-py#dicom_run-1_T0w'
-
-    run['bids']['run'] = '<<1>>'
-    bidsname = bids.get_bidsname('sub-001', '', run, validkeys=True, runtime=True)          # Test default: cleanup=True
-    assert bidsname == 'sub-001_acq-pydicom_run-1_T0w'
-
-    run['bids']['run'] = '<<>>'
-    bidsname = bids.get_bidsname('sub-001', '', run, validkeys=True, runtime=True)          # Test default: cleanup=True
-    assert bidsname == 'sub-001_acq-pydicom_T0w'
-
-
 def test_get_bidsvalue():
 
     bidsfile = Path('/bids/sub-01/anat/sub-01_acq-foo_run-1_T1w.nii.gz')
@@ -612,7 +666,7 @@ def test_updatemetadata(dcm_file, tmp_path):
     sourcefile.with_suffix('.jsn').touch()
     with sourcefile.with_suffix('.json').open('w') as fid:
         json.dump({'PatientName': 'SourceTest'}, fid)
-    extdatasource = bids.DataSource(sourcefile, {'dcm2niix2bids': Plugin({})}, 'DICOM')
+    extdatasource = DataSource(sourcefile, {'dcm2niix2bids': Plugin({})}, 'DICOM')
 
     # Create the metadata sidecar file
     outfolder = tmp_path/'bids'/'sub-001'/'ses-01'/'anat'
diff --git a/tests/test_bidsmapper.py b/tests/test_bidsmapper.py
index 1feef782..94ce75c8 100644
--- a/tests/test_bidsmapper.py
+++ b/tests/test_bidsmapper.py
@@ -1,6 +1,7 @@
 import pytest
 import re
 from bidscoin import bcoin, bidsmapper, bidsmap_template
+from pathlib import Path
 
 bcoin.setup_logging()
 
@@ -14,11 +15,11 @@ def test_bidsmapper(raw_dicomdir, bids_dicomdir, bidsmap_dicomdir, subprefix, se
     bidsmap     = bidsmapper.bidsmapper(raw_dicomdir, bids_dicomdir, bidsmap_dicomdir, bidsmap_template, [], subprefix, sesprefix, unzip='', store=store, automated=True, force=True)
     assert bidsmap.options['subprefix'] == subprefix
     assert bidsmap.options['sesprefix'] == sesprefix
-    assert bidsmap['DICOM']['subject']                 == f"<<filepath:/{raw_dicomdir.name}/{resubprefix}(.*?)/>>"
-    assert bidsmap['DICOM']['session']                 == f"<<filepath:/{raw_dicomdir.name}/{resubprefix}.*?/{resesprefix}(.*?)/>>"
-    assert len(bidsmap['DICOM']['exclude'])            > 1
-    for run in bidsmap['DICOM']['exclude']:
-        assert 'LOCALIZER' in run['attributes']['SeriesDescription'] or 'DERIVED' in run['attributes']['ImageType']
+    assert bidsmap.dataformat('DICOM').subject                           == f"<<filepath:/{raw_dicomdir.name}/{resubprefix}(.*?)/>>"
+    assert bidsmap.dataformat('DICOM').session                           == f"<<filepath:/{raw_dicomdir.name}/{resubprefix}.*?/{resesprefix}(.*?)/>>"
+    assert len(bidsmap.dataformat('DICOM').datatype('exclude').runitems) > 1
+    for run in bidsmap.dataformat('DICOM').datatype('exclude').runitems:
+        assert 'LOCALIZER' in run.attributes['SeriesDescription'] or 'DERIVED' in run.attributes['ImageType']
     assert bidsmap_dicomdir.is_file()
     assert 'Doe^Archibald' in bidsmap_dicomdir.read_text()                                      # Make sure we have discovered `Archibald` samples (-> provenance)
     assert 'Doe^Peter' in bidsmap_dicomdir.read_text()                                          # Make sure we have discovered `Peter` samples (-> provenance)
diff --git a/tests/test_plugins.py b/tests/test_plugins.py
index a45b91e6..980e72d2 100644
--- a/tests/test_plugins.py
+++ b/tests/test_plugins.py
@@ -9,12 +9,12 @@
 from bidscoin import bcoin, bids, bidsmap_template
 
 bcoin.setup_logging()
-template, _ = bids.load_bidsmap(bidsmap_template, checks=(False, False, False))
+template = bids.BidsMap(bidsmap_template, checks=(False, False, False))
 
 
 # Test all plugins using the template & default options
 @pytest.mark.parametrize('plugin', bcoin.list_plugins()[0])
-@pytest.mark.parametrize('options', [template['Options']['plugins'], {}])
+@pytest.mark.parametrize('options', [template.plugins, {}])
 def test_plugin(plugin, options):
 
     # First test to see if we can import the plugin