imagedata 3.6.0__tar.gz → 3.6.0.dev12__tar.gz

{imagedata-3.6.0 → imagedata-3.6.0.dev12}/CHANGELOG.md

@@ -7,22 +7,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!--next-version-placeholder-->
 
-## [v3.6.0] - 2024-06-27
-* Final release 3.6.0.
-
-## [v3.6.0-rc4] - 2024-06-25
-### Changed
-* Depend on pylibjpeg.
-* Standardized logging to log proper module and function names.
-### Fixed
-* Honor the `skip_broken_series` option.
-
-## [v3.6.0-rc3] - 2024-06-21
-* Release candidate 3.
-
-## [v3.6.0-rc2] - 2024-06-20
-* Release candidate 2.
-
 ## [v3.6.0-rc0] - 2024-06-17
 * Release candidate 0.
 

{imagedata-3.6.0 → imagedata-3.6.0.dev12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: imagedata
-Version: 3.6.0
+Version: 3.6.0.dev12
 Summary: Read/write medical image data
 Author-email: Erling Andersen <Erling.Andersen@Helse-Bergen.NO>
 Maintainer-email: Erling Andersen <Erling.Andersen@Helse-Bergen.NO>
@@ -47,7 +47,6 @@ Requires-Python: <3.13,>=3.9
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 Requires-Dist: pydicom>=2.4.0
-Requires-Dist: pylibjpeg[all]
 Requires-Dist: pynetdicom<2,>=1.2.0
 Requires-Dist: itk-io>=5.4.0
 Requires-Dist: scikit-build-core

imagedata-3.6.0.dev12/VERSION.txt

@@ -0,0 +1 @@
+3.6.0-dev12

{imagedata-3.6.0 → imagedata-3.6.0.dev12}/pyproject.toml

@@ -30,7 +30,6 @@ keywords = [
 license = {file = "LICENSE.txt"}
 dependencies = [
     "pydicom>=2.4.0",
-    "pylibjpeg[all]",
     "pynetdicom>=1.2.0, <2",
     "itk-io>=5.4.0",
     "scikit-build-core",

{imagedata-3.6.0 → imagedata-3.6.0.dev12}/src/imagedata/__init__.py

@@ -1,5 +1,6 @@
 """imagedata"""
 
+from os.path import join
 import logging
 from importlib import import_module
 from importlib.metadata import version, entry_points

{imagedata-3.6.0 → imagedata-3.6.0.dev12}/src/imagedata/archives/__init__.py

@@ -36,7 +36,6 @@ def find_plugin(pfind, url, mode="r", opts=None):
 
 def find_mimetype_plugin(mimetype, url, mode="r", read_directory_only=False, opts=None):
     """Return plugin for given file type."""
-    _name: str = '{}.{}'.format(__name__, find_mimetype_plugin.__name__)
     if opts is None:
         opts = {}
     from .. import plugins
@@ -68,16 +67,16 @@ def find_mimetype_plugin(mimetype, url, mode="r", read_directory_only=False, opt
         except AttributeError:
             pass
     for pname, ptype, pclass in plugins['archive']:
-        logger.debug("{}: compare '{}' to {}".format(
-            _name, mimetype, pclass.mimetypes))
+        logger.debug("imagedata.archive.find_mimetype_plugin: compare '{}' to {}".format(
+            mimetype, pclass.mimetypes))
         if mimetype in pclass.mimetypes:
-            logger.debug("{}: {}, mode: {}".format(
-                _name, ptype, mode))
+            logger.debug("imagedata.archives.find_mimetype_plugin: {}, mode: {}".format(
+                ptype, mode))
             return pclass(url=url, transport=transport, mode=mode, opts=opts)
     # if os.path.isfile(_path):
     # if os.path.exists(_path):
     if urldict.scheme == "file":
-        logger.debug("{}: filesystem".format(_name))
+        logger.debug("imagedata.archives.find_mimetype_plugin: filesystem")
         try:
             return find_plugin('filesystem', url, mode, opts=opts)
         except ArchivePluginNotFound:

{imagedata-3.6.0 → imagedata-3.6.0.dev12}/src/imagedata/archives/filesystemarchive.py

@@ -64,17 +64,16 @@ class FilesystemArchive(AbstractArchive, ABC):
         super(FilesystemArchive, self).__init__(
             self.name, self.description,
             self.authors, self.version, self.url, self.mimetypes)
-        _name: str = '{}.{}'.format(__name__, self.__init__.__name__)
-        logger.debug("{}: url: {}".format(_name, url))
+        logger.debug("FilesystemArchive.__init__ url: {}".format(url))
 
         self._parse_url(url)
         self._get_transport(transport, url, mode, read_directory_only)
         self.__mode = mode
 
-        logger.debug("{}: {}".format(_name, type(self.transport)))
+        logger.debug("FilesystemArchive __init__: {}".format(type(self.transport)))
 
-        logger.debug("{}: path: {}".format(_name, self.__path))
-        logger.debug("{}: open zipfile mode {}".format(_name, self.__mode))
+        logger.debug("FilesystemArchive path: {}".format(self.__path))
+        logger.debug("FilesystemArchive open zipfile mode %s" % self.__mode)
 
         self._set_basedir(mode)
 
@@ -102,7 +101,6 @@ class FilesystemArchive(AbstractArchive, ABC):
         access the parent directory.
         """
 
-        _name: str = '{}.{}'.format(__name__, self._get_transport.__name__)
         if transport is not None:
             self.transport = transport
             return
@@ -110,9 +108,8 @@ class FilesystemArchive(AbstractArchive, ABC):
             raise ValueError('url not given')
 
         url_tuple = urllib.parse.urlsplit(url, scheme='file')
-        logger.debug('{}: scheme: {}, netloc: {}'.format(
-                     _name, url_tuple.scheme, url_tuple.path
-        ))
+        logger.debug('FilesystemArchive._get_transport: scheme: %s, netloc: %s' %
+                     (url_tuple.scheme, url_tuple.path))
 
         try:
             self.transport = Transport(
@@ -134,30 +131,29 @@ class FilesystemArchive(AbstractArchive, ABC):
     def _set_basedir(self, mode):
         # If the URL refers to a single file, let directory_name refer to the
         # directory and basename to the file
-        _name: str = '{}.{}'.format(__name__, self._set_basedir.__name__)
-        logger.debug("{}: verify : {}".format(_name, self.__path))
+        logger.debug("FilesystemArchive __init__ verify : {}".format(self.__path))
         if mode[0] == 'r' and self.transport.isfile(self.__path):
             self.__dirname = os.path.dirname(self.__path)
             _basename = os.path.basename(self.__path)
             if len(_basename):
                 self.__basename = _basename
-            logger.debug("{}: directory_name : {}".format(_name, self.__dirname))
-            logger.debug("{}: basename: {}".format(_name, self.__basename))
+            logger.debug("FilesystemArchive __init__ directory_name : {}".format(self.__dirname))
+            logger.debug("FilesystemArchive __init__ basename: {}".format(self.__basename))
             return
         elif mode[0] == 'w' and not self.transport.exists(self.__path):
             self.__dirname = os.path.dirname(self.__path)
             _basename = os.path.basename(self.__path)
             if len(_basename):
                 self.__basename = _basename
-            logger.debug("{}: directory_name : {}".format(_name, self.__dirname))
-            logger.debug("{}: basename: {}".format(_name, self.__basename))
+            logger.debug("FilesystemArchive __init__ directory_name : {}".format(self.__dirname))
+            logger.debug("FilesystemArchive __init__ basename: {}".format(self.__basename))
             return
 
         # The URL refers to a directory. Let directory_name refer to the directory
         self.__dirname = self.__path
         self.__basename = None
-        logger.debug("{}: scan directory_name : {}".format(_name, self.__dirname))
-        logger.debug("{}: scan basename: {}".format(_name, self.__basename))
+        logger.debug("FilesystemArchive __init__ scan directory_name : {}".format(self.__dirname))
+        logger.debug("FilesystemArchive __init__ scan basename: {}".format(self.__basename))
 
     def use_query(self):
         """Does the plugin need the ?query part of the url?"""
@@ -398,13 +394,12 @@ class FilesystemArchive(AbstractArchive, ABC):
             ReadOnlyError: when the archive is read-only.
             WriteOnFile: when attempting to write a file to a file.
         """
-        _name: str = '{}.{}'.format(__name__, self.writedata.__name__)
         if self.__mode[0] == 'r':
             raise ReadOnlyError("Archive is read-only.")
         if len(self.__basename) > 0:
             raise WriteOnFile("Do not know how to write a file to a file.")
         fname = os.path.join(self.__dirname, filename)
-        logger.debug("{}: fname {}".format(_name, fname))
+        logger.debug("writedata: fname {}".format(fname))
         with self.transport.open(fname, 'wb') as f:
             f.write(data)
 
@@ -457,9 +452,8 @@ class FilesystemArchive(AbstractArchive, ABC):
     def __enter__(self):
         """Enter context manager.
         """
-        _name: str = '{}.{}'.format(__name__, self.__enter__.__name__)
-        logger.debug("{}: {} mode {}".format(
-            _name, type(self.transport), self.__mode))
+        logger.debug("FilesystemArchive __enter__: {} mode {}".format(
+            type(self.transport), self.__mode))
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):

{imagedata-3.6.0 → imagedata-3.6.0.dev12}/src/imagedata/archives/zipfilearchive.py

@@ -59,21 +59,18 @@ class WriteFileIO(io.FileIO):
 
     def close(self):
         """Close file, copy it to archive, then delete local file."""
-        _name: str = '{}.{}'.format(__name__, self.close.__name__)
-        logger.debug("{}:".format(_name))
+        logger.debug("ZipfileArchive.WriteFileIO.close:")
         ret = super(WriteFileIO, self).close()
         if isinstance(self.__local_file, str):
             self.__archive.write(self.__local_file, self.__filename)
             os.remove(self.__local_file)
         else:
             self.__local_file.close()
-            logger.debug("{}: zip {} as {}".format(
-                _name, self.__local_file.name, self.__filename)
-            )
+            logger.debug("ZipfileArchive.WriteFileIO.close: zip %s as %s" %
+                         (self.__local_file.name, self.__filename))
             self.__archive.write(self.__local_file.name, self.__filename)
-            logger.debug("{}: remove {}".format(
-                _name, self.__local_file.name)
-            )
+            logger.debug("ZipfileArchive.WriteFileIO.close: remove %s" %
+                         self.__local_file.name)
             os.remove(self.__local_file.name)
         return ret
 
@@ -121,9 +118,8 @@ class ZipfileArchive(AbstractArchive, ABC):
         super(ZipfileArchive, self).__init__(
             self.name, self.description,
             self.authors, self.version, self.url, self.mimetypes)
-        _name: str = '{}.{}'.format(__name__, self.__init__.__name__)
         self.opts = opts
-        logger.debug("{}: url: {}".format(_name, url))
+        logger.debug("ZipfileArchive.__init__ url: {}".format(url))
         if os.name == 'nt' and fnmatch.fnmatch(url, '[A-Za-z]:\\*'):
             # Windows: Parse without x:, then reattach drive letter
             urldict = urllib.parse.urlsplit(url[2:], scheme="file")
@@ -143,9 +139,8 @@ class ZipfileArchive(AbstractArchive, ABC):
             # self.__path: zipfile name
             try:
                 netloc = urldict.netloc + self.__path
-                logger.debug('{}: scheme: {}, netloc: {}'.format(
-                    _name, urldict.scheme, netloc
-                ))
+                logger.debug('ZipfileArchive.__init__: scheme: %s, netloc: %s' %
+                             (urldict.scheme, netloc))
                 self.transport = Transport(
                     urldict.scheme,
                     netloc=urldict.netloc,
@@ -157,19 +152,19 @@ class ZipfileArchive(AbstractArchive, ABC):
         self.__mode = mode
         self.__files = {}
 
-        logger.debug("{}: path: {}".format(_name, self.__path))
+        logger.debug("ZipfileArchive path: {}".format(self.__path))
         self.__fp = self.transport.open(
             self.__path, mode=self.__mode + "b")
-        logger.debug("{}: self.__fp: {}".format(_name, type(self.__fp)))
-        logger.debug("{}: open zipfile mode {}".format(_name, self.__mode))
+        logger.debug("ZipfileArchive self.__fp: {}".format(type(self.__fp)))
+        logger.debug("ZipfileArchive open zipfile mode %s" % self.__mode)
         self.__archive = zipfile.ZipFile(
             self.__fp,
             mode=self.__mode,
             compression=zipfile.ZIP_DEFLATED)
         # Extract the archive
         self.__tmpdir = tempfile.mkdtemp()
-        logger.debug("{}: Extract zipfile {} to {}".format(
-            _name, self.__archive, self.__tmpdir))
+        logger.debug("Extract zipfile {} to {}".format(
+            self.__archive, self.__tmpdir))
         # Get filelist in self.__files
         for fname in self.__archive.namelist():
             try:
@@ -177,7 +172,7 @@ class ZipfileArchive(AbstractArchive, ABC):
             except AttributeError:
                 _is_dir = fname[-1] == '/'
             except Exception as e:
-                logger.error('{}: {}'.format(_name, e))
+                logger.error('ZipfileArchive: {}'.format(e))
                 raise
             if not _is_dir:
                 self.__files[fname] = Member(fname,
@@ -201,7 +196,6 @@ class ZipfileArchive(AbstractArchive, ABC):
         Raises:
             FileNotFoundError: When no matching file is found.
         """
-        _name: str = '{}.{}'.format(__name__, self.getnames.__name__)
         if files is not None and issubclass(type(files), str):
             wanted_files = [files]
         else:
@@ -210,21 +204,21 @@ class ZipfileArchive(AbstractArchive, ABC):
                 (issubclass(type(wanted_files), list) and (
                         len(wanted_files) == 0 or
                         len(wanted_files) > 0 and wanted_files[0] == '*')):
-            logger.debug('{}: found files {}'.format(_name, len(self.__files)))
+            logger.debug('ZipfileArchive.getnames: found files {}'.format(len(self.__files)))
             return sorted(self.__files.keys())
         else:
             filelist = list()
             for filename in self.__files:
-                logger.debug('{}: member {}'.format(_name, filename))
+                logger.debug('ZipfileArchive.getnames: member {}'.format(filename))
                 for required_filename in wanted_files:
-                    logger.debug('{}: required {}'.format(_name, required_filename))
+                    logger.debug('ZipfileArchive.getnames: required {}'.format(required_filename))
                     if required_filename[-1] == '/':
                         required_filename = required_filename[:-1]
                     if fnmatch.fnmatchcase(filename, required_filename):
                         filelist.append(filename)
                     elif fnmatch.fnmatchcase(filename, required_filename + '/*'):
                         filelist.append(filename)
-            logger.debug('{}: found files {}'.format(_name, len(filelist)))
+            logger.debug('ZipfileArchive.getnames: found files {}'.format(len(filelist)))
             if len(filelist) < 1:
                 raise FileNotFoundError('No such file: {}'.format(wanted_files))
             return filelist
@@ -274,11 +268,10 @@ class ZipfileArchive(AbstractArchive, ABC):
             PermissionError: When archive is read-only.
         """
 
-        _name: str = '{}.{}'.format(__name__, self.open.__name__)
         if isinstance(member, str):
             member = Member(member)
-        logger.debug('{}: mode {}'.format(_name, mode))
-        logger.debug('{}: member {}'.format(_name, member.filename))
+        logger.debug('ZipfileArchive.open: mode %s' % mode)
+        logger.debug('ZipfileArchive.open: member %s' % member.filename)
         if mode[0] == 'r':
             if member.filename not in self.__files:
                 raise FileNotFoundError(
@@ -298,7 +291,8 @@ class ZipfileArchive(AbstractArchive, ABC):
             if ext >= 0:
                 suffix = member.filename[ext:]
             local_file = tempfile.NamedTemporaryFile(suffix=suffix, delete=False)
-            logger.debug('{}: mode {} file {}'.format(_name, mode, local_file))
+            logger.debug('ZipfileArchive.open: mode %s file %s' % (
+                mode, local_file))
             fh = WriteFileIO(self.__archive, member, local_file)
             # Update info on member file
             self.__files[member.filename] = Member(member.filename,
@@ -433,17 +427,16 @@ class ZipfileArchive(AbstractArchive, ABC):
             local_file: named local file
             filename: filename in the archive
         """
-        _name: str = '{}.{}'.format(__name__, self.add_localfile.__name__)
         if self.__mode[0] == 'r':
             raise PermissionError(
                 'Cannot write on an archive opened for read')
         member = Member(filename, info={'unpacked': True},
                         local_file=local_file)
         self.__archive.write(local_file, arcname=filename)
-        logger.debug('{}: local {} as {}'.format(
-            _name, local_file, filename))
+        logger.debug('ZipfileArchive.add_localfile: local {} as {}'.format(
+            local_file, filename))
         self.__files[filename] = member
-        logger.debug('{}: {}'.format(_name, self.__archive.namelist()))
+        logger.debug('{}'.format(self.__archive.namelist()))
 
     def writedata(self, filename, data):
         """Write data to a named file in the archive.
@@ -462,11 +455,10 @@ class ZipfileArchive(AbstractArchive, ABC):
     def close(self):
         """Close zip file.
         """
-        _name: str = '{}.{}'.format(__name__, self.close.__name__)
         self.__archive.close()
         self.__fp.close()
         shutil.rmtree(self.__tmpdir)
-        logger.debug('{}: {}'.format(_name, self.__tmpdir))
+        logger.debug('ZipfileArchive.close: {}'.format(self.__tmpdir))
         self.transport.close()
 
     def is_file(self, member):
@@ -511,14 +503,12 @@ class ZipfileArchive(AbstractArchive, ABC):
     def __enter__(self):
         """Enter context manager.
         """
-        _name: str = '{}.{}'.format(__name__, self.__enter__.__name__)
-        logger.debug("{}: {} mode {}".format(
-            _name, type(self.transport), self.__mode))
+        logger.debug("ZipfileArchive __enter__: {} mode {}".format(
+            type(self.transport), self.__mode))
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         """Leave context manager, cleaning up any open files.
         """
-        _name: str = '{}.{}'.format(__name__, self.__exit__.__name__)
-        logger.debug('{}:'.format(_name))
+        logger.debug('ZipfileArchive.__exit__:')
         self.close()

{imagedata-3.6.0 → imagedata-3.6.0.dev12}/src/imagedata/collections.py

@@ -9,6 +9,8 @@ The Cohort class is a collection of Patient objects.
 """
 
 from datetime import datetime, date, time
+from collections import UserDict
+import logging
 import argparse
 from pathlib import Path
 
@@ -16,6 +18,8 @@ from .series import Series
 from .readdata import read as r_read
 from .formats import UnknownInputError
 
+logger = logging.getLogger(__name__)
+
 
 def _get_attribute(_data, _attr):
     # Get attribute from first instance in _data

{imagedata-3.6.0 → imagedata-3.6.0.dev12}/src/imagedata/formats/__init__.py

@@ -3,11 +3,14 @@
 Standard plugins provides support for DICOM and Nifti image file formats.
 """
 
-# Copyright (c) 2013-2024 Erling Andersen, Haukeland University Hospital, Bergen, Norway
+# Copyright (c) 2013-2022 Erling Andersen, Haukeland University Hospital, Bergen, Norway
 
+import logging
 import sys
+
 import numpy as np
 
+logger = logging.getLogger(__name__)
 
 (SORT_ON_SLICE,
  SORT_ON_TAG) = range(2)

{imagedata-3.6.0 → imagedata-3.6.0.dev12}/src/imagedata/formats/abstractplugin.py

@@ -107,16 +107,15 @@ class AbstractPlugin(object, metaclass=ABCMeta):
                 - si[tag,slice,rows,columns]: numpy array
         """
 
-        _name: str = '{}.{}'.format(__name__, self.read.__name__)
         hdr = Header()
         hdr.input_format = self.name
         hdr.input_order = input_order
 
         # image_list: list of tuples (hdr,si)
-        logger.debug("{}: sources {}".format(_name, sources))
+        logger.debug("AbstractPlugin.read: sources {}".format(sources))
         image_list = list()
         for source in sources:
-            logger.debug("{}: source: {} {}".format(_name, type(source), source))
+            logger.debug("AbstractPlugin.read: source: {} {}".format(type(source), source))
             archive: AbstractArchive = source['archive']
             scan_files = source['files']
             if scan_files is None or len(scan_files) == 0:
@@ -130,16 +129,16 @@ class AbstractPlugin(object, metaclass=ABCMeta):
             #     scan_files = archive.getnames()
             # logger.debug("AbstractPlugin.read: scan_files {}".format(scan_files))
             for file_handle in archive.getmembers(scan_files):
-                logger.debug("{}: file_handle {}".format(_name, file_handle.filename))
+                logger.debug("AbstractPlugin.read: file_handle {}".format(file_handle.filename))
                 if self._need_local_file():
-                    logger.debug("{}: need local file {}".format(
-                        _name, file_handle.filename))
+                    logger.debug("AbstractPlugin.read: need local file {}".format(
+                        file_handle.filename))
                     f = archive.to_localfile(file_handle)
-                    logger.debug("{}: local file {}".format(_name, f))
+                    logger.debug("AbstractPlugin.read: local file {}".format(f))
                     info, si = self._read_image(f, opts, hdr)
                 else:
                     f = archive.open(file_handle, mode='rb')
-                    logger.debug("{}: file {}".format(_name, f))
+                    logger.debug("AbstractPlugin.read: file {}".format(f))
                     try:
                         info, si = self._read_image(f, opts, hdr)
                     except NotImageError:
@@ -153,10 +152,10 @@ class AbstractPlugin(object, metaclass=ABCMeta):
             raise ValueError('No image data read')
         info, si = image_list[0]
         self._reduce_shape(si)
-        logger.debug('{}: reduced si {}'.format(_name, si.shape))
+        logger.debug('AbstractPlugin.read: reduced si {}'.format(si.shape))
         shape = (len(image_list),) + si.shape
         dtype = si.dtype
-        logger.debug('{}: shape {}'.format(_name, shape))
+        logger.debug('AbstractPlugin.read: shape {}'.format(shape))
         si = np.zeros(shape, dtype)
         i = 0
         for info, img in image_list:
@@ -165,31 +164,31 @@ class AbstractPlugin(object, metaclass=ABCMeta):
             else:
                 si[i] = img
             i += 1
-        logger.debug('{}: si {}'.format(_name, si.shape))
+        logger.debug('AbstractPlugin.read: si {}'.format(si.shape))
 
         # Simplify shape
         self._reduce_shape(si)
-        logger.debug('{}: reduced si {}'.format(_name, si.shape))
+        logger.debug('AbstractPlugin.read: reduced si {}'.format(si.shape))
 
         _shape = si.shape
-        logger.debug('{}: _shape {}'.format(_name, _shape))
+        logger.debug('AbstractPlugin.read: _shape {}'.format(_shape))
         _ndim = len(_shape)
         nz = 1
         if _ndim > 2:
             nz = _shape[-3]
-        logger.debug('{}: slices {}'.format(_name, nz))
+        logger.debug('AbstractPlugin.read: slices {}'.format(nz))
 
-        logger.debug('{}: calling _set_tags'.format(_name))
+        logger.debug('AbstractPlugin.read: calling _set_tags')
         self._set_tags(image_list, hdr, si)
         # logger.debug('AbstractPlugin.read: return  _set_tags: {}'.format(hdr))
 
-        logger.info("{}: Data shape read: {}".format(_name, shape_to_str(si.shape)))
+        logger.info("Data shape read: {}".format(shape_to_str(si.shape)))
 
         # Add any DICOM template
         if pre_hdr is not None:
             hdr.update(pre_hdr)
 
-        logger.debug('{}: hdr {}'.format(_name, hdr))
+        logger.debug('AbstractPlugin.read: hdr {}'.format(hdr))
         return {0: hdr}, {0: si}
 
     def _need_local_file(self):
@@ -489,8 +488,8 @@ class AbstractPlugin(object, metaclass=ABCMeta):
         flipud: Whether matrix is transposed
         """
 
-        _name: str = '{}.{}'.format(__name__, self._reorder_to_dicom.__name__)
-        logger.debug('{}: shape in {}'.format(_name, data.shape))
+        logger.debug('AbstractPlugin._reorder_to_dicom: shape in {}'.format(
+            data.shape))
         if data.ndim == 5:
             rows, columns, slices, tags, d5 = data.shape
             if flipud:
@@ -546,7 +545,8 @@ class AbstractPlugin(object, metaclass=ABCMeta):
             #    si[:] = data[:]
         else:
             raise ValueError('Dimension %d is not implemented' % data.ndim)
-        logger.debug('{}: shape out {}'.format(_name, si.shape))
+        logger.debug('AbstractPlugin._reorder_to_dicom: shape out {}'.format(
+            si.shape))
         return si
 
     def _reorder_from_dicom(self, data, flip=False, flipud=False):
@@ -574,8 +574,7 @@ class AbstractPlugin(object, metaclass=ABCMeta):
         flipud: Whether matrix is transposed
         """
 
-        _name: str = '{}.{}'.format(__name__, self._reorder_from_dicom.__name__)
-        logger.debug('{}: shape in {}'.format(_name, data.shape))
+        logger.debug('AbstractPlugin._reorder_from_dicom: shape in {}'.format(data.shape))
         if data.ndim == 5:
             d5, tags, slices, rows, columns = data.shape
             if flipud:
@@ -627,7 +626,8 @@ class AbstractPlugin(object, metaclass=ABCMeta):
             #    si[:] = data[:]
         else:
             raise ValueError('Dimension %d is not implemented' % data.ndim)
-        logger.debug('{}: shape out {}'.format(_name, si.shape))
+        logger.debug('AbstractPlugin._reorder_from_dicom: shape out {}'.format(
+            si.shape))
         return si
 
     @staticmethod