diffpy.utils 3.6.0rc4__py3-none-any.whl → 3.6.1__py3-none-any.whl

diffpy/utils/__init__.py

@@ -1,10 +1,10 @@
 #!/usr/bin/env python
 ##############################################################################
 #
-# (c) 2024 The Trustees of Columbia University in the City of New York.
+# (c) 2025 The Trustees of Columbia University in the City of New York.
 # All rights reserved.
 #
-# File coded by: Billinge Group members and community contributors.
+# File coded by: Simon Billinge, Billinge Group members.
 #
 # See GitHub contributions for a more detailed list of contributors.
 # https://github.com/diffpy/diffpy.utils/graphs/contributors
@@ -19,3 +19,5 @@ from diffpy.utils.version import __version__
 
 # silence the pyflakes syntax checker
 assert __version__ or True
+
+# End of file

diffpy/utils/diffraction_objects.py

@@ -6,24 +6,42 @@ from copy import deepcopy
 import numpy as np
 
 from diffpy.utils.tools import get_package_info
-from diffpy.utils.transforms import d_to_q, d_to_tth, q_to_d, q_to_tth, tth_to_d, tth_to_q
+from diffpy.utils.transforms import (
+    d_to_q,
+    d_to_tth,
+    q_to_d,
+    q_to_tth,
+    tth_to_d,
+    tth_to_q,
+)
 
 QQUANTITIES = ["q"]
 ANGLEQUANTITIES = ["angle", "tth", "twotheta", "2theta"]
 DQUANTITIES = ["d", "dspace"]
 XQUANTITIES = ANGLEQUANTITIES + DQUANTITIES + QQUANTITIES
-XUNITS = ["degrees", "radians", "rad", "deg", "inv_angs", "inv_nm", "nm-1", "A-1"]
+XUNITS = [
+    "degrees",
+    "radians",
+    "rad",
+    "deg",
+    "inv_angs",
+    "inv_nm",
+    "nm-1",
+    "A-1",
+]
 
 x_values_not_equal_emsg = (
-    "The two objects have different values in x arrays (my_do.all_arrays[:, [1, 2, 3]]). "
-    "Please ensure the x values of the two objects are identical by re-instantiating "
-    "the DiffractionObject with the correct x value inputs."
+    "The two objects have different values in x arrays "
+    "(my_do.all_arrays[:, [1, 2, 3]]). "
+    "Please ensure the x values of the two objects are identical by "
+    "re-instantiating the DiffractionObject with the correct x value inputs."
 )
 
 invalid_add_type_emsg = (
-    "You may only add a DiffractionObject with another DiffractionObject or a scalar value. "
-    "Please rerun by adding another DiffractionObject instance or a scalar value. "
-    "e.g., my_do_1 + my_do_2 or my_do + 10 or 10 + my_do"
+    "You may only add a DiffractionObject with another DiffractionObject or "
+    "a scalar value. "
+    "Please rerun by adding another DiffractionObject instance or a "
+    "scalar value. e.g., my_do_1 + my_do_2 or my_do + 10 or 10 + my_do"
 )
 
 
@@ -54,11 +72,14 @@ class DiffractionObject:
     Attributes
     ----------
     scat_quantity : str
-        The type of scattering experiment (e.g., "x-ray", "neutron"). Default is an empty string "".
+        The type of scattering experiment (e.g., "x-ray", "neutron"). Default
+        is an empty string "".
     wavelength : float
-        The wavelength of the incoming beam, specified in angstroms (Å). Default is none.
+        The wavelength of the incoming beam, specified in angstroms (Å).
+        Default is none.
     name: str
-        The name or label for the scattering data. Default is an empty string "".
+        The name or label for the scattering data. Default is an empty string
+        "".
     qmin : float
         The minimum q value.
     qmax : float
@@ -92,7 +113,8 @@ class DiffractionObject:
         yarray : ndarray
             The dependent variable array corresponding to intensity values.
         xtype : str
-            The type of the independent variable in `xarray`. Must be one of {*XQUANTITIES}.
+            The type of the independent variable in `xarray`. Must be one of
+            {*XQUANTITIES}.
         wavelength : float, optional, default is None.
             The wavelength of the incoming beam, specified in angstroms (Å)
         scat_quantity : str, optional, default is an empty string "".
@@ -108,7 +130,7 @@ class DiffractionObject:
         >>> import numpy as np
         >>> from diffpy.utils.diffraction_objects import DiffractionObject
         ...
-        >>> x = np.array([0.12, 0.24, 0.31, 0.4])  # independent variable (e.g., q)
+        >>> x = np.array([0.12, 0.24, 0.31, 0.4])  # independent variable (e.g., q)  # noqa: E501
         >>> y = np.array([10, 20, 40, 60])  # intensity values
         >>> metadata = {
         ...     "sample": "rock salt from the beach",
@@ -129,9 +151,13 @@ class DiffractionObject:
         """
 
         self._uuid = uuid.uuid4()
-        self._input_data(xarray, yarray, xtype, wavelength, scat_quantity, name, metadata)
+        self._input_data(
+            xarray, yarray, xtype, wavelength, scat_quantity, name, metadata
+        )
 
-    def _input_data(self, xarray, yarray, xtype, wavelength, scat_quantity, name, metadata):
+    def _input_data(
+        self, xarray, yarray, xtype, wavelength, scat_quantity, name, metadata
+    ):
         if xtype not in XQUANTITIES:
             raise ValueError(_xtype_wmsg(xtype))
         if len(xarray) != len(yarray):
@@ -152,8 +178,12 @@ class DiffractionObject:
     def __eq__(self, other):
         if not isinstance(other, DiffractionObject):
             return NotImplemented
-        self_attributes = [key for key in self.__dict__ if not key.startswith("_")]
-        other_attributes = [key for key in other.__dict__ if not key.startswith("_")]
+        self_attributes = [
+            key for key in self.__dict__ if not key.startswith("_")
+        ]
+        other_attributes = [
+            key for key in other.__dict__ if not key.startswith("_")
+        ]
         if not sorted(self_attributes) == sorted(other_attributes):
             return False
         for key in self_attributes:
@@ -167,8 +197,13 @@ class DiffractionObject:
                     or not np.isclose(value, other_value, rtol=1e-5)
                 ):
                     return False
-            elif isinstance(value, list) and all(isinstance(i, np.ndarray) for i in value):
-                if not all(np.allclose(i, j, rtol=1e-5) for i, j in zip(value, other_value)):
+            elif isinstance(value, list) and all(
+                isinstance(i, np.ndarray) for i in value
+            ):
+                if not all(
+                    np.allclose(i, j, rtol=1e-5)
+                    for i, j in zip(value, other_value)
+                ):
                     return False
             else:
                 if value != other_value:
@@ -182,23 +217,29 @@ class DiffractionObject:
         Parameters
         ----------
         other : DiffractionObject, int, or float
-            The item to be added. If `other` is a scalar value, this value will be added to each element of the
-            yarray of this DiffractionObject instance. If `other` is another DiffractionObject, the yarrays of the
-            two DiffractionObjects will be combined element-wise. The result is a new DiffractionObject instance,
-            representing the addition and using the xarray from the left-hand side DiffractionObject.
+            The item to be added. If `other` is a scalar value, this value
+            will be added to each element of the yarray of this
+            DiffractionObject instance. If `other` is another DiffractionObject
+            , the yarrays of the two DiffractionObjects will be combined
+            element -wise. The result is a new DiffractionObject instance,
+            representing the addition and using the xarray from the left-hand
+            side DiffractionObject.
 
         Returns
         -------
         DiffractionObject
-            The new DiffractionObject instance with modified yarray values. This instance is a deep copy of the
-            original with the additions applied.
+            The new DiffractionObject instance with modified yarray values.
+            This instance is a deep copy of the original with the additions
+            applied.
 
         Raises
         ------
         ValueError
-            Raised when the xarrays of two DiffractionObject instances are not equal.
+            Raised when the xarrays of two DiffractionObject instances are
+            not equal.
         TypeError
-            Raised when `other` is not an instance of DiffractionObject, int, or float.
+            Raised when `other` is not an instance of DiffractionObject, int,
+            or float.
 
         Examples
         --------
@@ -224,12 +265,14 @@ class DiffractionObject:
         """Subtract scalar value or another DiffractionObject to the yarray of
         the DiffractionObject.
 
-        This method behaves similarly to the `__add__` method, but performs subtraction instead of addition.
-        For details on parameters, returns, and exceptions, refer to the documentation for `__add__`.
+        This method behaves similarly to the `__add__` method, but performs
+        subtraction instead of addition. For details on parameters, returns
+        , and exceptions, refer to the documentation for `__add__`.
 
         Examples
         --------
-        Subtract a scalar value from the yarray of a DiffractionObject instance:
+        Subtract a scalar value from the yarray of a DiffractionObject
+        instance:
         >>> new_do = my_do - 10.1
 
         Subtract the yarrays of two DiffractionObject instances:
@@ -250,12 +293,14 @@ class DiffractionObject:
         """Multiply a scalar value or another DiffractionObject with the yarray
         of this DiffractionObject.
 
-        This method behaves similarly to the `__add__` method, but performs multiplication instead of addition.
-        For details on parameters, returns, and exceptions, refer to the documentation for `__add__`.
+        This method behaves similarly to the `__add__` method, but performs
+        multiplication instead of addition. For details on parameters,
+        returns, and exceptions, refer to the documentation for `__add__`.
 
         Examples
         --------
-        Multiply a scalar value with the yarray of a DiffractionObject instance:
+        Multiply a scalar value with the yarray of a DiffractionObject
+        instance:
         >>> new_do = my_do * 3.5
 
         Multiply the yarrays of two DiffractionObject instances:
@@ -276,8 +321,9 @@ class DiffractionObject:
         """Divide the yarray of this DiffractionObject by a scalar value or
         another DiffractionObject.
 
-        This method behaves similarly to the `__add__` method, but performs division instead of addition.
-        For details on parameters, returns, and exceptions, refer to the documentation for `__add__`.
+        This method behaves similarly to the `__add__` method, but performs
+        division instead of addition. For details on parameters, returns,
+        and exceptions, refer to the documentation for `__add__`.
 
         Examples
         --------
@@ -303,7 +349,9 @@ class DiffractionObject:
         if isinstance(other, DiffractionObject):
             if self.all_arrays.shape != other.all_arrays.shape:
                 raise ValueError(x_values_not_equal_emsg)
-            if not np.allclose(self.all_arrays[:, [1, 2, 3]], other.all_arrays[:, [1, 2, 3]]):
+            if not np.allclose(
+                self.all_arrays[:, [1, 2, 3]], other.all_arrays[:, [1, 2, 3]]
+            ):
                 raise ValueError(x_values_not_equal_emsg)
 
     @property
@@ -313,8 +361,8 @@ class DiffractionObject:
         Returns
         -------
         ndarray
-            The shape (len(data), 4) 2D array with columns containing the `yarray` (intensity)
-            and the `xarray` values in q, tth, and d.
+            The shape (len(data), 4) 2D array with columns containing the `
+            yarray` (intensity) and the `xarray` values in q, tth, and d.
 
         Examples
         --------
@@ -361,27 +409,35 @@ class DiffractionObject:
     def uuid(self, _):
         raise AttributeError(_setter_wmsg("uuid"))
 
-    def get_array_index(self, xtype, xvalue):
-        """Return the index of the closest value in the array associated with
+    def get_array_index(self, xvalue, xtype=None):
+        f"""Return the index of the closest value in the array associated with
         the specified xtype and the value provided.
 
         Parameters
         ----------
-        xtype : str
-            The type of the independent variable in `xarray`. Must be one of {*XQUANTITIES}.
         xvalue : float
             The value of the xtype to find the closest index for.
+        xtype : str, optional
+            The type of the independent variable in `xarray`. Must be one
+            of {*XQUANTITIES, }. Default is {self._input_xtype}
 
         Returns
         -------
         index : int
-            The index of the closest value in the array associated with the specified xtype and the value provided.
+            The index of the closest value in the array associated with the
+            specified xtype and the value provided.
         """
-
-        xtype = self._input_xtype
+        if xtype is None:
+            xtype = self._input_xtype
+        else:
+            if xtype not in XQUANTITIES:
+                raise ValueError(_xtype_wmsg(xtype))
         xarray = self.on_xtype(xtype)[0]
         if len(xarray) == 0:
-            raise ValueError(f"The '{xtype}' array is empty. Please ensure it is initialized.")
+            raise ValueError(
+                f"The '{xtype}' array is empty. "
+                "Please ensure it is initialized."
+            )
         index = (np.abs(xarray - xvalue)).argmin()
         return index
 
@@ -447,14 +503,19 @@ class DiffractionObject:
         """
         return [self.all_arrays[:, 3], self.all_arrays[:, 0]]
 
-    def scale_to(self, target_diff_object, q=None, tth=None, d=None, offset=None):
+    def scale_to(
+        self, target_diff_object, q=None, tth=None, d=None, offset=None
+    ):
         """Return a new diffraction object which is the current object but
         rescaled in y to the target.
 
-        By default, if `q`, `tth`, or `d` are not provided, scaling is based on the max intensity from each object.
-        Otherwise, y-value in the target at the closest specified x-value will be used as the factor to scale to.
-        The entire array is scaled by this factor so that one object places on top of the other at that point.
-        If multiple values of `q`, `tth`, or `d` are provided, an error will be raised.
+        By default, if `q`, `tth`, or `d` are not provided, scaling is
+        based on the max intensity from each object. Otherwise, y-value in
+        the target at the closest specified x-value will be used as the
+        factor to scale to. The entire array is scaled by this factor so
+        that one object places on top of the other at that point. If
+        multiple values of `q`, `tth`, or `d` are provided, an error will
+        be raised.
 
         Parameters
         ----------
@@ -462,8 +523,9 @@ class DiffractionObject:
             The diffraction object you want to scale the current one onto.
 
         q, tth, d : float, optional, default is None
-            The value of the x-array where you want the curves to line up vertically.
-            Specify a value on one of the allowed grids, q, tth, or d), e.g., q=10.
+            The value of the x-array where you want the curves to line up
+            vertically. Specify a value on one of the allowed grids, q, tth,
+            or d), e.g., q=10.
 
         offset : float, optional, default is None
             The offset to add to the scaled y-values.
@@ -486,7 +548,10 @@ class DiffractionObject:
         if count == 0:
             q_target_max = max(target_diff_object.on_q()[1])
             q_self_max = max(self.on_q()[1])
-            scaled_do._all_arrays[:, 0] = scaled_do._all_arrays[:, 0] * q_target_max / q_self_max + offset
+            scaled_do._all_arrays[:, 0] = (
+                scaled_do._all_arrays[:, 0] * q_target_max / q_self_max
+                + offset
+            )
             return scaled_do
 
         xtype = "q" if q is not None else "tth" if tth is not None else "d"
@@ -497,7 +562,9 @@ class DiffractionObject:
 
         xindex_data = (np.abs(data[0] - xvalue)).argmin()
         xindex_target = (np.abs(target[0] - xvalue)).argmin()
-        scaled_do._all_arrays[:, 0] = data[1] * target[1][xindex_target] / data[1][xindex_data] + offset
+        scaled_do._all_arrays[:, 0] = (
+            data[1] * target[1][xindex_target] / data[1][xindex_data] + offset
+        )
         return scaled_do
 
     def on_xtype(self, xtype):
@@ -506,7 +573,8 @@ class DiffractionObject:
         Parameters
         ----------
         xtype : str
-            The type of quantity for the independent variable chosen from {*XQUANTITIES, }
+            The type of quantity for the independent variable chosen from
+            {*XQUANTITIES, }
 
         Raises
         ------
@@ -516,7 +584,8 @@ class DiffractionObject:
         Returns
         -------
         (xarray, yarray) : tuple of ndarray
-            The tuple containing two 1D numpy arrays with x and y data for the specified xtype.
+            The tuple containing two 1D numpy arrays with x and y data for
+            the specified xtype.
         """
         if xtype.lower() in ANGLEQUANTITIES:
             return self.on_tth()
@@ -536,12 +605,13 @@ class DiffractionObject:
         filepath : str
             The filepath where the diffraction object will be dumped
         xtype : str, optional, default is q
-            The type of quantity for the independent variable chosen from {*XQUANTITIES, }
+            The type of quantity for the independent variable chosen from
+            {*XQUANTITIES, }
 
         Examples
         --------
-        To save a diffraction object to a file named "diffraction_data.chi" in the current directory
-        with the independent variable 'q':
+        To save a diffraction object to a file named "diffraction_data.chi"
+        in the current directory with the independent variable 'q':
 
         >>> file = "diffraction_data.chi"
         >>> do.dump(file, xtype="q")
@@ -551,7 +621,8 @@ class DiffractionObject:
         >>> file = "./output/diffraction_data.chi"
         >>> do.dump(file, xtype="q")
 
-        To save the diffraction data with a different independent variable, such as 'tth':
+        To save the diffraction data with a different independent variable,
+        such as 'tth':
 
         >>> file = "diffraction_data_tth.chi"
         >>> do.dump(file, xtype="tth")
@@ -561,17 +632,23 @@ class DiffractionObject:
         if xtype in QQUANTITIES:
             data_to_save = np.column_stack((self.on_q()[0], self.on_q()[1]))
         elif xtype in ANGLEQUANTITIES:
-            data_to_save = np.column_stack((self.on_tth()[0], self.on_tth()[1]))
+            data_to_save = np.column_stack(
+                (self.on_tth()[0], self.on_tth()[1])
+            )
         elif xtype in DQUANTITIES:
             data_to_save = np.column_stack((self.on_d()[0], self.on_d()[1]))
         else:
             warnings.warn(_xtype_wmsg(xtype))
-        self.metadata.update(get_package_info("diffpy.utils", metadata=self.metadata))
+        self.metadata.update(
+            get_package_info("diffpy.utils", metadata=self.metadata)
+        )
         self.metadata["creation_time"] = datetime.datetime.now()
 
         with open(filepath, "w") as f:
             f.write(
-                f"[DiffractionObject]\nname = {self.name}\nwavelength = {self.wavelength}\n"
+                f"[DiffractionObject]\n"
+                f"name = {self.name}\n"
+                f"wavelength = {self.wavelength}\n"
                 f"scat_quantity = {self.scat_quantity}\n"
             )
             for key, value in self.metadata.items():
@@ -585,6 +662,7 @@ class DiffractionObject:
         Returns
         -------
         DiffractionObject
-            The new instance of DiffractionObject, which is a deep copy of the current instance.
+            The new instance of DiffractionObject, which is a deep copy of
+            the current instance.
         """
         return deepcopy(self)

diffpy/utils/parsers/custom_exceptions.py

@@ -51,5 +51,7 @@ class ImproperSizeError(Exception):
 
     def __init__(self, bad_object, message=None):
         if message is None:
-            self.message = f"The size of {bad_object} is different than expected."
+            self.message = (
+                f"The size of {bad_object} is different than expected."
+            )
         super().__init__(self.message)

diffpy/utils/parsers/loaddata.py

@@ -20,56 +20,67 @@ import numpy
 from diffpy.utils import validators
 
 
-def loadData(filename, minrows=10, headers=False, hdel="=", hignore=None, **kwargs):
+def loadData(
+    filename, minrows=10, headers=False, hdel="=", hignore=None, **kwargs
+):
     """Find and load data from a text file.
 
-    The data block is identified as the first matrix block of at least minrows rows and constant number of columns.
-    This seems to work for most of the datafiles including those generated by diffpy programs.
+    The data block is identified as the first matrix block of at least
+    minrows rows and constant number of columns. This seems to work for most
+    of the datafiles including those generated by diffpy programs.
 
     Parameters
     ----------
     filename
         Name of the file we want to load data from.
     minrows: int
-        Minimum number of rows in the first data block. All rows must have the same number of floating
-        point values.
+        Minimum number of rows in the first data block. All rows must have
+        the same number of floating point values.
     headers: bool
-        when False (default), the function returns a numpy array of the data in the data block.
-        When True, the function instead returns a dictionary of parameters and their corresponding
-        values parsed from header (information prior the data block). See hdel and hignore for options
-        to help with parsing header information.
+        when False (default), the function returns a numpy array of the data
+        in the data block. When True, the function instead returns a
+        dictionary of parameters and their corresponding values parsed from
+        header (information prior the data block). See hdel and hignore for
+        options to help with parsing header information.
     hdel: str
-        (Only used when headers enabled.) Delimiter for parsing header information (default '='). e.g. using
-        default hdel, the line 'parameter = p_value' is put into the dictionary as {parameter: p_value}.
+        (Only used when headers enabled.) Delimiter for parsing header
+        information (default '='). e.g. using default hdel, the line '
+        parameter = p_value' is put into the dictionary as
+        {parameter: p_value}.
     hignore: list
-        (Only used when headers enabled.) Ignore header rows beginning with any elements in hignore.
-        e.g. hignore=['# ', '['] causes the following lines to be skipped: '# qmax=10', '[defaults]'.
+        (Only used when headers enabled.) Ignore header rows beginning with
+        any elements in hignore. e.g. hignore=['# ', '['] causes the
+        following lines to be skipped: '# qmax=10', '[defaults]'.
     kwargs:
-        Keyword arguments that are passed to numpy.loadtxt including the following arguments below. (See
-        numpy.loadtxt for more details.) Only pass kwargs used by numpy.loadtxt.
+        Keyword arguments that are passed to numpy.loadtxt including the
+        following arguments below. (See numpy.loadtxt for more details.) Only
+        pass kwargs used by numpy.loadtxt.
 
     Useful kwargs
     =============
     comments: str, sequence of str
-        The characters or list of characters used to indicate the start of a comment (default '#').
-        Comment lines are ignored.
+        The characters or list of characters used to indicate the start of a
+        comment (default '#'). Comment lines are ignored.
     delimiter: str
-        Delimiter for the data in the block (default use whitespace). For comma-separated data blocks,
-        set delimiter to ','.
+        Delimiter for the data in the block (default use whitespace). For
+        comma-separated data blocks, set delimiter to ','.
     unpack: bool
-        Return data as a sequence of columns that allows tuple unpacking such as x, y =
-        loadData(FILENAME, unpack=True). Note transposing the loaded array as loadData(FILENAME).T has the same
-        effect.
+        Return data as a sequence of columns that allows tuple unpacking such
+        as x, y = loadData(FILENAME, unpack=True). Note transposing the
+        loaded array as loadData(FILENAME).T has the same effect.
     usecols:
-        Zero-based index of columns to be loaded, by default use all detected columns. The reading skips
-        data blocks that do not have the usecols-specified columns.
+        Zero-based index of columns to be loaded, by default use all detected
+        columns. The reading skips data blocks that do not have the usecols-
+        specified columns.
 
     Returns
     -------
     data_block: ndarray
-        A numpy array containing the found data block. (This is not returned if headers is enabled.)
+        A numpy array containing the found data block. (This is not returned
+        if headers is enabled.)
     hdata: dict
-        If headers are enabled, return a dictionary of parameters read from the header.
+        If headers are enabled, return a dictionary of parameters read from
+        the header.
     """
     from numpy import array, loadtxt
 
@@ -105,7 +116,12 @@ def loadData(filename, minrows=10, headers=False, hdel="=", hignore=None, **kwar
 
     # Check if file exists before trying to open
     if not os.path.exists(filename):
-        raise IOError(f"File {filename} cannot be found. Please rerun the program specifying a valid filename.")
+        raise IOError(
+            (
+                f"File {filename} cannot be found. "
+                "Please rerun the program specifying a valid filename."
+            )
+        )
 
     # make sure fid gets cleaned up
     with open(filename, "rb") as fid:
@@ -134,7 +150,10 @@ def loadData(filename, minrows=10, headers=False, hdel="=", hignore=None, **kwar
                         if hignore is not None:
                             for tag in hignore:
                                 taglen = len(tag)
-                                if len(hpair[0]) >= taglen and hpair[0][:taglen] == tag:
+                                if (
+                                    len(hpair[0]) >= taglen
+                                    and hpair[0][:taglen] == tag
+                                ):
                                     flag = False
                 # add header data
                 if flag:
@@ -187,7 +206,8 @@ class TextDataLoader(object):
     minrows: int
         Minimum number of rows in the first data block. (Default 10.)
     usecols: tuple
-        Which columns in our dataset to use. Ignores all other columns. If None (default), use all columns.
+        Which columns in our dataset to use. Ignores all other columns. If
+        None (default), use all columns.
     skiprows
         Rows in dataset to skip. (Currently not functional.)
     """
@@ -235,7 +255,8 @@ class TextDataLoader(object):
         File details include:
          *  File name.
          *  All data blocks findable by loadData.
-         *  Headers (if present) for each data block. (Generally the headers contain column name information).
+         *  Headers (if present) for each data block. (Generally the headers
+            contain column name information).
         """
         self._reset()
         # try to read lines from fp first
@@ -258,7 +279,13 @@ class TextDataLoader(object):
         # nf - number of words, ok - has data
         self._linerecs = numpy.recarray(
             (nlines,),
-            dtype=[("idx", int), ("nw0", int), ("nw1", int), ("nf", int), ("ok", bool)],
+            dtype=[
+                ("idx", int),
+                ("nw0", int),
+                ("nw1", int),
+                ("nf", int),
+                ("ok", bool),
+            ],
         )
         lr = self._linerecs
         lr.idx = numpy.arange(nlines)
@@ -319,7 +346,9 @@ class TextDataLoader(object):
             if self.usecols is None:
                 data = numpy.reshape(lw.value[bb1.nw0 : ee1.nw1], (-1, bb1.nf))
             else:
-                tdata = numpy.empty((len(self.usecols), dend - dbeg), dtype=float)
+                tdata = numpy.empty(
+                    (len(self.usecols), dend - dbeg), dtype=float
+                )
                 for j, trow in zip(self.usecols, tdata):
                     j %= bb1.nf
                     trow[:] = lw.value[bb1.nw0 + j : ee1.nw1 : bb1.nf]