From 98397f6fdc0f9c04c7372b68a4795dc657b78edb Mon Sep 17 00:00:00 2001
From: Petras Jokubauskas <klavishas@gmail.com>
Date: Thu, 18 May 2023 15:30:20 +0200
Subject: [PATCH 1/7] rename class SFS_reader into SfsReader to follow python
 class naming convention

---
 rsciio/bruker/_api.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/rsciio/bruker/_api.py b/rsciio/bruker/_api.py
index 852daea8..ad1aba90 100644
--- a/rsciio/bruker/_api.py
+++ b/rsciio/bruker/_api.py
@@ -289,7 +289,7 @@ def get_as_BytesIO_string(self):
         return data
 
 
-class SFS_reader(object):
+class SfsReader(object):
     """Class to read sfs file.
     SFS is AidAim software's(tm) single file system.
     The class provides basic reading capabilities of such container.
@@ -871,11 +871,11 @@ def gen_hspy_item_dict_basic(self):
         return i
 
 
-class BCF_reader(SFS_reader):
+class BCF_reader(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 +888,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 +968,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
@@ -1076,7 +1076,7 @@ def py_parse_hypermap(virtual_file, shape, dtype, downsample=1):
 
     Parameters
     ----------
-    virtual_file -- virtual file handle returned by SFS_reader instance
+    virtual_file -- virtual file handle returned by SfsReader instance
         or by object inheriting it (e.g. BCF_reader instance)
     shape -- numpy shape
     dtype -- numpy dtype

From 8fb64903b60228b3fef8ba26a866a14ae718aebe Mon Sep 17 00:00:00 2001
From: Petras Jokubauskas <klavishas@gmail.com>
Date: Fri, 19 May 2023 16:49:05 +0200
Subject: [PATCH 2/7] cleanup bruker _api and expose SfsReader under api

---
 rsciio/bruker/__init__.py |   2 +
 rsciio/bruker/_api.py     | 161 +++++++++++++++++++++++---------------
 rsciio/bruker/api.py      |   1 +
 3 files changed, 103 insertions(+), 61 deletions(-)
 create mode 100644 rsciio/bruker/api.py

diff --git a/rsciio/bruker/__init__.py b/rsciio/bruker/__init__.py
index d4de92f6..da8b3dc9 100644
--- a/rsciio/bruker/__init__.py
+++ b/rsciio/bruker/__init__.py
@@ -1,8 +1,10 @@
 from ._api import file_reader
+from . import api
 
 
 __all__ = [
     "file_reader",
+    "api",
 ]
 
 
diff --git a/rsciio/bruker/_api.py b/rsciio/bruker/_api.py
index ad1aba90..1b99393e 100644
--- a/rsciio/bruker/_api.py
+++ b/rsciio/bruker/_api.py
@@ -46,6 +46,10 @@
 
 from rsciio.docstrings import FILENAME_DOC, LAZY_DOC, RETURNS_DOC
 
+__all__ = [
+    "SfsReader",
+]
+
 _logger = logging.getLogger(__name__)
 
 warn_once = True
@@ -71,22 +75,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,
@@ -108,6 +113,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):
+        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 +129,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))
@@ -198,7 +205,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 +212,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,7 +227,7 @@ def _iter_read_compr_chunks(self):
         """
 
         offset = 0x80  # the 1st compression block header
-        for dummy1 in range(self.no_of_compr_blk):
+        for dummy1 in range(self.n_compressed_blocks):
             cpr_size = strct_unp("<I12x", self.read_piece(offset, 16))[0]
             # cpr_size, dum_size, dum_unkn, dum_size2 = strct_unp('<IIII',...
             # dum_unkn is probably some kind of checksum but
@@ -257,22 +241,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":
             return self._iter_read_chunks(), self.sfs.usable_chunk, self.size_in_chunks
         elif self.sfs.compression == "zlib":
             return (
-                self._iter_read_compr_chunks(),
-                self.uncompressed_blk_size,
-                self.no_of_compr_blk,
+                self._iter_read_compressed_chunks(),
+                self.uncompressed_block_size,
+                self.n_compressed_blocks,
             )
         else:
             raise RuntimeError(
@@ -290,24 +278,52 @@ def get_as_BytesIO_string(self):
 
 
 class SfsReader(object):
-    """Class to read sfs file.
-    SFS is AidAim software's(tm) single file system.
+    """Class to read sfs file. SFS is known to be used by bruker for
+    saving particle analysis (*.pan) frames, hyperspectral 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.
 
     This class can be used stand alone or inherited in construction of
-    file readers using sfs technolgy.
+    file readers for files using this format.
+
+    The format can be recognised independently from file extension
+    by file "magic" in the first 8 bytes: AAMVHFSS
 
     Attributes
     ----------
     filename
 
+    Attributes:
+    ----------
+    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)
+    sfs_n_of_chunks - total number of blocks in the SFS file (serves
+      no purpoise in reading, probably used for appending data)
+
+    Methods:
+    ----------
+    get_file - get file at pointed internal path as SFSTreeItem
+
     """
 
     def __init__(self, filename):
         self.filename = filename
+        self.compression = None
         # read the file header
         with open(filename, "rb") as fn:
             a = fn.read(8)
@@ -365,24 +381,47 @@ def _setup_vfs(self):
             # 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)
+        self._check_the_compression(temp_item_list)
         if self.compression == "zlib":
-            for c in temp_item_list:
-                if not c.is_dir:
-                    c.setup_compression_metadata()
+            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)
         # 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 = strct_unp("<IIII", sfs.read(16))
+        if aacs == 0x53434141:  # AACS as string
+            item.uncompressed_block_size = uc_size
+            item.n_compressed_blocks = n_of_blocks
+        else:
+            raise ValueError(
+                """The file is marked to be compressed,
+but compression signature is missing in the header. Aborting...."""
+            )
+
+    @staticmethod
+    def _flat_items_to_dict(paths, temp_item_list):
         """place items from flat list into dictionary tree
         of virtual file system
         """
         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:
@@ -406,7 +445,7 @@ def _flat_items_to_dict(self, paths, temp_item_list):
         # 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:
             # Find if there is compression:
@@ -441,7 +480,7 @@ def get_file(self, path):
         to get "file" object 'kitten.png' in folder 'catz' which
         resides in root directory of sfs, you would use:
 
-        >>> instance_of_SFSReader.get_file('catz/kitten.png')
+        >>> instance_of_SfsReader.get_file('catz/kitten.png')
 
         See also
         --------
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 *

From ef337cc8dd24dd7a318491789469abf3b1c40ee9 Mon Sep 17 00:00:00 2001
From: Petras Jokubauskas <klavishas@gmail.com>
Date: Sat, 27 May 2023 14:55:56 +0200
Subject: [PATCH 3/7] dont expose .api within __init__

---
 rsciio/bruker/__init__.py | 2 --
 rsciio/bruker/_api.py     | 4 ++--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/rsciio/bruker/__init__.py b/rsciio/bruker/__init__.py
index da8b3dc9..d4de92f6 100644
--- a/rsciio/bruker/__init__.py
+++ b/rsciio/bruker/__init__.py
@@ -1,10 +1,8 @@
 from ._api import file_reader
-from . import api
 
 
 __all__ = [
     "file_reader",
-    "api",
 ]
 
 
diff --git a/rsciio/bruker/_api.py b/rsciio/bruker/_api.py
index 1b99393e..a643c17e 100644
--- a/rsciio/bruker/_api.py
+++ b/rsciio/bruker/_api.py
@@ -82,7 +82,7 @@ class SFSTreeItem(object):
 
     Attributes:
     item_raw_string -- the bytes from sfs file table describing the file
-    parent -- the index of parent item in SFS file table. 
+    parent -- the index of parent item in SFS file table.
     The index of root is -1.
 
     Methods:
@@ -116,7 +116,7 @@ def __init__(self, item_raw_string, sfs):
             self.uncompressed_block_size = None
             self.n_compressed_blocks = None
 
-    def __repr__(self):
+    def __repr__(self):  # pragma: no cover
         return f"<SFSTreeItem {self.name}  {self.size} Bytes>"
 
     def _calc_pointer_table_size(self):

From efac6ebff9f32489f03f1b9626e7d176707349d0 Mon Sep 17 00:00:00 2001
From: Petras Jokubauskas <klavishas@gmail.com>
Date: Sun, 28 May 2023 13:59:11 +0200
Subject: [PATCH 4/7] rename classes to comply with PEP8: SfsReader->SFSReader
 BCF_reader -> BCFReader update docstrings

---
 rsciio/bruker/_api.py | 41 ++++++++++++++++++++---------------------
 1 file changed, 20 insertions(+), 21 deletions(-)

diff --git a/rsciio/bruker/_api.py b/rsciio/bruker/_api.py
index a643c17e..23e4a271 100644
--- a/rsciio/bruker/_api.py
+++ b/rsciio/bruker/_api.py
@@ -47,7 +47,7 @@
 from rsciio.docstrings import FILENAME_DOC, LAZY_DOC, RETURNS_DOC
 
 __all__ = [
-    "SfsReader",
+    "SFSReader",
 ]
 
 _logger = logging.getLogger(__name__)
@@ -277,26 +277,22 @@ def get_as_BytesIO_string(self):
         return data
 
 
-class SfsReader(object):
-    """Class to read sfs file. SFS is known to be used by bruker for
-    saving particle analysis (*.pan) frames, hyperspectral maps and
+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
+    This class can be used stand-alone or inherited in construction of
     file readers for files using this format.
 
     The format can be recognised independently from file extension
     by file "magic" in the first 8 bytes: AAMVHFSS
 
-    Attributes
-    ----------
-    filename
-
     Attributes:
     ----------
     vfs - virtual file system -- the dictionarized representation of sfs
@@ -313,7 +309,7 @@ class SfsReader(object):
     n_tree_items - number of items in tree descriptor (including files and
       directories)
     sfs_n_of_chunks - total number of blocks in the SFS file (serves
-      no purpoise in reading, probably used for appending data)
+      no purpose in reading, probably used for appending data)
 
     Methods:
     ----------
@@ -322,6 +318,8 @@ class SfsReader(object):
     """
 
     def __init__(self, filename):
+        """SFSReader requires valid relative or absolute path-like object.
+        which is used in python built-in open() function"""
         self.filename = filename
         self.compression = None
         # read the file header
@@ -407,11 +405,12 @@ def _setup_compression_metadata(self, item):
         if aacs == 0x53434141:  # AACS as string
             item.uncompressed_block_size = uc_size
             item.n_compressed_blocks = n_of_blocks
-        else:
+        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(paths, temp_item_list):
@@ -480,7 +479,7 @@ def get_file(self, path):
         to get "file" object 'kitten.png' in folder 'catz' which
         resides in root directory of sfs, you would use:
 
-        >>> instance_of_SfsReader.get_file('catz/kitten.png')
+        >>> instance_of_SFSReader.get_file('catz/kitten.png')
 
         See also
         --------
@@ -910,11 +909,11 @@ def gen_hspy_item_dict_basic(self):
         return i
 
 
-class BCF_reader(SfsReader):
+class BCFReader(SFSReader):
 
     """Class to read bcf (Bruker hypermapping) file.
 
-    Inherits SfsReader and all its attributes and methods.
+    Inherits SFSReader and all its attributes and methods.
 
     Attributes:
     filename
@@ -927,7 +926,7 @@ class BCF_reader(SfsReader):
     """
 
     def __init__(self, filename, instrument=None):
-        SfsReader.__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
@@ -1007,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 = SfsReader(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
@@ -1115,8 +1114,8 @@ def py_parse_hypermap(virtual_file, shape, dtype, downsample=1):
 
     Parameters
     ----------
-    virtual_file -- virtual file handle returned by SfsReader 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
@@ -1391,7 +1390,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":

From 4d48681024b23564f1aad1a46f312f7882861f11 Mon Sep 17 00:00:00 2001
From: Petras Jokubauskas <klavishas@gmail.com>
Date: Sun, 28 May 2023 14:19:41 +0200
Subject: [PATCH 5/7] fix_test

---
 rsciio/tests/test_bruker.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rsciio/tests/test_bruker.py b/rsciio/tests/test_bruker.py
index ea224330..8b08c73d 100644
--- a/rsciio/tests/test_bruker.py
+++ b/rsciio/tests/test_bruker.py
@@ -243,7 +243,7 @@ def test_fast_bcf():
 
     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

From 63979e4d3d551818bade61d8f1fd093c15ea72d8 Mon Sep 17 00:00:00 2001
From: Petras Jokubauskas <klavishas@gmail.com>
Date: Mon, 29 May 2023 09:57:31 +0200
Subject: [PATCH 6/7] expose spectra_from_xml, other polishing

---
 rsciio/bruker/_api.py       | 160 +++++++++++++++++++-----------------
 rsciio/tests/test_bruker.py |   4 +-
 2 files changed, 85 insertions(+), 79 deletions(-)

diff --git a/rsciio/bruker/_api.py b/rsciio/bruker/_api.py
index 23e4a271..8a272119 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
@@ -47,7 +47,9 @@
 from rsciio.docstrings import FILENAME_DOC, LAZY_DOC, RETURNS_DOC
 
 __all__ = [
+    "BCFReader",
     "SFSReader",
+    "spectra_from_xml",
 ]
 
 _logger = logging.getLogger(__name__)
@@ -105,7 +107,7 @@ def __init__(self, item_raw_string, sfs):
             _,
             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)
@@ -142,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)
@@ -228,8 +230,8 @@ def _iter_read_compressed_chunks(self):
 
         offset = 0x80  # the 1st compression block header
         for dummy1 in range(self.n_compressed_blocks):
-            cpr_size = strct_unp("<I12x", self.read_piece(offset, 16))[0]
-            # cpr_size, dum_size, dum_unkn, dum_size2 = strct_unp('<IIII',...
+            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...
@@ -254,21 +256,14 @@ def get_iter_and_properties(self):
         Returns:
             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_compressed_chunks(),
                 self.uncompressed_block_size,
                 self.n_compressed_blocks,
             )
-        else:
-            raise RuntimeError(
-                "file",
-                str(self.sfs.filename),
-                " is compressed by not known and not",
-                "implemented algorithm.\n Aborting...",
-            )
 
     def get_as_BytesIO_string(self):
         """Get the whole file as io.BytesIO object (in memory!)."""
@@ -308,7 +303,7 @@ class SFSReader(object):
     tree_address - block index where file tree descriptor starts
     n_tree_items - number of items in tree descriptor (including files and
       directories)
-    sfs_n_of_chunks - total number of blocks in the SFS file (serves
+    n_sfs_chunks - total number of blocks in the SFS file (serves
       no purpose in reading, probably used for appending data)
 
     Methods:
@@ -319,25 +314,25 @@ class SFSReader(object):
 
     def __init__(self, filename):
         """SFSReader requires valid relative or absolute path-like object.
-        which is used in python built-in open() function"""
+        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()
 
@@ -349,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()
@@ -376,16 +371,14 @@ 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_compression(temp_item_list)
-        if self.compression == "zlib":
+        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"]
 
@@ -401,7 +394,7 @@ def _setup_compression_metadata(self, item):
         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 = strct_unp("<IIII", sfs.read(16))
+            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
@@ -413,49 +406,56 @@ def _setup_compression_metadata(self, item):
             # Such kind of bug failed to be replicated more than once
 
     @staticmethod
-    def _flat_items_to_dict(paths, temp_item_list):
+    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 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_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):
@@ -1031,10 +1031,17 @@ 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']")
+    rsc_sig = spectra_from_xml(sp_node)
+    rsc_sig[0]["metadata"]["General"]["original_filename"] = basename(filename)
+
+
+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:
@@ -1066,7 +1073,6 @@ def spx_reader(filename, lazy=False):
                 }
             },
             "General": {
-                "original_filename": basename(filename),
                 "title": "EDX",
                 "date": spectrum.date,
                 "time": spectrum.time,
@@ -1132,7 +1138,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
@@ -1142,7 +1148,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:
@@ -1171,7 +1177,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)
             )
@@ -1214,12 +1220,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
@@ -1227,18 +1233,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],
                             )
@@ -1249,14 +1255,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
diff --git a/rsciio/tests/test_bruker.py b/rsciio/tests/test_bruker.py
index 8b08c73d..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.BCFReader(filename)
+        thingy = api.BCFReader(filename)
         for j in range(2, 5, 1):
             print("downsampling:", j)
             _api.fast_unbcf = True  # manually enabling fast parsing

From a57fd729d6b12938c2395bf07d4aa2376267a1d5 Mon Sep 17 00:00:00 2001
From: Petras Jokubauskas <klavishas@gmail.com>
Date: Mon, 29 May 2023 12:16:20 +0200
Subject: [PATCH 7/7] missed return fix

---
 rsciio/bruker/_api.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/rsciio/bruker/_api.py b/rsciio/bruker/_api.py
index 8a272119..e96455a7 100644
--- a/rsciio/bruker/_api.py
+++ b/rsciio/bruker/_api.py
@@ -1035,8 +1035,9 @@ def spx_reader(filename, lazy=False):
         xml_str = spx.read()
     root = ET.fromstring(xml_str)
     sp_node = root.find("./ClassInstance[@Type='TRTSpectrum']")
-    rsc_sig = spectra_from_xml(sp_node)
-    rsc_sig[0]["metadata"]["General"]["original_filename"] = basename(filename)
+    spect = spectra_from_xml(sp_node)
+    spect[0]["metadata"]["General"]["original_filename"] = basename(filename)
+    return spect
 
 
 def spectra_from_xml(sp_node):
@@ -1079,7 +1080,7 @@ def spectra_from_xml(sp_node):
             },
             "Sample": {"name": name},
             "Signal": {
-                "signal_type": "EDS_%s" % mode,
+                "signal_type": f"EDS_{mode}",
                 "record_by": "spectrum",
                 "quantity": "X-rays (Counts)",
             },