python-dwca-reader 0.16.2__py3-none-any.whl → 0.16.3__py3-none-any.whl

dwca/read.py

@@ -14,7 +14,12 @@ from pandas.io.parsers import TextFileReader
 
 import dwca.vendor
 from dwca.descriptors import ArchiveDescriptor, DataFileDescriptor, shorten_term
-from dwca.exceptions import RowNotFound, InvalidArchive, InvalidSimpleArchive, NotADataFile
+from dwca.exceptions import (
+    RowNotFound,
+    InvalidArchive,
+    InvalidSimpleArchive,
+    NotADataFile,
+)
 from dwca.files import CSVDataFile
 from dwca.helpers import remove_tree
 from dwca.rows import CoreRow
@@ -72,7 +77,7 @@ class DwCAReader(object):
 
     default_metadata_filename = "EML.xml"
     default_metafile_name = "meta.xml"
-    source_metadata_directory = 'dataset'
+    source_metadata_directory = "dataset"
 
     def __enter__(self):
         return self
@@ -80,7 +85,13 @@ class DwCAReader(object):
     def __exit__(self, exc_type, exc_value, exc_traceback):
         self.close()
 
-    def __init__(self, path: str, extensions_to_ignore: List[str] = None, tmp_dir: str = None) -> None:
+    def __init__(
+        self,
+        path: str,
+        extensions_to_ignore: List[str] = None,
+        tmp_dir: str = None,
+        skip_metadata: bool = False,
+    ) -> None:
         """Open the Darwin Core Archive."""
         if extensions_to_ignore is None:
             extensions_to_ignore = []
@@ -92,7 +103,9 @@ class DwCAReader(object):
         #: The path to the Darwin Core Archive file, as passed to the constructor.
         self.archive_path = path  # type: str
 
-        if os.path.isdir(self.archive_path):  # Archive is a (directly readable) directory
+        if os.path.isdir(
+            self.archive_path
+        ):  # Archive is a (directly readable) directory
             self._working_directory_path = self.archive_path
             self._directory_to_clean = None  # type: Optional[str]
         else:  # Archive is zipped/tgzipped, we have to extract it first.
@@ -104,15 +117,18 @@ class DwCAReader(object):
         self._metafile_handle = None
         try:
             self._metafile_handle = self.open_included_file(self.default_metafile_name)
-            self.descriptor = ArchiveDescriptor(self._metafile_handle.read(),
-                                                files_to_ignore=extensions_to_ignore)
+            self.descriptor = ArchiveDescriptor(
+                self._metafile_handle.read(), files_to_ignore=extensions_to_ignore
+            )
         except IOError as exc:
             if exc.errno == ENOENT:
                 pass
 
         #: A :class:`xml.etree.ElementTree.Element` instance containing the (scientific) metadata
-        #: of the archive, or `None` if the archive has no metadata.
-        self.metadata = self._parse_metadata_file()  # type: Optional[Element]
+        #: of the archive, or `None` if the archive has no metadata or if the `skip_metadata` parameter is True.
+        self.metadata = None  # type: Optional[Element]
+        if not skip_metadata:
+            self.metadata = self._parse_metadata_file()  # type: Optional[Element]
 
         #: If the archive contains source-level metadata (typically, GBIF downloads), this is a dict such as::
         #:
@@ -122,23 +138,33 @@ class DwCAReader(object):
         #: See :doc:`gbif_results` for more details.
         self.source_metadata = self._get_source_metadata()  # type: Dict[str, Element]
 
-        if self.descriptor:  # We have an Archive descriptor that we can use to access data files.
+        if (
+            self.descriptor
+        ):  # We have an Archive descriptor that we can use to access data files.
             #: An instance of :class:`dwca.files.CSVDataFile` for the core data file.
-            self.core_file = CSVDataFile(self._working_directory_path, self.descriptor.core)  # type: CSVDataFile
+            self.core_file = CSVDataFile(
+                self._working_directory_path, self.descriptor.core
+            )  # type: CSVDataFile
 
             #: A list of :class:`dwca.files.CSVDataFile`, one entry for each extension data file , sorted by order of
             #: appearance in the Metafile (or an empty list if the archive doesn't use extensions).
-            self.extension_files = [CSVDataFile(work_directory=self._working_directory_path,
-                                                file_descriptor=d)
-                                    for d in self.descriptor.extensions]  # type: List[CSVDataFile]
+            self.extension_files = [
+                CSVDataFile(
+                    work_directory=self._working_directory_path, file_descriptor=d
+                )
+                for d in self.descriptor.extensions
+            ]  # type: List[CSVDataFile]
         else:  # Archive without descriptor, we'll have to find and inspect the data file
             try:
                 datafile_name = self._is_valid_simple_archive()
                 descriptor = DataFileDescriptor.make_from_file(
-                    os.path.join(self._working_directory_path, datafile_name))
+                    os.path.join(self._working_directory_path, datafile_name)
+                )
 
-                self.core_file = CSVDataFile(work_directory=self._working_directory_path,
-                                             file_descriptor=descriptor)
+                self.core_file = CSVDataFile(
+                    work_directory=self._working_directory_path,
+                    file_descriptor=descriptor,
+                )
                 self.extension_files = []
             except InvalidSimpleArchive:
                 msg = "No Metafile was found, but the archive contains multiple files/directories."
@@ -146,14 +172,17 @@ class DwCAReader(object):
 
     def _get_source_metadata(self) -> Dict[str, Element]:
         source_metadata = {}  # type: Dict[str, Element]
-        source_metadata_dir = os.path.join(self._working_directory_path, self.source_metadata_directory)
+        source_metadata_dir = os.path.join(
+            self._working_directory_path, self.source_metadata_directory
+        )
 
         if os.path.isdir(source_metadata_dir):
             for f in os.listdir(source_metadata_dir):
                 if os.path.isfile(os.path.join(source_metadata_dir, f)):
                     dataset_key = os.path.splitext(f)[0]
                     source_metadata[dataset_key] = self._parse_xml_included_file(
-                        os.path.join(self.source_metadata_directory, f))
+                        os.path.join(self.source_metadata_directory, f)
+                    )
 
         return source_metadata
 
@@ -192,23 +221,27 @@ class DwCAReader(object):
             not supported in case the value returned by `pandas.read_csv()` is a `TextFileReader` (e.g. when using
             `chunksize` or `iterator=True`).
         """
-        datafile_descriptor = self.get_descriptor_for(relative_path)  # type: DataFileDescriptor
+        datafile_descriptor = self.get_descriptor_for(
+            relative_path
+        )  # type: DataFileDescriptor
 
         if not dwca.vendor._has_pandas:
             raise ImportError("Pandas is missing.")
 
         from pandas import read_csv
 
-        kwargs['delimiter'] = datafile_descriptor.fields_terminated_by
-        kwargs['skiprows'] = datafile_descriptor.lines_to_ignore
-        kwargs['header'] = None
-        kwargs['names'] = datafile_descriptor.short_headers
+        kwargs["delimiter"] = datafile_descriptor.fields_terminated_by
+        kwargs["skiprows"] = datafile_descriptor.lines_to_ignore
+        kwargs["header"] = None
+        kwargs["names"] = datafile_descriptor.short_headers
 
-        df_or_textreader = read_csv(self.absolute_temporary_path(relative_path), **kwargs)
+        df_or_textreader = read_csv(
+            self.absolute_temporary_path(relative_path), **kwargs
+        )
 
         # Add a column for default values, if present in the file descriptor
         for field in datafile_descriptor.fields:
-            field_default_value = field['default']
+            field_default_value = field["default"]
             if field_default_value is not None:
                 if isinstance(df_or_textreader, TextFileReader):
                     # I don't see how to assign default values to a TextFileReader, so
@@ -220,7 +253,7 @@ class DwCAReader(object):
                         "the archive."
                     )
 
-                df_or_textreader[shorten_term(field['term'])] = field_default_value
+                df_or_textreader[shorten_term(field["term"])] = field_default_value
 
         return df_or_textreader
 
@@ -249,7 +282,9 @@ class DwCAReader(object):
             ids = temp_ids.keys()
 
             for extension in self.extension_files:
-                coreid_index = dict((k, v.tolist()) for k, v in extension.coreid_index.items())
+                coreid_index = dict(
+                    (k, v.tolist()) for k, v in extension.coreid_index.items()
+                )
                 for id in ids:
                     coreid_index.pop(id, None)
                 indexes[extension.file_descriptor.file_location] = coreid_index
@@ -311,7 +346,7 @@ class DwCAReader(object):
             - The position is often an appropriate way to unambiguously identify a core row in a DwCA.
 
         """
-        for (i, row) in enumerate(self):
+        for i, row in enumerate(self):
             if i == position:
                 return row
 
@@ -340,7 +375,9 @@ class DwCAReader(object):
             File existence is not tested.
 
         """
-        return os.path.abspath(os.path.join(self._working_directory_path, relative_path))
+        return os.path.abspath(
+            os.path.join(self._working_directory_path, relative_path)
+        )
 
     def get_descriptor_for(self, relative_path: str) -> DataFileDescriptor:
         """Return a descriptor for the data file located at relative_path.
@@ -365,7 +402,6 @@ class DwCAReader(object):
         raise NotADataFile("{fn} is not a data file".format(fn=relative_path))
 
     def _is_valid_simple_archive(self) -> str:
-
         # If the working dir appear to contains a valid simple darwin core archive
         # (one single data file + possibly some metadata), returns the name of the data file.
         #
@@ -396,7 +432,7 @@ class DwCAReader(object):
         """Load the archive (scientific) Metadata file, parse it with\
         ElementTree and return its content (or `None` if the archive has no metadata).
 
-        :raises: :class:`dwca.exceptions.InvalidArchive` if the archive references an non-existent
+        :raises: :class:`dwca.exceptions.InvalidArchive` if the archive references a non-existent
         metadata file.
         """
         # If the archive has descriptor, look for the metadata filename there.
@@ -407,14 +443,18 @@ class DwCAReader(object):
                 return self._parse_xml_included_file(filename)
             except IOError as exc:
                 if exc.errno == ENOENT:  # File not found
-                    msg = "{} is referenced in the archive descriptor but missing.".format(filename)
+                    msg = "{} is referenced in the archive descriptor but missing.".format(
+                        filename
+                    )
                     raise InvalidArchive(msg)
 
         else:  # Otherwise, the metadata file has to be named 'EML.xml'
             try:
                 return self._parse_xml_included_file(self.default_metadata_filename)
             except IOError as exc:
-                if exc.errno == ENOENT:  # File not found, this is an archive without metadata
+                if (
+                    exc.errno == ENOENT
+                ):  # File not found, this is an archive without metadata
                     return None
 
         assert False  # For MyPy, see: https://github.com/python/mypy/issues/4223#issuecomment-342865133
@@ -428,7 +468,7 @@ class DwCAReader(object):
             # In that case, we work with a stripped string instead.
             # Note that this method cannot be generalized because it won't work well with encoding specified in the xml
             # tag. This is why we're only choosing it in case of error
-            data_as_string = self.open_included_file(relative_path, 'r').read()
+            data_as_string = self.open_included_file(relative_path, "r").read()
             return ET.fromstring(data_as_string.strip())
 
     def _unzip_or_untar(self) -> str:
@@ -444,14 +484,16 @@ class DwCAReader(object):
         try:
             # Security note: with Python < 2.7.4, a zip file may be able to write outside of the
             # directory using absolute paths, parent (..) path, ... See note in ZipFile.extract doc
-            zipfile.ZipFile(self.archive_path, 'r').extractall(tmp_dir)
+            zipfile.ZipFile(self.archive_path, "r").extractall(tmp_dir)
         except zipfile.BadZipfile:
             # Doesn't look like a valid zip, let's see if it's a tar archive (possibly compressed)
             try:
                 # TODO: Once we only support Python 3.12+, we should pass the filter="data" argument to extractall()
-                tarfile.open(self.archive_path, 'r:*').extractall(tmp_dir)
+                tarfile.open(self.archive_path, "r:*").extractall(tmp_dir)
             except tarfile.ReadError:
-                raise InvalidArchive("The archive cannot be read. Is it a .zip or .tgz file?")
+                raise InvalidArchive(
+                    "The archive cannot be read. Is it a .zip or .tgz file?"
+                )
 
         return tmp_dir
 
@@ -487,7 +529,7 @@ class DwCAReader(object):
             extension_file.close()
         if self._metafile_handle:
             self._metafile_handle.close()
-        
+
         if self._directory_to_clean:
             remove_tree(self._directory_to_clean)
 
@@ -495,7 +537,7 @@ class DwCAReader(object):
         """Return `True` if the Core file of the archive contains the `term_url` term."""
         return term_url in self.core_file.file_descriptor.terms
 
-    def __iter__(self) -> 'DwCAReader':
+    def __iter__(self) -> "DwCAReader":
         self._corefile_pointer = 0
         return self
 

dwca/rows.py

@@ -16,36 +16,45 @@ class Row(object):
 
     # Common ground for __str__ between subclasses
     def _build_str(self, source_str, id_str):
-        txt = ("--\n"
-               "Rowtype: {rowtype}\n"
-               "Position: {position}\n"
-               "Source: {source_str}\n"
-               "{id_row}\n"
-               "Reference extension rows: {extension_flag}\n"
-               "Reference source metadata: {source_metadata_flag}\n"
-               "Data: {data}\n"
-               "--\n")
-
-        extension_flag = "Yes" if (hasattr(self, 'extensions') and (len(self.extensions) > 0)) else "No"
-
-        if hasattr(self, 'source_metadata') and (self.source_metadata is not None):
-            source_metadata_flag = 'Yes'
+        txt = (
+            "--\n"
+            "Rowtype: {rowtype}\n"
+            "Position: {position}\n"
+            "Source: {source_str}\n"
+            "{id_row}\n"
+            "Reference extension rows: {extension_flag}\n"
+            "Reference source metadata: {source_metadata_flag}\n"
+            "Data: {data}\n"
+            "--\n"
+        )
+
+        extension_flag = (
+            "Yes"
+            if (hasattr(self, "extensions") and (len(self.extensions) > 0))
+            else "No"
+        )
+
+        if hasattr(self, "source_metadata") and (self.source_metadata is not None):
+            source_metadata_flag = "Yes"
         else:
-            source_metadata_flag = 'No'
-
-        return txt.format(rowtype=self.rowtype,
-                          position=self.position,
-                          source_str=source_str,
-                          data=self.data,
-                          id_row=id_str,
-                          extension_flag=extension_flag,
-                          source_metadata_flag=source_metadata_flag)
-
-    def __init__(self, csv_line: str, position: int, datafile_descriptor: DataFileDescriptor) -> None:
-
+            source_metadata_flag = "No"
+
+        return txt.format(
+            rowtype=self.rowtype,
+            position=self.position,
+            source_str=source_str,
+            data=self.data,
+            id_row=id_str,
+            extension_flag=extension_flag,
+            source_metadata_flag=source_metadata_flag,
+        )
+
+    def __init__(
+        self, csv_line: str, position: int, datafile_descriptor: DataFileDescriptor
+    ) -> None:
         #: An instance of :class:`dwca.descriptors.DataFileDescriptor` describing the originating
         #: data file.
-        self.descriptor = datafile_descriptor  # type: DataFileDescriptor 
+        self.descriptor = datafile_descriptor  # type: DataFileDescriptor
 
         #: The row position/index (starting at 0) in the source data file. This can be used, for example with
         #: :meth:`dwca.read.DwCAReader.get_corerow_by_position` or :meth:`dwca.files.CSVDataFile.get_row_by_position`.
@@ -59,10 +68,12 @@ class Row(object):
 
         # self.raw_fields is a list of the csv_line's content
         #:
-        self.raw_fields = csv_line_to_fields(csv_line,
-                                             line_ending=self.descriptor.lines_terminated_by,
-                                             field_ending=self.descriptor.fields_terminated_by,
-                                             fields_enclosed_by=self.descriptor.fields_enclosed_by)
+        self.raw_fields = csv_line_to_fields(
+            csv_line,
+            line_ending=self.descriptor.lines_terminated_by,
+            field_ending=self.descriptor.fields_terminated_by,
+            fields_enclosed_by=self.descriptor.fields_enclosed_by,
+        )
 
         # TODO: raw_fields is a new property: to test
 
@@ -84,18 +95,24 @@ class Row(object):
 
         for field_descriptor in self.descriptor.fields:
             try:
-                column_index = int(field_descriptor['index'])
+                column_index = int(field_descriptor["index"])
                 field_row_value = self.raw_fields[column_index]
             except TypeError:
                 # int() argument must be a string... We don't have an index for this field
                 field_row_value = None
             except IndexError:
-                msg = 'The descriptor references a non-existent field (index={i})'.format(i=column_index)
+                msg = (
+                    "The descriptor references a non-existent field (index={i})".format(
+                        i=column_index
+                    )
+                )
                 raise InvalidArchive(msg)
 
-            field_default_value = field_descriptor['default']
+            field_default_value = field_descriptor["default"]
 
-            self.data[field_descriptor['term']] = field_row_value or field_default_value or ''
+            self.data[field_descriptor["term"]] = (
+                field_row_value or field_default_value or ""
+            )
 
 
 class CoreRow(Row):
@@ -110,7 +127,9 @@ class CoreRow(Row):
         id_str = "Row id: " + str(self.id)
         return super(CoreRow, self)._build_str("Core file", id_str)
 
-    def __init__(self, csv_line: str, position: int, datafile_descriptor: DataFileDescriptor) -> None:
+    def __init__(
+        self, csv_line: str, position: int, datafile_descriptor: DataFileDescriptor
+    ) -> None:
         super(CoreRow, self).__init__(csv_line, position, datafile_descriptor)
 
         if self.descriptor.id_index is not None:
@@ -129,14 +148,14 @@ class CoreRow(Row):
         # provide some, but not for this row, it will be set to None).
         #
         # If this method is never called, the source_metadata attribute will not exist
-        field_name = 'http://rs.tdwg.org/dwc/terms/datasetID'
+        field_name = "http://rs.tdwg.org/dwc/terms/datasetID"
 
         #: Row-level metadata (if provided by the archive).
         #: This is a non-standard DwCA feature currently that we can sometimes encounter (in downloads from GBIF.org
         #: for example).
         self.source_metadata = None
 
-        if (archive_source_metadata and (field_name in self.data)):
+        if archive_source_metadata and (field_name in self.data):
             try:
                 self.source_metadata = archive_source_metadata[self.data[field_name]]
             except KeyError:
@@ -150,10 +169,13 @@ class CoreRow(Row):
         # type () -> List[ExtensionRow]
         """A list of :class:`.ExtensionRow` instances that relates to this Core row."""
         # We use lazy loading
-        if not hasattr(self, '_extensions'):
+        if not hasattr(self, "_extensions"):
             self._extensions = []
             for csv_file in self.extension_data_files:
-                [self._extensions.append(r) for r in csv_file.get_all_rows_by_coreid(self.id)]
+                [
+                    self._extensions.append(r)
+                    for r in csv_file.get_all_rows_by_coreid(self.id)
+                ]
 
         return self._extensions
 
@@ -161,8 +183,16 @@ class CoreRow(Row):
     # Should these 3 be factorized ? How ? Mixin ? Parent class ?
     def __key(self):
         """Return a tuple representing the row. Common ground between equality and hash."""
-        return (self.descriptor, self.id, self.data, self.extensions, self.source_metadata,
-                self.rowtype, self.raw_fields, self.position)
+        return (
+            self.descriptor,
+            self.id,
+            self.data,
+            self.extensions,
+            self.source_metadata,
+            self.rowtype,
+            self.raw_fields,
+            self.position,
+        )
 
     def __eq__(self, other):
         return self.__key() == other.__key()
@@ -185,7 +215,9 @@ class ExtensionRow(Row):
         id_str = "Core row id: " + str(self.core_id)
         return super(ExtensionRow, self)._build_str("Extension file", id_str)
 
-    def __init__(self, csv_line: str, position: int, datafile_descriptor: DataFileDescriptor) -> None:
+    def __init__(
+        self, csv_line: str, position: int, datafile_descriptor: DataFileDescriptor
+    ) -> None:
         super(ExtensionRow, self).__init__(csv_line, position, datafile_descriptor)
 
         #: The id of the core row this extension row is referring to.
@@ -193,7 +225,14 @@ class ExtensionRow(Row):
 
     def __key(self):
         """Return a tuple representing the row. Common ground between equality and hash."""
-        return (self.descriptor, self.core_id, self.data, self.rowtype, self.raw_fields, self.position)
+        return (
+            self.descriptor,
+            self.core_id,
+            self.data,
+            self.rowtype,
+            self.raw_fields,
+            self.position,
+        )
 
     def __eq__(self, other):
         return self.__key() == other.__key()
@@ -214,10 +253,9 @@ def csv_line_to_fields(csv_line, line_ending, field_ending, fields_enclosed_by):
     raw_fields = []
 
     if fields_enclosed_by == "":
-        opts = {'quoting': csv.QUOTE_NONE}
+        opts = {"quoting": csv.QUOTE_NONE}
     else:
-        opts = {'quoting': csv.QUOTE_ALL,
-                'quotechar': fields_enclosed_by}
+        opts = {"quoting": csv.QUOTE_ALL, "quotechar": fields_enclosed_by}
 
     for row in csv.reader([csv_line], delimiter=field_ending, **opts):
         for f in row:

dwca/star_record.py

@@ -5,16 +5,19 @@ import itertools
 
 
 class StarRecordIterator(object):
-    """ Object used to iterate over multiple DWCA-files joined on the coreid
-    
-        :param files_to_join: a list of the `dwca.files.CSVDataFile`s we'd like to join.
-            May or may not include the core file (the core is not treated in a special way)
-        :param how: indicates the type of join.  "inner" and "outer" correspond vaguely to 
-            inner and full joins.  The outer join includes rows that don't match on all files,
-            however, it doesn't create null fields to fill in when rows are missing in files.
-            Attempts to conform to pandas.DataFrame.merge API.
+    """Object used to iterate over multiple DWCA-files joined on the coreid
+
+    :param files_to_join: a list of the `dwca.files.CSVDataFile`s we'd like to join.
+        May or may not include the core file (the core is not treated in a special way)
+    :param how: indicates the type of join.  "inner" and "outer" correspond vaguely to
+        inner and full joins.  The outer join includes rows that don't match on all files,
+        however, it doesn't create null fields to fill in when rows are missing in files.
+        Attempts to conform to pandas.DataFrame.merge API.
     """
-    def __init__(self, files_to_join: List[CSVDataFile], how: Literal["inner", "outer"] = "inner"):
+
+    def __init__(
+        self, files_to_join: List[CSVDataFile], how: Literal["inner", "outer"] = "inner"
+    ):
         self.files_to_join = files_to_join
 
         # gather the coreids we want to join over.
@@ -26,12 +29,11 @@ class StarRecordIterator(object):
             # outer join: coreid may be in any files
             elif how == "outer":
                 self.common_core |= set(data_file.coreid_index)
-                
+
         # initialize iterator variables
         self._common_core_iterator = iter(self.common_core)
         self._cross_product_iterator = iter([])
 
-    
     def __next__(self):
         # the next combination of rows matching this coreid
         next_positions = next(self._cross_product_iterator, None)
@@ -40,20 +42,26 @@ class StarRecordIterator(object):
             # get the next coreid
             self._current_coreid = next(self._common_core_iterator)
             self._files_with_current_coreid = [
-                csv_file for csv_file in self.files_to_join 
-                    if self._current_coreid in csv_file.coreid_index]
+                csv_file
+                for csv_file in self.files_to_join
+                if self._current_coreid in csv_file.coreid_index
+            ]
             # this iterates over all combinations of rows matching a coreid from all files
             self._cross_product_iterator = itertools.product(
                 *(
-                    csv_file.coreid_index[self._current_coreid] 
-                        for csv_file in self._files_with_current_coreid
-                ))
+                    csv_file.coreid_index[self._current_coreid]
+                    for csv_file in self._files_with_current_coreid
+                )
+            )
             # go back and try to iterate over the rows for the new coreid
             return next(self)
         # zip up this combination of rows from all of the files.
         return (
-            csv_file.get_row_by_position(position) for position, csv_file in zip(next_positions, self._files_with_current_coreid)
+            csv_file.get_row_by_position(position)
+            for position, csv_file in zip(
+                next_positions, self._files_with_current_coreid
+            )
         )
 
-    
-    def __iter__(self): return self
+    def __iter__(self):
+        return self

dwca/test/helpers.py

@@ -4,4 +4,4 @@ import os
 
 
 def sample_data_path(filename):
-    return os.path.join(os.path.dirname(__file__), 'sample_files', filename)
+    return os.path.join(os.path.dirname(__file__), "sample_files", filename)

dwca/test/test_datafile.py

@@ -35,13 +35,18 @@ class TestCSVDataFile(unittest.TestCase):
             description_txt = extension_files[0]
             vernacular_txt = extension_files[1]
 
-            expected_core = {'1': array('L', [0]), '2': array('L', [1]), '3': array('L', [2]), '4': array('L', [3])}
+            expected_core = {
+                "1": array("L", [0]),
+                "2": array("L", [1]),
+                "3": array("L", [2]),
+                "4": array("L", [3]),
+            }
             assert core_txt.coreid_index == expected_core
 
-            expected_vernacular = {"1": array('L', [0, 1, 2]), "2": array('L', [3])}
+            expected_vernacular = {"1": array("L", [0, 1, 2]), "2": array("L", [3])}
             assert vernacular_txt.coreid_index == expected_vernacular
 
-            expected_description = {"1": array('L', [0, 1]), "4": array('L', [2])}
+            expected_description = {"1": array("L", [0, 1]), "4": array("L", [2])}
             assert description_txt.coreid_index == expected_description
 
             with pytest.raises(AttributeError):