diff --git a/rsciio/bruker/_api.py b/rsciio/bruker/_api.py
index 852daea8..e96455a7 100644
--- a/rsciio/bruker/_api.py
+++ b/rsciio/bruker/_api.py
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright 2016 Petras Jokubauskas
-# Copyright 2016 The HyperSpy developers
+# Copyright 2023 Petras Jokubauskas
+# Copyright 2023 The HyperSpy developers
 #
 # This library is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -18,10 +18,10 @@
 # If not, see <https://www.gnu.org/licenses/#GPL>.
 #
 # This python library subset provides read functionality of
-#  Bruker bcf files.
+#  Bruker bcf and spx files.
 # The basic reading capabilities of proprietary AidAim Software(tm)
-#  SFS (Single File System) (used in bcf technology) is present in
-#  the same library.
+#  SFS (Single File System) used in bcf technology is exposed for
+#  eventual reuse for other Bruker files.
 
 
 # Plugin characteristics
@@ -30,7 +30,7 @@
 from math import ceil
 import logging
 from zlib import decompress as unzip_block
-from struct import unpack as strct_unp
+from struct import unpack
 from datetime import datetime
 from ast import literal_eval
 import codecs
@@ -46,6 +46,12 @@
 
 from rsciio.docstrings import FILENAME_DOC, LAZY_DOC, RETURNS_DOC
 
+__all__ = [
+    "BCFReader",
+    "SFSReader",
+    "spectra_from_xml",
+]
+
 _logger = logging.getLogger(__name__)
 
 warn_once = True
@@ -71,22 +77,23 @@ class Container(object):
 
 
 class SFSTreeItem(object):
-    """Class to manage one internal sfs file.
-
-    Reading, reading in chunks, reading and extracting, reading without
-    extracting even if compression is pressent.
+    """Class to manage one internal SFS file.
+    This class provides means to Read, read in blocks, read and extract
+    compressed blocks and read without extracting even if compression
+    is present (for debuging purpoises).
 
     Attributes:
     item_raw_string -- the bytes from sfs file table describing the file
-    parent -- the item higher hierarchicaly in the sfs file tree
+    parent -- the index of parent item in SFS file table.
+    The index of root is -1.
 
     Methods:
     read_piece, setup_compression_metadata, get_iter_and_properties,
     get_as_BytesIO_string
     """
 
-    def __init__(self, item_raw_string, parent):
-        self.sfs = parent
+    def __init__(self, item_raw_string, sfs):
+        self.sfs = sfs
         (
             self._pointer_to_pointer_table,
             self.size,
@@ -100,7 +107,7 @@ def __init__(self, item_raw_string, parent):
             _,
             name,
             _,
-        ) = strct_unp("<iQQQQIi176s?3s256s32s", item_raw_string)
+        ) = unpack("<iQQQQIi176s?3s256s32s", item_raw_string)
         self.create_time = msfiletime_to_unix(create_time)
         self.mod_time = msfiletime_to_unix(mod_time)
         self.some_time = msfiletime_to_unix(some_time)
@@ -108,6 +115,11 @@ def __init__(self, item_raw_string, parent):
         self.size_in_chunks = self._calc_pointer_table_size()
         if self.is_dir == 0:
             self._fill_pointer_table()
+            self.uncompressed_block_size = None
+            self.n_compressed_blocks = None
+
+    def __repr__(self):  # pragma: no cover
+        return f"<SFSTreeItem {self.name}  {self.size} Bytes>"
 
     def _calc_pointer_table_size(self):
         n_chunks = ceil(self.size / self.sfs.usable_chunk)
@@ -119,13 +131,10 @@ def _fill_pointer_table(self):
         self.pointer is the sfs pointer table containing addresses of
         every chunk of the file.
 
-        The pointer table if the file is big can extend throught many
-        sfs chunks. Differently than files, the pointer table of file have no
-        table of pointers to the chunks. Instead if pointer table is larger
-        than sfs chunk, the chunk header contains next chunk number (address
-        can be calculated using known chunk size and global offset) with
-        continuation of file pointer table, thus it have to be read and filled
-        consecutive.
+        The pointer table, if the internal file is large enough, can extend
+        throught many sfs blocks. In case pointer table or its continuation
+        do not fit inside single SFS block, then the block's header contains
+        next block index.
         """
         # table size in number of chunks:
         n_of_chunks = ceil(self.size_in_chunks / (self.sfs.usable_chunk // 4))
@@ -135,7 +144,7 @@ def _fill_pointer_table(self):
                 temp_string = io.BytesIO()
                 for dummy1 in range(n_of_chunks):
                     fn.seek(self.sfs.chunksize * next_chunk + 0x118)
-                    next_chunk = strct_unp("<I", fn.read(4))[0]
+                    next_chunk = unpack("<I", fn.read(4))[0]
                     fn.seek(28, 1)
                     temp_string.write(fn.read(self.sfs.usable_chunk))
                 temp_string.seek(0)
@@ -198,7 +207,6 @@ def _iter_read_chunks(self, first=0):
 
         Keyword arguments:
         first -- the index of first chunk from which to read. (default 0)
-        chunks -- the number of chunks to read. (default False)
         """
         last = self.size_in_chunks
         with open(self.sfs.filename, "rb") as fn:
@@ -206,35 +214,13 @@ def _iter_read_chunks(self, first=0):
                 fn.seek(self.pointers[idx])
                 yield fn.read(self.sfs.usable_chunk)
             fn.seek(self.pointers[last - 1])
-            last_stuff = self.size % self.sfs.usable_chunk
-            if last_stuff != 0:
-                yield fn.read(last_stuff)
+            last_n_bytes = self.size % self.sfs.usable_chunk
+            if last_n_bytes != 0:
+                yield fn.read(last_n_bytes)
             else:
                 yield fn.read(self.sfs.usable_chunk)
 
-    def setup_compression_metadata(self):
-        """parse and setup the number of compression chunks
-
-        and uncompressed chunk size as class attributes.
-
-        Sets up attributes:
-        self.uncompressed_blk_size, self.no_of_compr_blk
-
-        """
-        with open(self.sfs.filename, "rb") as fn:
-            fn.seek(self.pointers[0])
-            # AACS signature, uncompressed size, undef var, number of blocks
-            aacs, uc_size, _, n_of_blocks = strct_unp("<IIII", fn.read(16))
-        if aacs == 0x53434141:  # AACS as string
-            self.uncompressed_blk_size = uc_size
-            self.no_of_compr_blk = n_of_blocks
-        else:
-            raise ValueError(
-                """The file is marked to be compressed,
-but compression signature is missing in the header. Aborting...."""
-            )
-
-    def _iter_read_compr_chunks(self):
+    def _iter_read_compressed_chunks(self):
         """Generate and return reader and decompressor iterator
         for compressed with zlib compression sfs internal file.
 
@@ -243,9 +229,9 @@ def _iter_read_compr_chunks(self):
         """
 
         offset = 0x80  # the 1st compression block header
-        for dummy1 in range(self.no_of_compr_blk):
-            cpr_size = strct_unp("<I12x", self.read_piece(offset, 16))[0]
-            # cpr_size, dum_size, dum_unkn, dum_size2 = strct_unp('<IIII',...
+        for dummy1 in range(self.n_compressed_blocks):
+            cpr_size = unpack("<I12x", self.read_piece(offset, 16))[0]
+            # cpr_size, dum_size, dum_unkn, dum_size2 = unpack('<IIII',...
             # dum_unkn is probably some kind of checksum but
             # none of known (crc16, crc32, adler32) algorithm could match.
             # dum_size2 == cpr_size + 0x10 which have no use...
@@ -257,29 +243,26 @@ def _iter_read_compr_chunks(self):
             yield unzip_block(raw_string)
 
     def get_iter_and_properties(self):
-        """Generate and return the iterator of data chunks and
-        properties of such chunks such as size and count.
+        """Generate and return the iterator of data blocks and
+        properties of set of blocks such as single block size
+        and number of blocks.
+
+        This method is memory efficient, as it returns iterator
+        which loads blocks iteratively.
 
         Method detects if data is compressed and uses iterator with
         decompression involved, else uses simple iterator of chunks.
 
         Returns:
-            (iterator, chunk_size, number_of_chunks)
+            tuple of (iterator, single block size, number of chunks)
         """
-        if self.sfs.compression == "None":
+        if not self.sfs.compression:
             return self._iter_read_chunks(), self.sfs.usable_chunk, self.size_in_chunks
-        elif self.sfs.compression == "zlib":
+        if self.sfs.compression:
             return (
-                self._iter_read_compr_chunks(),
-                self.uncompressed_blk_size,
-                self.no_of_compr_blk,
-            )
-        else:
-            raise RuntimeError(
-                "file",
-                str(self.sfs.filename),
-                " is compressed by not known and not",
-                "implemented algorithm.\n Aborting...",
+                self._iter_read_compressed_chunks(),
+                self.uncompressed_block_size,
+                self.n_compressed_blocks,
             )
 
     def get_as_BytesIO_string(self):
@@ -289,41 +272,67 @@ def get_as_BytesIO_string(self):
         return data
 
 
-class SFS_reader(object):
-    """Class to read sfs file.
-    SFS is AidAim software's(tm) single file system.
+class SFSReader(object):
+    """Class to read sfs file. SFS is known to be used by Bruker for
+    saving particle analysis (*.pan) frames, hyper-spectral maps and
+    EBSD maps and metadata (*.bcf).
+    SFS stands for AidAim software's(tm) [s]ingle [f]ile [s]ystem.
     The class provides basic reading capabilities of such container.
     It is capable to read compressed data in zlib, but
-    SFS can contain other compression which is not implemented here.
-    It is also not able to read encrypted sfs containers.
+    SFS can use other compression than zlib, which is not implemented
+    here. This implementation also does not cover SFS internal encryption.
+
+    This class can be used stand-alone or inherited in construction of
+    file readers for files using this format.
 
-    This class can be used stand alone or inherited in construction of
-    file readers using sfs technolgy.
+    The format can be recognised independently from file extension
+    by file "magic" in the first 8 bytes: AAMVHFSS
 
-    Attributes
+    Attributes:
     ----------
-    filename
+    vfs - virtual file system -- the dictionarized representation of sfs
+      file tree.
+    filename - filename or full path (depends from initialization)
+      which is used for opening and reading SFS internal file content.
+    compression - if internal files are compressed.
+    sfs_version - SFS version (for debug)
+    chunksize - block size including block header and data (often a "round"
+      number in hexidecimali, but in EBSD cases could be "optimized")
+    usable_chunk - usable size within single block after subtraction size
+      of block header (-32 bytes)
+    tree_address - block index where file tree descriptor starts
+    n_tree_items - number of items in tree descriptor (including files and
+      directories)
+    n_sfs_chunks - total number of blocks in the SFS file (serves
+      no purpose in reading, probably used for appending data)
+
+    Methods:
+    ----------
+    get_file - get file at pointed internal path as SFSTreeItem
 
     """
 
     def __init__(self, filename):
+        """SFSReader requires valid relative or absolute path-like object.
+        It should be same valid as it would for python built-in open()"""
         self.filename = filename
+        self.compression = None
         # read the file header
-        with open(filename, "rb") as fn:
-            a = fn.read(8)
-            if a != b"AAMVHFSS":
-                raise TypeError("file '{0}' is not SFS container".format(filename))
-            fn.seek(0x124)  # this looks to be version, as float value is always
+        with open(filename, "rb") as file:
+            magic = file.read(8)
+            if magic != b"AAMVHFSS":
+                raise TypeError(f"file '{filename}' is not SFS container")
+            file.seek(0x124)  # this looks to be version, as float value is
             # nicely rounded and at older bcf versions (<1.9) it was 2.40,
             # at new (v2) - 2.60
-            version, self.chunksize = strct_unp("<fI", fn.read(8))
-            self.sfs_version = "{0:4.2f}".format(version)
+            version, self.chunksize = unpack("<fI", file.read(8))
+            self.sfs_version = f"{version:4.2f}"
             self.usable_chunk = self.chunksize - 32
-            fn.seek(0x140)
+            file.seek(0x140)
             # the sfs tree and number of the items / files + directories in it,
             # and the number in chunks of whole sfs:
-            self.tree_address, self.n_tree_items, self.sfs_n_of_chunks = strct_unp(
-                "<III", fn.read(12)
+            self.tree_address, self.n_tree_items, self.n_sfs_chunks = unpack(
+                "<III", file.read(12)
             )
         self._setup_vfs()
 
@@ -335,26 +344,26 @@ def _setup_vfs(self):
         --------
         SFSTreeItem
         """
-        with open(self.filename, "rb") as fn:
+        with open(self.filename, "rb") as sfs:
             # check if file tree do not exceed one chunk:
             n_file_tree_chunks = ceil(
                 (self.n_tree_items * 0x200) / (self.chunksize - 0x20)
             )
             if n_file_tree_chunks == 1:
                 # file tree do not exceed one chunk in bcf:
-                fn.seek(self.chunksize * self.tree_address + 0x138)
-                raw_tree = fn.read(0x200 * self.n_tree_items)
+                sfs.seek(self.chunksize * self.tree_address + 0x138)
+                raw_tree = sfs.read(0x200 * self.n_tree_items)
             else:
                 temp_str = io.BytesIO()
                 tree_address = self.tree_address
                 tree_items_in_chunk = (self.chunksize - 0x20) // 0x200
                 for i in range(n_file_tree_chunks):
                     # jump to tree/list address:
-                    fn.seek(self.chunksize * tree_address + 0x118)
+                    sfs.seek(self.chunksize * tree_address + 0x118)
                     # next tree/list address:
-                    tree_address = strct_unp("<I", fn.read(4))[0]
-                    fn.seek(28, 1)
-                    temp_str.write(fn.read(tree_items_in_chunk * 0x200))
+                    tree_address = unpack("<I", sfs.read(4))[0]
+                    sfs.seek(28, 1)
+                    temp_str.write(sfs.read(tree_items_in_chunk * 0x200))
                 temp_str.seek(0)
                 raw_tree = temp_str.read(self.n_tree_items * 0x200)
                 temp_str.close()
@@ -362,62 +371,91 @@ def _setup_vfs(self):
                 SFSTreeItem(raw_tree[i * 0x200 : (i + 1) * 0x200], self)
                 for i in range(self.n_tree_items)
             ]
-            # temp list with parents of items
-            paths = [[h.parent] for h in temp_item_list]
         # checking the compression header which can be different per file:
-        self._check_the_compresion(temp_item_list)
-        if self.compression == "zlib":
-            for c in temp_item_list:
-                if not c.is_dir:
-                    c.setup_compression_metadata()
+        self._check_the_compression(temp_item_list)
+        if self.compression:
+            for item in temp_item_list:
+                if item.is_dir == 0:
+                    self._setup_compression_metadata(item)
         # convert the items to virtual file system tree
-        dict_tree = self._flat_items_to_dict(paths, temp_item_list)
+        dict_tree = self._flat_items_to_dict(temp_item_list)
         # and finaly set the Virtual file system:
         self.vfs = dict_tree["root"]
 
-    def _flat_items_to_dict(self, paths, temp_item_list):
+    def _setup_compression_metadata(self, item):
+        """parse and setup the number of compression chunks
+
+        and uncompressed chunk size as class attributes.
+
+        Sets up attributes:
+        item.uncompressed_blk_size, item.no_of_compr_blk
+
+        """
+        with open(self.filename, "rb") as sfs:
+            sfs.seek(item.pointers[0])
+            # AACS signature, uncompressed size, undef var, number of blocks
+            aacs, uc_size, _, n_of_blocks = unpack("<IIII", sfs.read(16))
+        if aacs == 0x53434141:  # AACS as string
+            item.uncompressed_block_size = uc_size
+            item.n_compressed_blocks = n_of_blocks
+        else:  # pragma: no cover
+            raise ValueError(
+                """The file is marked to be compressed,
+but compression signature is missing in the header. Aborting...."""
+            )
+            # Such kind of bug failed to be replicated more than once
+
+    @staticmethod
+    def _flat_items_to_dict(temp_item_list):
         """place items from flat list into dictionary tree
         of virtual file system
         """
+        # init path defined by indices with direct parent of item:
+        paths = [[h.parent] for h in temp_item_list]
+
         while not all(g[-1] == -1 for g in paths):
-            for f in range(len(paths)):
-                if paths[f][-1] != -1:
-                    paths[f].extend(paths[paths[f][-1]])
+            for path in paths:
+                if path[-1] != -1:
+                    path.extend(paths[path[-1]])
         names = [j.name for j in temp_item_list]
         names.append("root")  # temp root item in dictionary
-        for p in paths:
-            for r in range(len(p)):
-                p[r] = names[p[r]]
-        for p in paths:
-            p.reverse()
+        for path in paths:
+            for idx, parent in enumerate(path):
+                path[idx] = names[parent]
+        # reverse sequences of parent indexes:
+        for path in paths:
+            path.reverse()
         root = {}
-        for i in range(len(temp_item_list)):
+        for idx, item in enumerate(temp_item_list):
             dir_pointer = root
-            for j in paths[i]:
+            for j in paths[idx]:
                 if j in dir_pointer:
                     dir_pointer = dir_pointer[j]
                 else:
                     dir_pointer[j] = {}
                     dir_pointer = dir_pointer[j]
-            if temp_item_list[i].is_dir:
-                dir_pointer[temp_item_list[i].name] = {}
+            if item.is_dir:
+                dir_pointer[item.name] = {}
             else:
-                dir_pointer[temp_item_list[i].name] = temp_item_list[i]
+                dir_pointer[item.name] = item
         # return dict tree:
         return root
 
-    def _check_the_compresion(self, temp_item_list):
+    def _check_the_compression(self, temp_item_list):
         """parse, check and setup the self.compression"""
-        with open(self.filename, "rb") as fn:
+        with open(self.filename, "rb") as sfs:
             # Find if there is compression:
-            for c in temp_item_list:
-                if not c.is_dir:
-                    fn.seek(c.pointers[0])
-                    if fn.read(4) == b"\x41\x41\x43\x53":  # string AACS
-                        self.compression = "zlib"
+            for entry in temp_item_list:
+                if not entry.is_dir:
+                    sfs.seek(entry.pointers[0])
+                    # this only checks for compression, not the type.
+                    # bruker is known to use only zlib, thus this
+                    # function is simplified.
+                    if sfs.read(4) == b"\x41\x41\x43\x53":  # string AACS
+                        self.compression = True
                     else:
-                        self.compression = "None"
-                    # compression is global, can't be diferent per file in sfs
+                        self.compression = False
+                    # compression is global - same for all  files in sfs
                     break
 
     def get_file(self, path):
@@ -871,11 +909,11 @@ def gen_hspy_item_dict_basic(self):
         return i
 
 
-class BCF_reader(SFS_reader):
+class BCFReader(SFSReader):
 
     """Class to read bcf (Bruker hypermapping) file.
 
-    Inherits SFS_reader and all its attributes and methods.
+    Inherits SFSReader and all its attributes and methods.
 
     Attributes:
     filename
@@ -888,7 +926,7 @@ class BCF_reader(SFS_reader):
     """
 
     def __init__(self, filename, instrument=None):
-        SFS_reader.__init__(self, filename)
+        SFSReader.__init__(self, filename)
         header_file = self.get_file("EDSDatabase/HeaderData")
         self.available_indexes = []
         # get list of presented indexes from file tree of binary sfs container
@@ -968,7 +1006,7 @@ def parse_hypermap(self, index=None, downsample=1, cutoff_at_kV=None, lazy=False
             ceil(self.header.image.width / downsample),
             n_channels,
         )
-        sfs_file = SFS_reader(self.filename)
+        sfs_file = SFSReader(self.filename)
         vrt_file_hand = sfs_file.get_file("EDSDatabase/SpectrumData" + str(index))
         if fast_unbcf:
             parse_func = unbcf_fast.parse_to_numpy
@@ -993,10 +1031,18 @@ def add_filename_to_general(self, item):
 
 
 def spx_reader(filename, lazy=False):
-    with open(filename, "br") as fn:
-        xml_str = fn.read()
+    with open(filename, "br") as spx:
+        xml_str = spx.read()
     root = ET.fromstring(xml_str)
     sp_node = root.find("./ClassInstance[@Type='TRTSpectrum']")
+    spect = spectra_from_xml(sp_node)
+    spect[0]["metadata"]["General"]["original_filename"] = basename(filename)
+    return spect
+
+
+def spectra_from_xml(sp_node):
+    """translate etree node from bruker xml [with attribute Type='TRTSpectrum']
+    and return rsciio type of signal"""
     try:
         name = str(sp_node.attrib["Name"])
     except KeyError:
@@ -1028,14 +1074,13 @@ def spx_reader(filename, lazy=False):
                 }
             },
             "General": {
-                "original_filename": basename(filename),
                 "title": "EDX",
                 "date": spectrum.date,
                 "time": spectrum.time,
             },
             "Sample": {"name": name},
             "Signal": {
-                "signal_type": "EDS_%s" % mode,
+                "signal_type": f"EDS_{mode}",
                 "record_by": "spectrum",
                 "quantity": "X-rays (Counts)",
             },
@@ -1076,8 +1121,8 @@ def py_parse_hypermap(virtual_file, shape, dtype, downsample=1):
 
     Parameters
     ----------
-    virtual_file -- virtual file handle returned by SFS_reader instance
-        or by object inheriting it (e.g. BCF_reader instance)
+    virtual_file -- virtual file handle returned by SFSReader instance
+        or by object inheriting it (e.g. instance of BCFReader)
     shape -- numpy shape
     dtype -- numpy dtype
     downsample -- downsample factor
@@ -1094,7 +1139,7 @@ def py_parse_hypermap(virtual_file, shape, dtype, downsample=1):
     dwn_factor = downsample
     max_chan = shape[2]
     buffer1 = next(iter_data)
-    height, width = strct_unp("<ii", buffer1[:8])
+    height, width = unpack("<ii", buffer1[:8])
     # hyper map as very flat array:
     vfa = np.zeros(shape[0] * shape[1] * shape[2], dtype=dtype)
     offset = 0x1A0
@@ -1104,7 +1149,7 @@ def py_parse_hypermap(virtual_file, shape, dtype, downsample=1):
             size = size_chnk + size - offset
             buffer1 = buffer1[offset:] + next(iter_data)
             offset = 0
-        line_head = strct_unp("<i", buffer1[offset : offset + 4])[0]
+        line_head = unpack("<i", buffer1[offset : offset + 4])[0]
         offset += 4
         for dummy1 in range(line_head):
             if (offset + 22) >= size:
@@ -1133,7 +1178,7 @@ def py_parse_hypermap(virtual_file, shape, dtype, downsample=1):
                 dummy_size1,
                 n_of_pulses,
                 data_size2,
-            ) = strct_unp("<IHHIHHHI", buffer1[offset : offset + 22])
+            ) = unpack("<IHHIHHHI", buffer1[offset : offset + 22])
             pix_idx = (x_pix // dwn_factor) + (
                 ceil(width / dwn_factor) * (line_cnt // dwn_factor)
             )
@@ -1176,12 +1221,12 @@ def py_parse_hypermap(virtual_file, shape, dtype, downsample=1):
                     # this would work on py3
                     # size_p, channels = buffer1[offset:offset + 2]
                     # this is needed on py2:
-                    size_p, channels = strct_unp("<BB", buffer1[offset : offset + 2])
+                    size_p, channels = unpack("<BB", buffer1[offset : offset + 2])
                     offset += 2
                     if size_p == 0:
                         pixel += channels * [0]
                     else:
-                        gain = strct_unp(
+                        gain = unpack(
                             "<" + st[size_p * 2], buffer1[offset : offset + size_p]
                         )[0]
                         offset += size_p
@@ -1189,18 +1234,18 @@ def py_parse_hypermap(virtual_file, shape, dtype, downsample=1):
                             # special case with nibble switching
                             length = ceil(channels / 2)
                             # valid py3 code
-                            # a = list(buffer1[offset:offset + length])
+                            a = list(buffer1[offset:offset + length])
                             # this have to be used on py2:
-                            a = strct_unp(
-                                "<" + "B" * length, buffer1[offset : offset + length]
-                            )
+                            # a = unpack(
+                            #    "<" + "B" * length, buffer1[offset : offset + length]
+                            # )
                             g = []
                             for i in a:
                                 g += (i & 0x0F) + gain, (i >> 4) + gain
                             pixel += g[:channels]
                         else:
                             length = int(channels * size_p / 2)
-                            temp = strct_unp(
+                            temp = unpack(
                                 "<" + channels * st[size_p],
                                 buffer1[offset : offset + length],
                             )
@@ -1211,14 +1256,14 @@ def py_parse_hypermap(virtual_file, shape, dtype, downsample=1):
                     pixel += rest * [0]
                 # additional data size:
                 if n_of_pulses > 0:
-                    add_s = strct_unp("<I", buffer1[offset : offset + 4])[0]
+                    add_s = unpack("<I", buffer1[offset : offset + 4])[0]
                     offset += 4
                     if (offset + add_s) >= size:
                         buffer1 = buffer1[offset:] + next(iter_data)
                         size = size_chnk + size - offset
                         offset = 0
                     # the additional pulses:
-                    add_pulses = strct_unp(
+                    add_pulses = unpack(
                         "<" + "H" * n_of_pulses, buffer1[offset : offset + add_s]
                     )
                     offset += add_s
@@ -1352,7 +1397,7 @@ def bcf_reader(
     """
 
     # objectified bcf file:
-    obj_bcf = BCF_reader(filename, instrument=instrument)
+    obj_bcf = BCFReader(filename, instrument=instrument)
     if select_type == "image":
         return bcf_images(obj_bcf)
     elif select_type == "spectrum_image":
diff --git a/rsciio/bruker/api.py b/rsciio/bruker/api.py
new file mode 100644
index 00000000..24a99282
--- /dev/null
+++ b/rsciio/bruker/api.py
@@ -0,0 +1 @@
+from ._api import *
diff --git a/rsciio/tests/test_bruker.py b/rsciio/tests/test_bruker.py
index ea224330..50d1a47f 100644
--- a/rsciio/tests/test_bruker.py
+++ b/rsciio/tests/test_bruker.py
@@ -239,11 +239,11 @@ def test_wrong_file():
 
 def test_fast_bcf():
     thingy = pytest.importorskip("rsciio.bruker.unbcf_fast")
-    from rsciio.bruker import _api
+    from rsciio.bruker import _api, api
 
     for bcffile in test_files:
         filename = os.path.join(my_path, "bruker_data", bcffile)
-        thingy = _api.BCF_reader(filename)
+        thingy = api.BCFReader(filename)
         for j in range(2, 5, 1):
             print("downsampling:", j)
             _api.fast_unbcf = True  # manually enabling fast parsing