style: apply black and flake8 to all files in the project

Author: ycexiao

Diff for: doc/source/conf.py

@@ -221,7 +221,13 @@
 # (source start file, target name, title,
 # author, documentclass [howto, manual, or own class]).
 latex_documents = [
-    ("index", "diffpy.utils.tex", "diffpy.utils Documentation", ab_authors, "manual"),
+    (
+        "index",
+        "diffpy.utils.tex",
+        "diffpy.utils Documentation",
+        ab_authors,
+        "manual",
+    ),
 ]
 
 # The name of an image file (relative to this directory) to place at the top of
@@ -249,7 +255,9 @@
 
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
-man_pages = [("index", "diffpy.utils", "diffpy.utils Documentation", ab_authors, 1)]
+man_pages = [
+    ("index", "diffpy.utils", "diffpy.utils Documentation", ab_authors, 1)
+]
 
 # If true, show URL addresses after external links.
 # man_show_urls = False

Diff for: src/diffpy/utils/diffraction_objects.py

@@ -6,13 +6,29 @@
 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]]). "
@@ -129,9 +145,13 @@ def __init__(
         """
 
         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 +172,12 @@ def _input_data(self, xarray, yarray, xtype, wavelength, scat_quantity, name, me
     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 +191,13 @@ def __eq__(self, other):
                     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:
@@ -303,7 +332,9 @@ def _check_operation_compatibility(self, other):
         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
@@ -381,7 +412,9 @@ def get_array_index(self, xtype, xvalue):
         xtype = self._input_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,7 +480,9 @@ def on_d(self):
         """
         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.
 
@@ -486,7 +521,10 @@ def scale_to(self, target_diff_object, q=None, tth=None, d=None, offset=None):
         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 +535,9 @@ def scale_to(self, target_diff_object, q=None, tth=None, d=None, offset=None):
 
         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):
@@ -561,12 +601,16 @@ def dump(self, filepath, xtype=None):
         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:

Diff for: src/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)

Diff for: src/diffpy/utils/parsers/loaddata.py

@@ -20,7 +20,9 @@
 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.
@@ -105,7 +107,9 @@ def countcolumnsvalues(line):
 
     # 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 +138,10 @@ def countcolumnsvalues(line):
                         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:
@@ -258,7 +265,13 @@ def _findDataBlocks(self):
         # 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 +332,9 @@ def _findDataBlocks(self):
             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]

Diff for: src/diffpy/utils/parsers/serialization.py

@@ -86,8 +86,12 @@ def serialize_data(
         num_columns = [len(row) for row in data_table]
         max_columns = max(num_columns)
         num_col_names = len(dt_colnames)
-        if max_columns < num_col_names:  # assume numpy.loadtxt gives non-irregular array
-            raise ImproperSizeError("More entries in dt_colnames than columns in data_table.")
+        if (
+            max_columns < num_col_names
+        ):  # assume numpy.loadtxt gives non-irregular array
+            raise ImproperSizeError(
+                "More entries in dt_colnames than columns in data_table."
+            )
         named_columns = 0
         for idx in range(num_col_names):
             colname = dt_colnames[idx]