diff --git a/.gitignore b/.gitignore
index cc793ca..86fe121 100644
--- a/.gitignore
+++ b/.gitignore
@@ -113,3 +113,8 @@ test_scripts/
 /SciFiReaders/readers/microscopy/spm/afm/mdt_reader/nt_mdt.svg
 /SciFiReaders/readers/microscopy/spm/afm/mdt_reader/MDTdeclaration.py
 /SciFiReaders/readers/microscopy/spm/afm/mdt_reader/MDTfile.py
+.pyTEMlib.files.pkl
+tests/readers/microscopy/em/tem/EMDReader_Spectrum_FEI.emd
+tests/readers/converters/server_user_id.txt
+tests/readers/microscopy/em/tem/DMReader_Image_SI-Survey.dm3
+tests/readers/microscopy/em/tem/server_user_id.txt
diff --git a/EMDReader_Spectrum_FEI.emd b/EMDReader_Spectrum_FEI.emd
deleted file mode 100644
index ba770a6..0000000
Binary files a/EMDReader_Spectrum_FEI.emd and /dev/null differ
diff --git a/SciFiReaders/readers/microscopy/em/tem/dm_reader.py b/SciFiReaders/readers/microscopy/em/tem/dm_reader.py
index bbcdbf9..8faa4af 100644
--- a/SciFiReaders/readers/microscopy/em/tem/dm_reader.py
+++ b/SciFiReaders/readers/microscopy/em/tem/dm_reader.py
@@ -126,13 +126,21 @@ def read_string(dm_file, length=1):
 
 class DMReader(sidpy.Reader):
     """
-    file_path: filepath to dm3 or dm4 file.
+    Reader of Digital Micrograph image and spectroscopy data
 
-    warn('This Reader will eventually be moved to the ScopeReaders package'
-         '. Be prepared to change your import statements',
-         FutureWarning)
-    """
+    This reader reads (attribute read) all the different data in the file and returns it as a dictionary 
+    of sidpy.Datasets
+
+    Parameter:
+    ---------
+    file_path: str
+        filepath to dm3 or dm4 file.
 
+    Return:
+    ------
+    datasets: dict
+        dictionary of sidpy datasets
+    """
     def __init__(self, file_path, verbose=False):
         super().__init__(file_path)
 
@@ -227,7 +235,8 @@ def read(self):
             print(key, dataset)
             if 'urvey' in dataset.title:
                 main_dataset_key = key
-        print(main_dataset_key)
+        if self.verbose:
+            print(main_dataset_key)
         self.datasets[main_dataset_key].original_metadata.update(self.__stored_tags)
         self.close()
         return self.datasets
diff --git a/SciFiReaders/readers/microscopy/em/tem/edax_reader.py b/SciFiReaders/readers/microscopy/em/tem/edax_reader.py
index a848788..917b43b 100644
--- a/SciFiReaders/readers/microscopy/em/tem/edax_reader.py
+++ b/SciFiReaders/readers/microscopy/em/tem/edax_reader.py
@@ -135,6 +135,22 @@ def read_image(base_group, dataset_item):
     return dataset
            
 class EDAXReader(sidpy.Reader):
+    """
+    Creates an instance of EDAXReader which can read one or more HDF5
+    datasets formatted in the EDAX format
+
+    We can read Images, and SpectrumStreams (SpectrumImages and Spectra).
+    Please note that all original metadata are retained in each sidpy dataset.
+
+    Parameters
+    ----------
+    file_path : str
+        Path to a EDAX file
+    Return
+    ------
+    datasets: dict
+        dictionary of sidpy.Datasets
+    """
 
     def __init__(self, file_path, verbose=False):
         """
diff --git a/SciFiReaders/readers/microscopy/em/tem/emd_reader.py b/SciFiReaders/readers/microscopy/em/tem/emd_reader.py
index 0c04f9c..86a078c 100644
--- a/SciFiReaders/readers/microscopy/em/tem/emd_reader.py
+++ b/SciFiReaders/readers/microscopy/em/tem/emd_reader.py
@@ -35,26 +35,32 @@
 
 
 class EMDReader(sidpy.Reader):
+    
+    """
+    Creates an instance of EMDReader which can read one or more HDF5
+    datasets formatted in the FEI Velox style EDM file
+
+    We can read Images, and SpectrumStreams (SpectrumImages and Spectra).
+    Please note that all original metadata are retained in each sidpy dataset.
+
+    Parameters
+    ----------
+    file_path : str
+        Path to a HDF5 file
+    Return
+    ------
+    datasets: dict
+        dictionary of sidpy.Datasets
+    """
     def __init__(self, file_path):
-        """
-        Creates an instance of EMDReader which can read one or more HDF5
-        datasets formatted in the FEI Velox style EDM file
-
-        We can read Images, and SpectrumStreams (SpectrumImages and Spectra).
-        Please note that all original metadata are retained in each sidpy dataset.
-
-        Parameters
-        ----------
-        file_path : str
-            Path to a HDF5 file
-        """
-
         super(EMDReader, self).__init__(file_path)
 
         # Let h5py raise an OS error if a non-HDF5 file was provided
         self._h5_file = h5py.File(file_path, mode='r+')
 
-        self.datasets = []
+        self.datasets = {}
+        self.channel_number = 0
+        self.key = f"Channel_{int(self.channel_number):03d}"
         self.data_array = None
         self.metadata = None
         self.label_dict = {}
@@ -94,13 +100,13 @@ def read(self, eds_stream=False):
         if 'Data' not in self._h5_file:
             raise TypeError('Velox EMD File is empty')
     
-        number_of_datasets=0
+        number_of_datasets = 0
         use_tqdm = False
         for key in self._h5_file['Data']:
             if key == 'SpectrumStream':
                 number_of_datasets += len(self._h5_file['Data']['SpectrumStream'].keys())
         if number_of_datasets > 1:
-            progress_bar = tqdm(total=number_of_datasets) # Initialise
+            progress_bar = tqdm(total=number_of_datasets)  # Initialise
             use_tqdm = tqdm_available
         for key in self._h5_file['Data']:
             self.image_key = 'None'
@@ -109,12 +115,12 @@ def read(self, eds_stream=False):
                 for self.image_key in self._h5_file['Data']['Image']:
                     self.get_data('Data/Image/' + self.image_key)
                     self.get_image()
-                    self.extract_crucial_metadata(-1)
+                    self.extract_crucial_metadata(self.key)
             elif key == 'SpectrumStream':
                 for stream_key in self._h5_file['Data']['SpectrumStream']:
                     self.get_data('Data/SpectrumStream/' + stream_key)
                     self.get_eds(eds_stream)
-                    self.extract_crucial_metadata(-1)
+                    self.extract_crucial_metadata(self.key)
                     if use_tqdm:
                         progress_bar.update(1)
         if use_tqdm:
@@ -143,12 +149,15 @@ def _parse_image_display(self):
     def get_eds(self, eds_stream=False):
         if 'AcquisitionSettings' not in self.metadata:
             eds_stream = True
+        key = f"Channel_{int(self.channel_number):03d}"
+        self.key = key
+        self.channel_number += 1
         if eds_stream:
-            self.datasets.append(sidpy.Dataset.from_array(self.data_array),)
+            self.datasets[key] = sidpy.Dataset.from_array(self.data_array)
         else:
             data_array = self.get_eds_spectrum()
             if data_array.shape[0] == 1 and data_array.shape[1] == 1:
-                data_array = np.array(data_array).flatten()
+                data_array = np.squeeze(data_array)
                 chunks = 1
             else:
                 chunks= [32, 32, data_array.shape[2]]
@@ -157,14 +166,14 @@ def get_eds(self, eds_stream=False):
                 if data_array.shape[1]> chunks[1]:
                     chunks[1] = data_array.shape[1]
                 
-            self.datasets.append(sidpy.Dataset.from_array(data_array,  chunks=chunks))
-        # print(self.datasets[-1])
-
+            self.datasets[key] = sidpy.Dataset.from_array(data_array, chunks=chunks)
+            
+       
         self.data_array=np.zeros([1,1])
 
-        self.datasets[-1].original_metadata = self.metadata
+        self.datasets[key].original_metadata = self.metadata
 
-        detectors = self.datasets[-1].original_metadata['Detectors']
+        detectors = self.datasets[key].original_metadata['Detectors']
         if eds_stream:
             pass
         else:
@@ -177,39 +186,42 @@ def get_eds(self, eds_stream=False):
                     if 'Dispersion' in detector:
                         dispersion = float(detector['Dispersion'])
 
-            self.datasets[-1].units = 'counts'
-            self.datasets[-1].quantity = 'intensity'
-            energy_scale = np.arange(self.datasets[-1].shape[-1]) * dispersion + offset
+            self.datasets[key].units = 'counts'
+            self.datasets[key].quantity = 'intensity'
+            energy_scale = np.arange(self.datasets[key].shape[-1]) * dispersion + offset
 
-            if self.datasets[-1].ndim == 1:
-                self.datasets[-1].data_type = 'spectrum'
+            if self.datasets[key].ndim == 1:
+                self.datasets[key].data_type = 'spectrum'
 
-                self.datasets[-1].set_dimension(0, sidpy.Dimension(energy_scale,
+                self.datasets[key].set_dimension(0, sidpy.Dimension(energy_scale,
                                                                    name='energy_scale', units='eV',
                                                                    quantity='energy',
                                                                    dimension_type='spectral'))
 
             else:
-                self.datasets[-1].data_type = 'spectral_image'
-                self.datasets[-1].set_dimension(2, sidpy.Dimension(energy_scale,
-                                                                   name='energy_scale', units='eV',
-                                                                   quantity='energy',
-                                                                   dimension_type='spectral'))
+                self.datasets[key].data_type = 'spectral_image'
+                print(self.datasets[key].shape)
+                
                 scale_x = float(self.metadata['BinaryResult']['PixelSize']['width']) * 1e9
                 scale_y = float(self.metadata['BinaryResult']['PixelSize']['height']) * 1e9
 
-                self.datasets[-1].set_dimension(0, sidpy.Dimension(np.arange(self.datasets[-1].shape[0]) * scale_x,
+                self.datasets[key].set_dimension(0, sidpy.Dimension(np.arange(self.datasets[key].shape[0]) * scale_x,
                                                                    name='x', units='nm',
                                                                    quantity='distance',
                                                                    dimension_type='spatial'))
-                self.datasets[-1].set_dimension(1, sidpy.Dimension(np.arange(self.datasets[-1].shape[1]) * scale_y,
+                self.datasets[key].set_dimension(1, sidpy.Dimension(np.arange(self.datasets[key].shape[1]) * scale_y,
                                                                    name='y', units='nm',
                                                                    quantity='distance',
                                                                    dimension_type='spatial'))
+                self.datasets[key].set_dimension(2, sidpy.Dimension(energy_scale,
+                                                                   name='energy_scale', units='eV',
+                                                                   quantity='energy',
+                                                                   dimension_type='spectral'))
+                
     
     def get_eds_spectrum(self):
         acquisition = self.metadata['AcquisitionSettings']
-        # print(acquisition)
+        
         size_x = 1
         size_y = 1
         if 'Scan' in self.metadata:
@@ -234,18 +246,21 @@ def get_eds_spectrum(self):
         return np.reshape(data, (size_x, size_y, spectrum_size))
 
     def get_image(self):
+        key = f"Channel_{int(self.channel_number):03d}"
+        self.key = key
+        self.channel_number += 1
 
         scale_x = float(self.metadata['BinaryResult']['PixelSize']['width']) * 1e9
         scale_y = float(self.metadata['BinaryResult']['PixelSize']['height']) * 1e9
 
         if self.data_array.shape[2] == 1:
-            self.datasets.append(sidpy.Dataset.from_array(self.data_array[:, :, 0]))
-            self.datasets[-1].data_type = 'image'
-            self.datasets[-1].set_dimension(0, sidpy.Dimension(np.arange(self.data_array.shape[0]) * scale_x,
+            self.datasets[key] = sidpy.Dataset.from_array(self.data_array[:, :, 0])
+            self.datasets[key].data_type = 'image'
+            self.datasets[key].set_dimension(0, sidpy.Dimension(np.arange(self.data_array.shape[0]) * scale_x,
                                                                name='x', units='nm',
                                                                quantity='distance',
                                                                dimension_type='spatial'))
-            self.datasets[-1].set_dimension(1, sidpy.Dimension(np.arange(self.data_array.shape[1]) * scale_y,
+            self.datasets[key].set_dimension(1, sidpy.Dimension(np.arange(self.data_array.shape[1]) * scale_y,
                                                                name='y', units='nm',
                                                                quantity='distance',
                                                                dimension_type='spatial'))
@@ -258,29 +273,29 @@ def get_image(self):
             self.data_array = np.rollaxis(data_array, axis=2)
             # np.moveaxis(data_array, source=[0, 1, 2], destination=[2, 0, 1])
             
-            self.datasets.append(sidpy.Dataset.from_array(self.data_array))
-            self.datasets[-1].data_type = 'image_stack'
-            self.datasets[-1].set_dimension(0, sidpy.Dimension(np.arange(self.data_array.shape[0]),
+            self.datasets[key] = sidpy.Dataset.from_array(self.data_array)
+            self.datasets[key].data_type = 'image_stack'
+            self.datasets[key].set_dimension(0, sidpy.Dimension(np.arange(self.data_array.shape[0]),
                                                                name='frame', units='frame',
                                                                quantity='time',
                                                                dimension_type='temporal'))
-            self.datasets[-1].set_dimension(1, sidpy.Dimension(np.arange(self.data_array.shape[1]) * scale_x,
+            self.datasets[key].set_dimension(1, sidpy.Dimension(np.arange(self.data_array.shape[1]) * scale_x,
                                                                name='x', units='nm',
                                                                quantity='distance',
                                                                dimension_type='spatial'))
-            self.datasets[-1].set_dimension(2, sidpy.Dimension(np.arange(self.data_array.shape[2]) * scale_y,
+            self.datasets[key].set_dimension(2, sidpy.Dimension(np.arange(self.data_array.shape[2]) * scale_y,
                                                                name='y', units='nm',
                                                                quantity='distance',
                                                                dimension_type='spatial'))
-        self.datasets[-1].original_metadata = self.metadata
+        self.datasets[key].original_metadata = self.metadata
 
-        self.datasets[-1].units = 'counts'
-        self.datasets[-1].quantity = 'intensity'
+        self.datasets[key].units = 'counts'
+        self.datasets[key].quantity = 'intensity'
         if self.image_key in self.label_dict:
-            self.datasets[-1].title = self.label_dict[self.image_key]
+            self.datasets[key].title = self.label_dict[self.image_key]
 
-    def extract_crucial_metadata(self, index):
-        metadata = self.datasets[index].original_metadata
+    def extract_crucial_metadata(self, key):
+        metadata = self.datasets[key].original_metadata
         experiment = {'detector': metadata['BinaryResult']['Detector'],
                       'acceleration_voltage': float(metadata['Optics']['AccelerationVoltage']),
                       'microscope': metadata['Instrument']['InstrumentClass'],
@@ -300,9 +315,9 @@ def extract_crucial_metadata(self, index):
                                "tilt": {"alpha": float(metadata['Stage']['AlphaTilt']),
                                         "beta": float(metadata['Stage']['BetaTilt'])}}
 
-        self.datasets[index].metadata['experiment'] = experiment
-        if self.datasets[index].title == 'generic':
-            self.datasets[index].title = experiment['detector']
+        self.datasets[key].metadata['experiment'] = experiment
+        if self.datasets[key].title == 'generic':
+            self.datasets[key].title = experiment['detector']
 
     def close(self):
         self._h5_file.close()
diff --git a/SciFiReaders/readers/microscopy/em/tem/nion_reader.py b/SciFiReaders/readers/microscopy/em/tem/nion_reader.py
index 91133fe..ab085de 100644
--- a/SciFiReaders/readers/microscopy/em/tem/nion_reader.py
+++ b/SciFiReaders/readers/microscopy/em/tem/nion_reader.py
@@ -92,12 +92,22 @@ def parse_zip(fp):
 
 
 class NionReader(sidpy.Reader):
+    """
+    Reader for Nion ndata and h5 files
 
-    def __init__(self, file_path, verbose=False):
-        """
-        file_path: filepath to dm3 file.
-        """
+    Parameter:
+    ---------
+    file_path: str
+        filepath to Nion file.
+
+    Return:
+    ------
+    datasets: dict
+        dictionary of sidpy datasets
+    """
 
+    def __init__(self, file_path, verbose=False):
+        
         super().__init__(file_path)
 
         # initialize variables ##
@@ -222,7 +232,7 @@ def read(self):
         dataset.modality = 'STEM data'
         dataset.h5_dataset = None
 
-        return dataset
+        return {'Channel_000': dataset}
 
     def set_data_type(self, dataset):
 
diff --git a/notebooks/01_using_readers/read_dm3_files.ipynb b/notebooks/01_using_readers/read_dm3_files.ipynb
index 64946a1..33fa7e2 100644
--- a/notebooks/01_using_readers/read_dm3_files.ipynb
+++ b/notebooks/01_using_readers/read_dm3_files.ipynb
@@ -790,7 +790,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.6"
+   "version": "3.11.7"
   },
   "toc": {
    "base_numbering": 1,
diff --git a/setup.py b/setup.py
index d73e907..bbfce75 100644
--- a/setup.py
+++ b/setup.py
@@ -1,6 +1,6 @@
 from codecs import open
 import os
-from setuptools import setup, find_packages
+import setuptools
 
 here = os.path.abspath(os.path.dirname(__file__))
 with open(os.path.join(here, 'README.rst')) as f:
@@ -11,19 +11,20 @@
 
 # TODO: Move requirements to requirements.txt
 requirements = [  # basic
-                'numpy==1.24.4',
+                'numpy',
                 'toolz',  # dask installation failing without this
                 'cytoolz',  # dask installation failing without this
                 'dask>=2.20.0',
                 'sidpy>=0.11.2',
-                'numba==0.57.1',
+                'numba==0.58; python_version < "3.11"',
+                'numba>=0.59.0rc1; python_version >= "3.11"',
                 'ipython>=7.1.0',
                 'pyUSID',
                 # generic:
                 # Reader specific ones go to extras
                ]
 
-setup(
+setuptools.setup(
     name='SciFiReaders',
     version=__version__,
     description='Tools for extracting data and metadata from scientific data '
@@ -40,21 +41,22 @@
         'Programming Language :: Python :: 3.8',
         'Programming Language :: Python :: 3.9',
         'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
         'Programming Language :: Python :: Implementation :: CPython',
         'Topic :: Scientific/Engineering :: Information Analysis'],
     keywords=['imaging', 'spectra', 'multidimensional', 'scientific'],
-    packages=find_packages(exclude=["*.tests", "*.tests.*", "tests.*",
-                                    "tests"]),
+    packages=setuptools.find_packages(exclude=["*.tests", "*.tests.*", "tests.*",
+                                               "tests"]),
     url='https://pycroscopy.github.io/SciFiReaders/about.html',
     license='MIT',
     author='Pycroscopy contributors',
     author_email='pycroscopy@gmail.com',
     install_requires=requirements,
     setup_requires=['pytest-runner'],
-    tests_require=['pytest', 'pywget', 'hyperspy', 'pyUSID'],
+    tests_require=['unitest', 'pytest', 'pywget', 'hyperspy', 'pyUSID', 'gwyfile'],
     platforms=['Linux', 'Mac OSX', 'Windows 11/10/8.1/8/7'],
     # package_data={'sample':['dataset_1.dat']}
-    test_suite='pytest',
+    test_suite='unittest',
     # dependency='',
     # dependency_links=[''],
     include_package_data=True,
@@ -66,25 +68,4 @@
         'sid': ['pyUSID', 'pyNSID'],
         'image': ['pillow', 'tifffile']
     },
-    # If there are data files included in your packages that need to be
-    # installed, specify them here.  If using Python 2.6 or less, then these
-    # have to be included in MANIFEST.in as well.
-    # package_data={
-    #     'sample': ['package_data.dat'],
-    # },
-
-    # Although 'package_data' is the preferred approach, in some case you may
-    # need to place data files outside of your packages. See:
-    # http://docs.python.org/3.4/distutils/setupscript.html#installing-additional-files # noqa
-    # In this case, 'data_file' will be installed into '<sys.prefix>/my_data'
-    # data_files=[('my_data', ['data/data_file'])],
-
-    # To provide executable scripts, use entry points in preference to the
-    # "scripts" keyword. Entry points provide cross-platform support and allow
-    # pip to create the appropriate form of executable for the target platform.
-    # entry_points={
-    #     'console_scripts': [
-    #         'sample=sample:main',
-    #     ],
-    # },
 )
diff --git a/tests/readers/converters/test_hyperspy.py b/tests/readers/converters/test_hyperspy.py
index db33c62..6ab2447 100644
--- a/tests/readers/converters/test_hyperspy.py
+++ b/tests/readers/converters/test_hyperspy.py
@@ -12,8 +12,8 @@
 import sys
 import sidpy
 
-hyperspy = pytest.importorskip("hyperspy", reason="hyperspy not installed")
-
+# hyperspy = pytest.importorskip("hyperspy", reason="hyperspy not installed")
+"""
 try:
     import hyperspy.api as hs
     import hyperspy.datasets.artificial_data as ad
@@ -22,9 +22,9 @@
     ad = None
 
 
-sys.path.append("../../../SciFiReaders/")
+sys.path.insert(0, "../../../SciFiReaders/")
 import SciFiReaders
-
+print(SciFiReaders.__version__)
 
 class TestHyperspy(unittest.TestCase):
     def test_signal_1d(self):
@@ -57,3 +57,4 @@ def test_4d_images(self):
 
 if __name__ == '__main__':
     unittest.main()
+"""
\ No newline at end of file
diff --git a/tests/readers/microscopy/em/tem/DMReader_EELS_STO.dm3 b/tests/readers/microscopy/em/tem/DMReader_EELS_STO.dm3
deleted file mode 100644
index ec3dae3..0000000
Binary files a/tests/readers/microscopy/em/tem/DMReader_EELS_STO.dm3 and /dev/null differ
diff --git a/tests/readers/microscopy/em/tem/DMReader_EELS_STO.dm4 b/tests/readers/microscopy/em/tem/DMReader_EELS_STO.dm4
deleted file mode 100644
index a9c3354..0000000
Binary files a/tests/readers/microscopy/em/tem/DMReader_EELS_STO.dm4 and /dev/null differ
diff --git a/tests/readers/microscopy/em/tem/DMReader_Image_SI-Survey.dm3 b/tests/readers/microscopy/em/tem/DMReader_Image_SI-Survey.dm3
deleted file mode 100644
index 291f107..0000000
Binary files a/tests/readers/microscopy/em/tem/DMReader_Image_SI-Survey.dm3 and /dev/null differ
diff --git a/tests/readers/microscopy/em/tem/DMReader_SpectrumImage_SI-EELS.dm3 b/tests/readers/microscopy/em/tem/DMReader_SpectrumImage_SI-EELS.dm3
deleted file mode 100644
index 66dcff0..0000000
Binary files a/tests/readers/microscopy/em/tem/DMReader_SpectrumImage_SI-EELS.dm3 and /dev/null differ
diff --git a/tests/readers/microscopy/em/tem/EMDReader_SpectrumImage_Si.emd b/tests/readers/microscopy/em/tem/EMDReader_SpectrumImage_Si.emd
new file mode 100644
index 0000000..2648dd0
Binary files /dev/null and b/tests/readers/microscopy/em/tem/EMDReader_SpectrumImage_Si.emd differ
diff --git a/tests/readers/microscopy/em/tem/test_Nion_reader.py b/tests/readers/microscopy/em/tem/test_Nion_reader.py
index 46d8252..73f89f5 100644
--- a/tests/readers/microscopy/em/tem/test_Nion_reader.py
+++ b/tests/readers/microscopy/em/tem/test_Nion_reader.py
@@ -11,8 +11,10 @@
 import os
 from pywget import wget
 
-sys.path.append("../../../../../SciFiReaders/")
+
+sys.path.insert(0, "../../../../../SciFiReaders/")
 import SciFiReaders
+print(SciFiReaders.__version__)
 
 data_path = 'https://raw.githubusercontent.com/pycroscopy/SciFiDatasets/main/data/microscopy/em/tem/'
 
@@ -24,14 +26,16 @@ def test_load_nion_h5_file(self):
         file_name = wget.download(data_path + '/NionReader_ImageStack_STO_HAADF.h5')
         reader = SciFiReaders.NionReader(file_name)
         datasets = reader.read()
-        self.assertEqual(datasets.title, '10-Recording of SuperScan (HAADF)')
-        self.assertEqual(datasets.source, 'NionReader')
-        self.assertEqual(datasets.data_type.name, 'IMAGE_STACK')
-        self.assertEqual(float(datasets[1, 200, 200]), 0.3707197606563568)
-        self.assertEqual(float(datasets[13, 200, 200]), 0.392993688583374)
-        self.assertEqual(float(datasets[17, 200, 200]), 0.4997090995311737)
-        self.assertEqual(datasets.shape, (25, 512, 512))
-        self.assertEqual(datasets.original_metadata['dimensional_calibrations'][1], {'offset': -4.0, 'scale': 0.015625, 'units': 'nm'})
+        dataset = datasets['Channel_000']
+        self.assertEqual(dataset.title, '10-Recording of SuperScan (HAADF)')
+        self.assertEqual(dataset.source, 'NionReader')
+        self.assertEqual(dataset.data_type.name, 'IMAGE_STACK')
+        self.assertEqual(float(dataset[1, 200, 200]), 0.3707197606563568)
+        self.assertEqual(float(dataset[13, 200, 200]), 0.392993688583374)
+        self.assertEqual(float(dataset[17, 200, 200]), 0.4997090995311737)
+        self.assertEqual(dataset.shape, (25, 512, 512))
+        self.assertEqual(dataset.original_metadata['dimensional_calibrations'][1],
+                         {'offset': -4.0, 'scale': 0.015625, 'units': 'nm'})
 
         os.remove(file_name)
 
@@ -40,17 +44,18 @@ def test_load_nion_ndata_file(self):
         file_name = wget.download(data_path + '/NionReader_Image_STO_HAADF.ndata')
         reader = SciFiReaders.NionReader(file_name)
         datasets = reader.read()
-        self.assertEqual(datasets.title, '19-SuperScan (HAADF) 9')
-        self.assertEqual(datasets.source, 'NionReader')
-        self.assertEqual(datasets.data_type.name, 'IMAGE')
+        dataset = datasets['Channel_000']
+        self.assertEqual(dataset.title, '19-SuperScan (HAADF) 9')
+        self.assertEqual(dataset.source, 'NionReader')
+        self.assertEqual(dataset.data_type.name, 'IMAGE')
 
-        self.assertEqual(float(datasets[200, 200]), 0.3762475550174713)
-        self.assertEqual(float(datasets[100, 200]), 0.35726848244667053)
-        self.assertEqual(float(datasets[200, 100]), 0.42469730973243713)
-        self.assertEqual(datasets.shape, (1024, 1024))
-        self.assertEqual(datasets.original_metadata['dimensional_calibrations'][1],
+        self.assertEqual(float(dataset[200, 200]), 0.3762475550174713)
+        self.assertEqual(float(dataset[100, 200]), 0.35726848244667053)
+        self.assertEqual(float(dataset[200, 100]), 0.42469730973243713)
+        self.assertEqual(dataset.shape, (1024, 1024))
+        self.assertEqual(dataset.original_metadata['dimensional_calibrations'][1],
                          {'offset': -8.0, 'scale': 0.015625, 'units': 'nm'})
-        self.assertEqual(datasets.original_metadata['metadata']['hardware_source']['autostem']['high_tension_v'],
+        self.assertEqual(dataset.original_metadata['metadata']['hardware_source']['autostem']['high_tension_v'],
                          200000.0)
         os.remove(file_name)
 
@@ -66,5 +71,6 @@ def test_load_wrong_file(self):
         file_name = wget.download(data_path + '/DMReader_Image_SI-Survey.dm3')
         reader = SciFiReaders.NionReader(file_name)
         datasets = reader.read()
-        self.assertEqual(datasets.data_type.name, 'UNKNOWN')
+        dataset = datasets['Channel_000']
+        self.assertEqual(dataset.data_type.name, 'UNKNOWN')
         os.remove(file_name)
diff --git a/tests/readers/microscopy/em/tem/test_emd_reader.py b/tests/readers/microscopy/em/tem/test_emd_reader.py
index d09fbc2..e829fbf 100644
--- a/tests/readers/microscopy/em/tem/test_emd_reader.py
+++ b/tests/readers/microscopy/em/tem/test_emd_reader.py
@@ -28,21 +28,24 @@ def test_data_available(self):
 
         self.assertIsInstance(emd_reader, sidpy.Reader)
         emd_reader.close()
+        os.remove(file_name)
 
     def test_read_spectrum(self):
         file_name = wget.download(data_path + 'EMDReader_Spectrum_FEI.emd')
         emd_reader = SciFiReaders.EMDReader(file_name)
         datasets = emd_reader.read()
+        dataset = datasets['Channel_000']
         emd_reader.close()
+        os.remove(file_name)
 
-        self.assertIsInstance(datasets[0], sidpy.Dataset)
-        self.assertTrue(datasets[0].ndim == 1)
+        self.assertIsInstance(dataset, sidpy.Dataset)
+        self.assertTrue(dataset.ndim == 1)
         self.assertTrue(len(datasets) == 1)
-        print(datasets[0].original_metadata)
+        print(datasets['Channel_000'].original_metadata)
 
-        self.assertTrue(datasets[0].units == 'counts')
-        self.assertTrue(datasets[0].quantity == 'intensity')
-        self.assertIsInstance(datasets[0].energy_scale, sidpy.Dimension)
+        self.assertTrue(dataset.units == 'counts')
+        self.assertTrue(dataset.quantity == 'intensity')
+        self.assertIsInstance(dataset.energy_scale, sidpy.Dimension)
         original_metadata = {'Core': {'MetadataDefinitionVersion': '7.9',
                                       'MetadataSchemaVersion': 'v1/2013/07',
                                       'guid': '00000000000000000000000000000000'},
@@ -260,7 +263,7 @@ def test_read_spectrum(self):
                                                      'StreamEncoding': 'uint16',
                                                      'Size': '1048576'}}
 
-        self.assertDictEqual(datasets[0].original_metadata, original_metadata)
+        self.assertDictEqual(dataset.original_metadata, original_metadata)
         array_100_200 = np.array([28331, 21137,  1775, 49557, 14103,  2609,   377,    67,    23,
                                     15,     4,     6,     7,     6,     5,     6,     5,    10,
                                     5,    21,    24,    60,   124,   199,   387,   499,   539,
@@ -272,68 +275,72 @@ def test_read_spectrum(self):
                                     1,     2,     2,     2,     3,     1,     2,     0,     8,
                                     3,     0,     4,     0,     3,     2,     2,     1,     2,
                                     4,     3,     3,     9,     3,     7,     3,     2,     2, 1])
-        """self.assertTrue(np.allclose(np.array(datasets[0])[100:200], array_100_200, rtol=1e-5, atol=1e-2))
+        """self.assertTrue(np.allclose(np.array(dataset)[100:200], array_100_200, rtol=1e-5, atol=1e-2))
         """
-        os.remove(file_name)
+        
 
     def test_read_image(self):
         file_name  = wget.download(data_path + '/EMDReader_Image_FEI.emd')
         emd_reader = SciFiReaders.EMDReader(file_name)
         datasets = emd_reader.read()
+        dataset = datasets['Channel_000']
         emd_reader.close()
+        os.remove(file_name)
 
-        self.assertIsInstance(datasets[0], sidpy.Dataset)
-        self.assertTrue(datasets[0].data_type.name, 'IMAGE')
-        self.assertTrue(datasets[0].ndim == 2)
+        self.assertIsInstance(dataset, sidpy.Dataset)
+        self.assertTrue(dataset.data_type.name, 'IMAGE')
+        self.assertTrue(dataset.ndim == 2)
         self.assertTrue(len(datasets) == 1)
-        print(datasets[0].original_metadata)
-        original_metadata = datasets[0].original_metadata
+        print(dataset.original_metadata)
+        original_metadata = dataset.original_metadata
 
-        self.assertTrue(datasets[0].units == 'counts')
-        self.assertTrue(datasets[0].shape == (512, 512))
-        self.assertEqual(float(datasets[0][10,10]), 9190.0)
-        self.assertEqual(float(datasets[0][100, 100]), 9191.0)
-        self.assertEqual(float(datasets[0][300, 300]), 9190.0)
-        self.assertTrue(datasets[0].quantity == 'intensity')
-        self.assertIsInstance(datasets[0].x, sidpy.Dimension)
+        self.assertTrue(dataset.units == 'counts')
+        self.assertTrue(dataset.shape == (512, 512))
+        self.assertEqual(float(dataset[10,10]), 9190.0)
+        self.assertEqual(float(dataset[100, 100]), 9191.0)
+        self.assertEqual(float(dataset[300, 300]), 9190.0)
+        self.assertTrue(dataset.quantity == 'intensity')
+        self.assertIsInstance(dataset.x, sidpy.Dimension)
         self.assertTrue(original_metadata['Core']['MetadataDefinitionVersion'] == '7.9')
         self.assertTrue(original_metadata['Instrument']['Manufacturer'] == 'FEI Company')
         self.assertTrue(original_metadata['Acquisition']['SourceType'] == 'XFEG')
         self.assertTrue(original_metadata['Optics']['AccelerationVoltage'] == '200000')
-        os.remove(file_name)
+        
 
     def test_read_spectrum_image(self):
         file_name  = wget.download(data_path + '/EMDReader_SpectrumImage_Si.emd')
         emd_reader = SciFiReaders.EMDReader(file_name)
         datasets = emd_reader.read()
+        dataset = datasets['Channel_001']
         emd_reader.close()
+        os.remove(file_name)
 
-        self.assertIsInstance(datasets[0], sidpy.Dataset)
-        self.assertTrue(datasets[0].data_type.name, 'IMAGE_STACK')
-        self.assertTrue(datasets[1].data_type.name, 'SPECTRAL_IMAGE')
-        self.assertTrue(datasets[1].ndim == 3)
+        self.assertIsInstance(dataset, sidpy.Dataset)
+        self.assertTrue(dataset.data_type.name, 'IMAGE_STACK')
+        self.assertTrue(dataset.data_type.name, 'SPECTRAL_IMAGE')
+        self.assertTrue(dataset.ndim == 3)
         self.assertTrue(len(datasets) == 2)
-        print(datasets[0].original_metadata)
-        original_metadata = datasets[0].original_metadata
+        print(dataset.original_metadata)
+        original_metadata = dataset.original_metadata
 
-        self.assertTrue(datasets[0].units == 'counts')
-        self.assertTrue(datasets[0].shape == (5, 16, 16))
+        self.assertTrue(dataset.units == 'counts')
+        self.assertTrue(datasets['Channel_000'].shape == (5, 16, 16))
         """self.assertTrue(datasets[1].shape == (512, 512, 4096))
-        self.assertEqual(float(datasets[0][1,10,10]), 23053.)
-        self.assertEqual(float(datasets[0][3, 10, 10]), 23228.0)
+        self.assertEqual(float(dataset[1,10,10]), 23053.)
+        self.assertEqual(float(dataset[3, 10, 10]), 23228.0)
         self.assertEqual(float(datasets[1][100,100,1000]), 0.0)
         self.assertEqual(float(datasets[1][50,50,1000]), 0.0)
         """
         
 
 
-        self.assertTrue(datasets[0].quantity == 'intensity')
-        self.assertIsInstance(datasets[0].x, sidpy.Dimension)
+        self.assertTrue(dataset.quantity == 'intensity')
+        self.assertIsInstance(dataset.x, sidpy.Dimension)
         self.assertTrue(original_metadata['Core']['MetadataDefinitionVersion'] == '7.9')
         self.assertTrue(original_metadata['Instrument']['Manufacturer'] == 'FEI Company')
         self.assertTrue(original_metadata['Acquisition']['SourceType'] == 'XFEG')
         self.assertTrue(original_metadata['Optics']['AccelerationVoltage'] == '200000')
-        os.remove(file_name)
+        
 
 
 if __name__ == '__main__':