Repository: AequilibraE/aequilibrae (language: python)

Issue:
Run black on all source files
Hi!

### Preamble
I'm currently preparing a number of issues/PRs for Aequilibrae. With my company we're running a (not yet public) fork of Aequilibrae for which I've recently become the maintainer. You may already have heard of us through our ex-colleague @barisdemirdelen. Now, I would like to look at the possibility to bring (some of) our changes into Aequilibrae proper, which would it easier for us to maintain our fork and gives Aequilibrae some newer/enhanced features/capabilities. Our changes include:
- Support for multiple projects
- Some threading changes (or perhaps customizability/configurability of some threading aspects)
- Some (test) performance changes
- Getting rid of some warnings/deprecations

/end-of-preamble

I've noticed that you are using black (judging from the .pre-commit-config.yaml) for code formatting. This is great! However, not all code seems to be blackened yet. I would like to keep the PRs I'm preparing clean, but right now precommit is blackening every file I'm touching so there's also a bunch of changes that are just code formatting. I would like to suggest to create a single commit/PR that blackens all of the codebase, so any further PRs are not muddied by code format changes. The PR would consist of the following

- update .pre-commit-config.yaml to point to a specific black version
- add a pyproject.toml so that black can easily be run from commandline with the specified line length
- update .gitignore (black automatically ignores everything in .gitignore to ensure it doesn't format files it doesnt need to)
- run black

Now, this commit/PR would muddy git blame, since it would appear that the commiter changed all files. Black proposes a solution for that in the form of an ignore-revision (see https://black.readthedocs.io/en/stable/guides/introducing_black_to_your_project.html). There would be a second commit that adds the first commit's hash to a `.git-blame-ignore-revs` file. This file can then be passed to git blame (and is also automatically passed to Githubs blame server) so that those changed lines would still be attributed to the correct commit.

What do you think of this?







Discussion / hints:

Fix patch:
diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
new file mode 100644
index 000000000..01efa4b95
--- /dev/null
+++ b/.git-blame-ignore-revs
@@ -0,0 +1,2 @@
+# Migrate code style to Black
+da16bfaffaed76cfdf5e53d96ff155cd4c4a78d5
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 313c81e5d..075a53c99 100644
--- a/.gitignore
+++ b/.gitignore
@@ -63,12 +63,34 @@ aequilibrae/paths/build/*
 docs/build/*
 docs/source/_generated/*
 docs/source/_auto_examples/*
+*.cpp 
 
 
 #Virtual environment
 .venv/
 
 # Test files
-tests/*.aem
-tests/*.csv
-tests/*.omx
+tests/**/*.aem
+tests/**/*.csv
+tests/**/*.omx
+
+#### Snippet from https://github.com/github/gitignore/blob/main/Python.gitignore
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+
+# C extensions
+*.so
+
+# Distribution / packaging
+build/
+*.egg-info/
+*.egg
+
+# Unit test / coverage reports
+.coverage
+.coverage.*
+coverage.xml
+
+#### End snippet
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index cd1476567..0e3fbbc53 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,11 +1,9 @@
 repos:
 -   repo: https://github.com/ambv/black
-    rev: stable
+    rev: 22.3.0
     hooks:
     - id: black
-      language_version: python3.8
-      args: [--line-length=120]
--   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v1.2.3
+-   repo: https://github.com/pycqa/flake8
+    rev: 4.0.1
     hooks:
     - id: flake8
\ No newline at end of file
diff --git a/aequilibrae/distribution/gravity_application.py b/aequilibrae/distribution/gravity_application.py
index e8db465cd..beb763ec7 100644
--- a/aequilibrae/distribution/gravity_application.py
+++ b/aequilibrae/distribution/gravity_application.py
@@ -152,8 +152,8 @@ def __init__(self, **kwargs):
         self.output = None
         self.gap = np.inf
         self.logger = logging.getLogger("aequilibrae")
-        self.procedure_date = ''
-        self.procedure_id = ''
+        self.procedure_date = ""
+        self.procedure_id = ""
         self.__ipf = None  # type: Ipf
 
     def apply(self):
@@ -205,7 +205,7 @@ def apply(self):
         self.output = self.__ipf.output
         self.gap = self.__ipf.gap
 
-        self.report.extend(self.__ipf.report[1:] + ['', ''])
+        self.report.extend(self.__ipf.report[1:] + ["", ""])
         self.report.append("Total of matrix: " + "{:15,.4f}".format(float(np.nansum(self.output.matrix_view))))
         intrazonals = float(np.nansum(np.diagonal(self.output.matrix_view)))
         self.report.append("Intrazonal flow: " + "{:15,.4f}".format(intrazonals))
@@ -229,8 +229,8 @@ def save_to_project(self, name: str, file_name: str) -> None:
         record = mats.new_record(name, file_name, self.output)
         record.procedure_id = self.procedure_id
         record.timestamp = self.procedure_date
-        record.procedure = 'Synthetic gravity trip distribution'
-        record.description = f'Synthetic gravity trip distribution. {self.model.function}'
+        record.procedure = "Synthetic gravity trip distribution"
+        record.description = f"Synthetic gravity trip distribution. {self.model.function}"
         record.save()
 
     def __get_parameters(self):
@@ -312,13 +312,16 @@ def __apply_function(self):
 
             elif self.model.function == "POWER":
                 # self.output.matrices[self.core_name][i, :] = (np.power(self.impedance.matrix_view[i, :, 0], - self.model.alpha) * p * a)[:]
-                self.output.matrix_view[i, :] = (np.power(self.impedance.matrix_view[i, :], -self.model.alpha) * p
-                                                 * a)[:]
+                self.output.matrix_view[i, :] = (np.power(self.impedance.matrix_view[i, :], -self.model.alpha) * p * a)[
+                    :
+                ]
             elif self.model.function == "GAMMA":
-                self.output.matrix_view[i, :] = (np.power(self.impedance.matrix_view[i, :], self.model.alpha)
-                                                 * np.exp(-self.model.beta * self.impedance.matrix_view[i, :])
-                                                 * p
-                                                 * a)[:]
+                self.output.matrix_view[i, :] = (
+                    np.power(self.impedance.matrix_view[i, :], self.model.alpha)
+                    * np.exp(-self.model.beta * self.impedance.matrix_view[i, :])
+                    * p
+                    * a
+                )[:]
 
         # Deals with infinite and NaNs
         infinite = np.isinf(self.output.matrix_view[:, :]).astype(int)
diff --git a/aequilibrae/distribution/gravity_calibration.py b/aequilibrae/distribution/gravity_calibration.py
index c5c21ba63..f77bf8992 100644
--- a/aequilibrae/distribution/gravity_calibration.py
+++ b/aequilibrae/distribution/gravity_calibration.py
@@ -48,7 +48,7 @@ class GravityCalibration:
         with open('path.to/report.txt', 'w') as f:
             for line in gravity.report:
                 f.write(f'{line}\n')
-        """
+    """
 
     def __init__(self, **kwargs):
         """
@@ -139,9 +139,9 @@ def calibrate(self):
 
             # weighted average cost
             self.report.append("Iteration: 1")
-            cstar = np.nansum(
-                self.impedance.matrix_view[:, :] * self.result_matrix.gravity[:, :] * a
-            ) / np.nansum(self.result_matrix.gravity[:, :] * a)
+            cstar = np.nansum(self.impedance.matrix_view[:, :] * self.result_matrix.gravity[:, :] * a) / np.nansum(
+                self.result_matrix.gravity[:, :] * a
+            )
 
             b0 = 1 / cstar
 
@@ -264,9 +264,9 @@ def __apply_gravity(self):
         self.gravity.apply()
         self.result_matrix = self.gravity.output
 
-        return np.nansum(
-            self.impedance.matrix_view[:, :] * self.result_matrix.gravity[:, :]
-        ) / np.nansum(self.result_matrix.gravity[:, :])
+        return np.nansum(self.impedance.matrix_view[:, :] * self.result_matrix.gravity[:, :]) / np.nansum(
+            self.result_matrix.gravity[:, :]
+        )
 
     def __get_parameters(self):
         par = Parameters().parameters
diff --git a/aequilibrae/distribution/ipf.py b/aequilibrae/distribution/ipf.py
index 1f9eff6fc..9a709e7fa 100644
--- a/aequilibrae/distribution/ipf.py
+++ b/aequilibrae/distribution/ipf.py
@@ -16,50 +16,49 @@
 class Ipf:
     """Iterative proportional fitting procedure
 
-        ::
+    ::
 
-            import pandas as pd
-            from aequilibrae.distribution import Ipf
-            from aequilibrae.matrix import AequilibraeMatrix
-            from aequilibrae.matrix import AequilibraeData
+        import pandas as pd
+        from aequilibrae.distribution import Ipf
+        from aequilibrae.matrix import AequilibraeMatrix
+        from aequilibrae.matrix import AequilibraeData
 
-            matrix = AequilibraeMatrix()
+        matrix = AequilibraeMatrix()
 
-            # Here we can create from OMX or load from an AequilibraE matrix.
-            matrix.create_from_omx(path/to/aequilibrae_matrix, path/to/omxfile)
+        # Here we can create from OMX or load from an AequilibraE matrix.
+        matrix.create_from_omx(path/to/aequilibrae_matrix, path/to/omxfile)
 
-            # The matrix will be operated one (see the note on overwriting), so it does
-            # not make sense load an OMX matrix
+        # The matrix will be operated one (see the note on overwriting), so it does
+        # not make sense load an OMX matrix
 
 
-            source_vectors = pd.read_csv(path/to/CSVs)
-            zones = source_vectors.zone.shape[0]
+        source_vectors = pd.read_csv(path/to/CSVs)
+        zones = source_vectors.zone.shape[0]
 
-            args = {"entries": zones, "field_names": ["productions", "attractions"],
-                    "data_types": [np.float64, np.float64], "memory_mode": True}
+        args = {"entries": zones, "field_names": ["productions", "attractions"],
+                "data_types": [np.float64, np.float64], "memory_mode": True}
 
-            vectors = AequilibraEData()
-            vectors.create_empty(**args)
+        vectors = AequilibraEData()
+        vectors.create_empty(**args)
 
-            vectors.productions[:] = source_vectors.productions[:]
-            vectors.attractions[:] = source_vectors.attractions[:]
+        vectors.productions[:] = source_vectors.productions[:]
+        vectors.attractions[:] = source_vectors.attractions[:]
 
-            # We assume that the indices would be sorted and that they would match the matrix indices
-            vectors.index[:] = source_vectors.zones[:]
+        # We assume that the indices would be sorted and that they would match the matrix indices
+        vectors.index[:] = source_vectors.zones[:]
 
-            args = {
-                    "matrix": matrix, "rows": vectors, "row_field": "productions", "columns": vectors,
-                    "column_field": "attractions", "nan_as_zero": False}
+        args = {
+                "matrix": matrix, "rows": vectors, "row_field": "productions", "columns": vectors,
+                "column_field": "attractions", "nan_as_zero": False}
 
-            fratar = Ipf(**args)
+        fratar = Ipf(**args)
 
-             fratar.fit()
+         fratar.fit()
 
-            # We can get back to our OMX matrix in the end
-            fratar.output.export(path/to_omx/output.omx)
-            fratar.output.export(path/to_aem/output.aem)
-
-"""
+        # We can get back to our OMX matrix in the end
+        fratar.output.export(path/to_omx/output.omx)
+        fratar.output.export(path/to_aem/output.aem)
+    """
 
     def __init__(self, **kwargs):
         """
@@ -110,8 +109,8 @@ def __init__(self, **kwargs):
         self.error_free = True
         self.report = ["  #####    IPF computation    #####  ", ""]
         self.gap = None
-        self.procedure_date = ''
-        self.procedure_id = ''
+        self.procedure_date = ""
+        self.procedure_id = ""
 
     def __check_data(self):
         self.error = None
@@ -191,8 +190,9 @@ def fit(self):
 
             if self.matrix.is_omx():
                 self.output = AequilibraeMatrix()
-                self.output.create_from_omx(self.output.random_name(), self.matrix.file_path,
-                                            cores=self.matrix.view_names)
+                self.output.create_from_omx(
+                    self.output.random_name(), self.matrix.file_path, cores=self.matrix.view_names
+                )
                 self.output.computational_view()
             else:
                 self.output = self.matrix.copy(self.output_name)
@@ -259,7 +259,7 @@ def save_to_project(self, name: str, file_name: str) -> MatrixRecord:
         record = mats.new_record(name, file_name, self.output)
         record.procedure_id = self.procedure_id
         record.timestamp = self.procedure_date
-        record.procedure = 'Iterative Proportional fitting'
+        record.procedure = "Iterative Proportional fitting"
         record.save()
         return record
 
diff --git a/aequilibrae/distribution/synthetic_gravity_model.py b/aequilibrae/distribution/synthetic_gravity_model.py
index 8d2af84e7..eaa56cac4 100644
--- a/aequilibrae/distribution/synthetic_gravity_model.py
+++ b/aequilibrae/distribution/synthetic_gravity_model.py
@@ -6,9 +6,7 @@
 
 
 class SyntheticGravityModel:
-    """Simple class object to represent synthetic gravity models
-
-    """
+    """Simple class object to represent synthetic gravity models"""
 
     def __init__(self):
         self.function = None
@@ -49,9 +47,7 @@ def __getattr__(self, key):
             return self.__dict__[key]
 
     def load(self, file_name):
-        """Loads model from disk. Extension is \*.mod
-
-        """
+        """Loads model from disk. Extension is \*.mod"""
         try:
             with open(file_name, "r") as f:
                 model = yaml.safe_load(f)[self.model_type]
@@ -64,9 +60,7 @@ def load(self, file_name):
             raise ValueError("File provided is not a valid Synthetic Gravity Model - {}".format(err.__str__()))
 
     def save(self, file_name):
-        """Saves model to disk in yaml format. Extension is \*.mod
-
-        """
+        """Saves model to disk in yaml format. Extension is \*.mod"""
         file_name = str(file_name)
         if file_name[-4:].upper() != ".MOD":
             file_name += ".mod"
diff --git a/aequilibrae/log/log.py b/aequilibrae/log/log.py
index bf98bceb9..059066b23 100644
--- a/aequilibrae/log/log.py
+++ b/aequilibrae/log/log.py
@@ -30,10 +30,10 @@ def contents(self) -> list:
             *log_contents* (:obj:`list`): List with all entries in the log file
         """
 
-        with open(self.log_file_path, 'r') as file:
+        with open(self.log_file_path, "r") as file:
             return [x.strip() for x in file.readlines()]
 
     def clear(self):
         """Clears the log file. Use it wisely"""
-        with open(self.log_file_path, 'w') as _:
+        with open(self.log_file_path, "w") as _:
             pass
diff --git a/aequilibrae/matrix/aequilibrae_matrix.py b/aequilibrae/matrix/aequilibrae_matrix.py
index 69df1d080..f43b22e2d 100644
--- a/aequilibrae/matrix/aequilibrae_matrix.py
+++ b/aequilibrae/matrix/aequilibrae_matrix.py
@@ -120,13 +120,13 @@ def save(self, names=()) -> None:
         self.computational_view(names)
 
     def create_empty(
-            self,
-            file_name: str = None,
-            zones: int = None,
-            matrix_names: List[str] = None,
-            data_type: np.dtype = np.float64,
-            index_names: List[str] = None,
-            compressed: bool = False,
+        self,
+        file_name: str = None,
+        zones: int = None,
+        matrix_names: List[str] = None,
+        data_type: np.dtype = np.float64,
+        index_names: List[str] = None,
+        compressed: bool = False,
     ):
         """
         Creates an empty matrix in the AequilibraE format
@@ -248,13 +248,13 @@ def get_matrix(self, core: str, copy=False) -> np.ndarray:
             return mat
 
     def create_from_omx(
-            self,
-            file_path: str,
-            omx_path: str,
-            cores: List[str] = None,
-            mappings: List[str] = None,
-            robust: bool = True,
-            compressed: bool = False,
+        self,
+        file_path: str,
+        omx_path: str,
+        cores: List[str] = None,
+        mappings: List[str] = None,
+        robust: bool = True,
+        compressed: bool = False,
     ) -> None:
         """
         Creates an AequilibraeMatrix from an original OpenMatrix
@@ -810,10 +810,10 @@ def computational_view(self, core_list: List[str] = None):
                 self.matrix_view = self.matrices[:, :, idx1]
             elif len(core_list) > 1:
                 idx2 = self.names.index(core_list[-1])
-                self.matrix_view = self.matrices[:, :, idx1: idx2 + 1]
+                self.matrix_view = self.matrices[:, :, idx1 : idx2 + 1]
 
     def copy(
-            self, output_name: str = None, cores: List[str] = None, names: List[str] = None, compress: bool = None
+        self, output_name: str = None, cores: List[str] = None, names: List[str] = None, compress: bool = None
     ) -> None:
         """
         Copies a list of cores (or all cores) from one matrix file to another one
diff --git a/aequilibrae/parameters.py b/aequilibrae/parameters.py
index fe1607113..d63acc8a3 100644
--- a/aequilibrae/parameters.py
+++ b/aequilibrae/parameters.py
@@ -33,9 +33,9 @@ class Parameters:
     """
 
     def __init__(self):
-        """ Loads parameters from file. The place is always the same. The root of the package"""
+        """Loads parameters from file. The place is always the same. The root of the package"""
 
-        proj_path = os.environ.get('AEQUILIBRAE_PROJECT_PATH', '')
+        proj_path = os.environ.get("AEQUILIBRAE_PROJECT_PATH", "")
         default_path = os.path.dirname(os.path.realpath(__file__))
 
         self.file = os.path.join(proj_path, "parameters.yml")
@@ -50,7 +50,7 @@ def __init__(self):
         else:
             self.parameters = deepcopy(self._default)
             if proj_path:
-                warn('No pre-existing parameter file exists for this project. Will use default')
+                warn("No pre-existing parameter file exists for this project. Will use default")
 
     def write_back(self):
         """Writes the parameters back to file"""
diff --git a/aequilibrae/paths/all_or_nothing.py b/aequilibrae/paths/all_or_nothing.py
index bbf9e6cdd..445818c70 100644
--- a/aequilibrae/paths/all_or_nothing.py
+++ b/aequilibrae/paths/all_or_nothing.py
@@ -76,8 +76,9 @@ def execute(self):
         pool.join()
         # TODO: Multi-thread this sum
         self.results.compact_link_loads = np.sum(self.aux_res.temp_link_loads, axis=2)
-        assign_link_loads(self.results.link_loads, self.results.compact_link_loads,
-                          self.results.crosswalk, self.results.cores)
+        assign_link_loads(
+            self.results.link_loads, self.results.compact_link_loads, self.results.crosswalk, self.results.cores
+        )
         if pyqt:
             self.assignment.emit(["finished_threaded_procedure", None])
 
diff --git a/aequilibrae/paths/assignment_paths.py b/aequilibrae/paths/assignment_paths.py
index 76e96adcd..3daecdd42 100644
--- a/aequilibrae/paths/assignment_paths.py
+++ b/aequilibrae/paths/assignment_paths.py
@@ -59,7 +59,7 @@ def get_traffic_class_names_and_id(self) -> List[TrafficClassIdentifier]:
 
 
 class AssignmentPaths(object):
-    """ Class for accessing path files optionally generated during assignment.
+    """Class for accessing path files optionally generated during assignment.
     ::
         paths = AssignmentPath(table_name_with_assignment_results)
         paths.get_path_for_destination(origin, destination, iteration, traffic_class_id)
@@ -102,13 +102,13 @@ def read_path_file(self, origin: int, iteration: int, traffic_class_id: str) ->
         return path_o, path_o_index
 
     def get_path_for_destination(self, origin: int, destination: int, iteration: int, traffic_class_id: str):
-        """ Return all link ids, i.e. the full path, for a given destination"""
+        """Return all link ids, i.e. the full path, for a given destination"""
         path_o, path_o_index = self.read_path_file(origin, iteration, traffic_class_id)
         return self.get_path_for_destination_from_files(path_o, path_o_index, destination)
 
     @staticmethod
     def get_path_for_destination_from_files(path_o: pd.DataFrame, path_o_index: pd.DataFrame, destination: int):
-        """ for a given path file and path index file, and a given destination, return the path links in o-d order"""
+        """for a given path file and path index file, and a given destination, return the path links in o-d order"""
         if destination == 0:
             lower_incl = 0
         else:
diff --git a/aequilibrae/paths/graph.py b/aequilibrae/paths/graph.py
index 4343c82a7..728057c47 100644
--- a/aequilibrae/paths/graph.py
+++ b/aequilibrae/paths/graph.py
@@ -633,7 +633,7 @@ def __determine_types__(self, new_type, current_type):
         return def_type
 
     def save_compressed_correspondence(self, path, mode_name, mode_id):
-        """ Save graph and nodes_to_indices to disk"""
+        """Save graph and nodes_to_indices to disk"""
         graph_path = join(path, f"correspondence_c{mode_name}_{mode_id}.feather")
         self.graph.to_feather(graph_path)
         node_path = join(path, f"nodes_to_indices_c{mode_name}_{mode_id}.feather")
diff --git a/aequilibrae/paths/results/assignment_results.py b/aequilibrae/paths/results/assignment_results.py
index 707546d3f..bfa9b9e1d 100644
--- a/aequilibrae/paths/results/assignment_results.py
+++ b/aequilibrae/paths/results/assignment_results.py
@@ -138,7 +138,7 @@ def __redim(self):
         self.reset()
 
     def total_flows(self) -> None:
-        """ Totals all link flows for this class into a single link load
+        """Totals all link flows for this class into a single link load
 
         Results are placed into *total_link_loads* class member
         """
@@ -212,7 +212,7 @@ def get_load_results(self) -> AequilibraeData:
         return res
 
     def save_to_disk(self, file_name=None, output="loads") -> None:
-        """ Function to write to disk all outputs computed during assignment
+        """Function to write to disk all outputs computed during assignment
 
         Args:
             *file_name* (:obj:`str`): Name of the file, with extension. Valid extensions are: ['aed', 'csv', 'sqlite']
diff --git a/aequilibrae/paths/results/path_results.py b/aequilibrae/paths/results/path_results.py
index d0cbc87c0..42dcf8639 100644
--- a/aequilibrae/paths/results/path_results.py
+++ b/aequilibrae/paths/results/path_results.py
@@ -6,7 +6,7 @@
 try:
     from aequilibrae.paths.AoN import update_path_trace, path_computation
 except ImportError as ie:
-    logger.warning(f'Could not import procedures from the binary. {ie.args}')
+    logger.warning(f"Could not import procedures from the binary. {ie.args}")
 
 
 class PathResults:
@@ -81,7 +81,7 @@ def compute_path(self, origin: int, destination: int) -> None:
         """
 
         if self.graph is None:
-            raise Exception('You need to set graph skimming before you compute a path')
+            raise Exception("You need to set graph skimming before you compute a path")
 
         path_computation(origin, destination, self.graph, self)
         if self.graph.skim_fields:
diff --git a/aequilibrae/paths/traffic_assignment.py b/aequilibrae/paths/traffic_assignment.py
index 7e08f61a4..7e14476a2 100644
--- a/aequilibrae/paths/traffic_assignment.py
+++ b/aequilibrae/paths/traffic_assignment.py
@@ -512,13 +512,13 @@ def results(self) -> pd.DataFrame:
     def report(self) -> pd.DataFrame:
         """Returns the assignment convergence report
 
-         Returns:
-            *DataFrame* (:obj:`pd.DataFrame`): Convergence report
+        Returns:
+           *DataFrame* (:obj:`pd.DataFrame`): Convergence report
         """
         return pd.DataFrame(self.assignment.convergence_report)
 
     def info(self) -> dict:
-        """ Returns information for the traffic assignment procedure
+        """Returns information for the traffic assignment procedure
 
         Dictionary contains keys  'Algorithm', 'Classes', 'Computer name', 'Procedure ID',
         'Maximum iterations' and 'Target RGap'.
@@ -610,8 +610,11 @@ def save_skims(self, matrix_name: str, which_ones="final", format="omx") -> None
             # We will want only the time for the last iteration and the distance averaged out for all iterations
             working_name = export_name if mat_format == "aem" else AequilibraeMatrix().random_name()
 
-            kwargs = {"file_name": working_name, "zones": self.classes[0].graph.centroids.shape[0],
-                      "matrix_names": names}
+            kwargs = {
+                "file_name": working_name,
+                "zones": self.classes[0].graph.centroids.shape[0],
+                "matrix_names": names,
+            }
 
             # Create the matrix to manipulate
             out_skims = AequilibraeMatrix()
diff --git a/aequilibrae/paths/vdf.py b/aequilibrae/paths/vdf.py
index bb846a48e..d76e1d4ad 100644
--- a/aequilibrae/paths/vdf.py
+++ b/aequilibrae/paths/vdf.py
@@ -48,6 +48,5 @@ def __setattr__(self, instance, value) -> None:
             raise AttributeError("This class only allows you to set the VDF to use")
 
     def functions_available(self) -> list:
-        """returns a list of all functions available
-        """
+        """returns a list of all functions available"""
         return all_vdf_functions
diff --git a/aequilibrae/project/about.py b/aequilibrae/project/about.py
index ef9a8d36e..b4a2fd544 100644
--- a/aequilibrae/project/about.py
+++ b/aequilibrae/project/about.py
@@ -10,14 +10,14 @@
 
 class About:
     """Provides an interface for querying and editing the **about** table of an AequilibraE project
-        ::
+    ::
 
-            p = Project()
-            p.open('my/project/folder')
-            about = p.about
+        p = Project()
+        p.open('my/project/folder')
+        about = p.about
 
-            about.description = 'This is the example project. Do not use for forecast'
-            about.write_back()
+        about.description = 'This is the example project. Do not use for forecast'
+        about.write_back()
 
 
     """
@@ -33,7 +33,7 @@ def create(self):
         """Creates the 'about' table for project files that did not previously contain it"""
 
         if not self.__has_about():
-            qry_file = join(dirname(realpath(__file__)), 'database_specification', 'tables', 'about.sql')
+            qry_file = join(dirname(realpath(__file__)), "database_specification", "tables", "about.sql")
             run_queries_from_sql_file(self.__conn, qry_file)
 
         cursor = self.__conn.cursor()
@@ -47,7 +47,7 @@ def create(self):
 
             self.__load()
         else:
-            warn('About table already exists. Nothing was done', Warning)
+            warn("About table already exists. Nothing was done", Warning)
 
     def list_fields(self) -> list:
         """Returns a list of all characteristics the about table holds"""
@@ -57,23 +57,23 @@ def list_fields(self) -> list:
     def add_info_field(self, info_field: str) -> None:
         """Adds new information field to the model
 
-            Args:
-                *info_field* (:obj:`str`): Name of the desired information field to be added.  Has to be a valid
-                Python VARIABLE name (i.e. letter as first character, no spaces and no special characters)
+        Args:
+            *info_field* (:obj:`str`): Name of the desired information field to be added.  Has to be a valid
+            Python VARIABLE name (i.e. letter as first character, no spaces and no special characters)
 
-            ::
+        ::
 
-                p = Project()
-                p.open('my/project/folder')
-                p.about.add_info_field('my_super_relevant_field')
-                p.about.my_super_relevant_field = 'super relevant information'
-                p.about.write_back()
+            p = Project()
+            p.open('my/project/folder')
+            p.about.add_info_field('my_super_relevant_field')
+            p.about.my_super_relevant_field = 'super relevant information'
+            p.about.write_back()
         """
-        allowed = string.ascii_lowercase + '_'
+        allowed = string.ascii_lowercase + "_"
         has_forbidden = [x for x in info_field if x not in allowed]
 
         if has_forbidden:
-            raise ValueError(f'{info_field} is not valid as a metadata field. Should be a lower case ascii letter or _')
+            raise ValueError(f"{info_field} is not valid as a metadata field. Should be a lower case ascii letter or _")
 
         sql = "INSERT INTO 'about' (infoname) VALUES(?)"
         curr = self.__conn.cursor()
@@ -85,25 +85,25 @@ def add_info_field(self, info_field: str) -> None:
     def write_back(self):
         """Saves the information parameters back to the project database
 
-            ::
+        ::
 
-                p = Project()
-                p.open('my/project/folder')
-                p.about.description = 'This is the example project. Do not use for forecast'
-                p.about.write_back()
+            p = Project()
+            p.open('my/project/folder')
+            p.about.description = 'This is the example project. Do not use for forecast'
+            p.about.write_back()
         """
         curr = self.__conn.cursor()
         for k in self.__characteristics:
             v = self.__dict__[k]
             if v != self.__original[k]:
                 curr.execute("UPDATE 'about' set infovalue = ? where infoname=?", [v, k])
-                logger.info(f'Updated {k} on About_Table to {v}')
+                logger.info(f"Updated {k} on About_Table to {v}")
         self.__conn.commit()
 
     def __has_about(self):
         curr = self.__conn.cursor()
         curr.execute("SELECT name FROM sqlite_master WHERE type='table';")
-        return any(['about' in x[0] for x in curr.fetchall()])
+        return any(["about" in x[0] for x in curr.fetchall()])
 
     def __load(self):
         self.__characteristics = []
diff --git a/aequilibrae/project/basic_table.py b/aequilibrae/project/basic_table.py
index a26a19b83..1c9cadfa7 100644
--- a/aequilibrae/project/basic_table.py
+++ b/aequilibrae/project/basic_table.py
@@ -11,7 +11,7 @@ class BasicTable:
     """
 
     def __init__(self):
-        self.__table_type__ = ''
+        self.__table_type__ = ""
         self.conn = database_connection()
         self._curr = self.conn.cursor()
 
diff --git a/aequilibrae/project/data/matrices.py b/aequilibrae/project/data/matrices.py
index c65632ee8..1c26bf0b2 100644
--- a/aequilibrae/project/data/matrices.py
+++ b/aequilibrae/project/data/matrices.py
@@ -85,7 +85,7 @@ def update_database(self) -> None:
             rec.save()
 
     def list(self) -> pd.DataFrame:
-        """ List of all matrices available
+        """List of all matrices available
         Returns:
              df (:obj:`pd.DataFrame`:) Pandas DataFrame listing all matrices available in the model
         """
diff --git a/aequilibrae/project/data/matrix_record.py b/aequilibrae/project/data/matrix_record.py
index ac3d78a17..461d06476 100644
--- a/aequilibrae/project/data/matrix_record.py
+++ b/aequilibrae/project/data/matrix_record.py
@@ -11,20 +11,20 @@ class MatrixRecord(SafeClass):
     def __init__(self, data_set: dict):
         super().__init__(data_set)
         self._exists = True
-        self.fldr = join(os.environ.get(ENVIRON_VAR), 'matrices')
+        self.fldr = join(os.environ.get(ENVIRON_VAR), "matrices")
 
     def save(self):
         """Saves matrix record to the project database"""
         conn = database_connection()
         curr = conn.cursor()
 
-        curr.execute('select count(*) from matrices where name=?', [self.name])
+        curr.execute("select count(*) from matrices where name=?", [self.name])
         if curr.fetchone()[0] == 0:
             data = [str(self.name), str(self.file_name), int(self.cores)]
-            curr.execute('Insert into matrices (name, file_name, cores) values(?,?,?)', data)
+            curr.execute("Insert into matrices (name, file_name, cores) values(?,?,?)", data)
 
         for key, value in self.__dict__.items():
-            if key != 'name' and key in self.__original__:
+            if key != "name" and key in self.__original__:
                 v_old = self.__original__.get(key, None)
                 if value != v_old and value:
                     self.__original__[key] = value
@@ -36,20 +36,20 @@ def delete(self):
         """Deletes this matrix record and the underlying data from disk"""
         conn = database_connection()
         curr = conn.cursor()
-        curr.execute('DELETE FROM matrices where name=?', [self.name])
+        curr.execute("DELETE FROM matrices where name=?", [self.name])
         conn.commit()
         if isfile(join(self.fldr, self.file_name)):
             try:
                 unlink(join(self.fldr, self.file_name))
             except Exception as e:
-                logger.error(f'Could not remove matrix from disk: {e.args}')
+                logger.error(f"Could not remove matrix from disk: {e.args}")
 
         conn.close()
         self._exists = False
 
     def update_cores(self):
         """Updates this matrix record with the matrix core count in disk"""
-        self.__dict__['cores'] = self.__get_cores()
+        self.__dict__["cores"] = self.__get_cores()
 
     def get_data(self) -> AequilibraeMatrix:
         """Returns the actual matrix for further computation
@@ -62,24 +62,24 @@ def get_data(self) -> AequilibraeMatrix:
         return mat
 
     def __setattr__(self, instance, value) -> None:
-        if instance == 'name':
+        if instance == "name":
             value = str(value).lower()
             conn = database_connection()
             curr = conn.cursor()
-            curr.execute('Select count(*) from matrices where LOWER(name)=?', [value])
+            curr.execute("Select count(*) from matrices where LOWER(name)=?", [value])
             if sum(curr.fetchone()) > 0:
-                raise ValueError('Another matrix with this name already exists')
+                raise ValueError("Another matrix with this name already exists")
             conn.close()
-        elif instance == 'file_name':
+        elif instance == "file_name":
             conn = database_connection()
             curr = conn.cursor()
-            curr.execute('Select count(*) from matrices where LOWER(file_name)=?', [str(value).lower()])
+            curr.execute("Select count(*) from matrices where LOWER(file_name)=?", [str(value).lower()])
             if sum(curr.fetchone()) > 0:
-                raise ValueError('There is another matrix record for this file')
+                raise ValueError("There is another matrix record for this file")
 
         self.__dict__[instance] = value
-        if instance in ['file_name', 'cores']:
-            self.__dict__['cores'] = self.__get_cores()
+        if instance in ["file_name", "cores"]:
+            self.__dict__["cores"] = self.__get_cores()
 
     def __get_cores(self) -> int:
         mat = AequilibraeMatrix()
diff --git a/aequilibrae/project/data_loader.py b/aequilibrae/project/data_loader.py
index 68a93efb4..cfe7bb21e 100644
--- a/aequilibrae/project/data_loader.py
+++ b/aequilibrae/project/data_loader.py
@@ -3,7 +3,7 @@
 import pandas as pd
 
 
-class DataLoader():
+class DataLoader:
     def __init__(self, conn: Connection, table_name: str):
         self.conn = conn
         self.curr = conn.cursor()
@@ -14,14 +14,14 @@ def load_table(self) -> pd.DataFrame:
         fields = [f'"{x}"' for x in fields]
         if geo_field is not None:
             fields.append('ST_AsBinary("geometry") geometry')
-        keys = ','.join(fields)
+        keys = ",".join(fields)
         df = pd.read_sql_query(f"select {keys} from '{self.table_name}'", self.conn)
         df.geometry = df.geometry.apply(shapely.wkb.loads)
         return df
 
     def __find_table_fields(self):
-        geotypes = ['LINESTRING', 'POINT', 'POLYGON', 'MULTIPOLYGON']
-        self.curr.execute(f'pragma table_info({self.table_name})')
+        geotypes = ["LINESTRING", "POINT", "POLYGON", "MULTIPOLYGON"]
+        self.curr.execute(f"pragma table_info({self.table_name})")
         structure = self.curr.fetchall()
         fields = [x[1].lower() for x in structure]
         geotype = geo_field = None
diff --git a/aequilibrae/project/network/link.py b/aequilibrae/project/network/link.py
index 221af6593..fdaec5b19 100644
--- a/aequilibrae/project/network/link.py
+++ b/aequilibrae/project/network/link.py
@@ -45,14 +45,15 @@ class Link(SafeClass):
         # We can just save the link
         link1.save()
         link2.save()
-        """
+    """
+
     def __init__(self, dataset):
         super().__init__(dataset)
         self.__fields = list(dataset.keys())
 
-        self.__new = dataset['geometry'] is None
+        self.__new = dataset["geometry"] is None
         self.__stil_exists = True
-        self._table = 'links'
+        self._table = "links"
 
     def delete(self):
         """Deletes link from database"""
@@ -90,9 +91,9 @@ def set_modes(self, modes: str):
         """
 
         if not isinstance(modes, str):
-            raise ValueError('Modes field needs to be a string')
-        if modes == '':
-            raise ValueError('Modes field needs to have at least one mode')
+            raise ValueError("Modes field needs to be a string")
+        if modes == "":
+            raise ValueError("Modes field needs to have at least one mode")
 
         self.__dict__["modes"] = modes
 
@@ -107,7 +108,7 @@ def add_mode(self, mode: [str, Mode]):
         mode_id = self.__validate(mode)
 
         if mode_id in self.modes:
-            logger.warning('Mode already active for this link')
+            logger.warning("Mode already active for this link")
             return
 
         self.__dict__["modes"] += mode_id
@@ -124,13 +125,13 @@ def drop_mode(self, mode: [str, Mode]):
         mode_id = self.__validate(mode)
 
         if mode_id not in self.modes:
-            logger.warning('Mode already inactive for this link')
+            logger.warning("Mode already inactive for this link")
             return
 
         if len(self.modes) == 1:
-            raise ValueError('Link needs to have at least one mode')
+            raise ValueError("Link needs to have at least one mode")
 
-        self.__dict__['modes'] = self.modes.replace(mode_id, '')
+        self.__dict__["modes"] = self.modes.replace(mode_id, "")
 
     def data_fields(self) -> list:
         """lists all data fields for the link, as available in the database
@@ -149,48 +150,48 @@ def __validate(self, mode: [str, Mode]) -> str:
             mode_id = mode.mode_id
         elif isinstance(mode, str):
             if len(mode) > 1:
-                raise ValueError('A mode_id is a single character')
+                raise ValueError("A mode_id is a single character")
             mode_id = mode
         else:
-            raise TypeError('You should provide a mode id (string) or a Mode object')
+            raise TypeError("You should provide a mode id (string) or a Mode object")
         return mode_id
 
     def __save_existing_link(self):
         data = []
-        if self.link_id != self.__original__['link_id']:
-            raise ValueError('One cannot change the link_id')
+        if self.link_id != self.__original__["link_id"]:
+            raise ValueError("One cannot change the link_id")
 
         txts = []
         for key, val in self.__dict__.items():
             if key not in self.__original__:
                 continue
             if val != self.__original__[key]:
-                if key == 'geometry' and val is not None:
+                if key == "geometry" and val is not None:
                     data.extend([val.wkb, self.__srid__])
-                    txts.append('geometry=GeomFromWKB(?, ?)')
+                    txts.append("geometry=GeomFromWKB(?, ?)")
                 else:
                     data.append(val)
                     txts.append(f'"{key}"=?')
 
         if not data:
-            logger.warning(f'Nothing to update for link {self.link_id}')
-            return [], ''
+            logger.warning(f"Nothing to update for link {self.link_id}")
+            return [], ""
 
-        txts = ','.join(txts) + ' where link_id=?'
+        txts = ",".join(txts) + " where link_id=?"
         data.append(self.link_id)
-        sql = f'Update Links set {txts}'
+        sql = f"Update Links set {txts}"
         return data, sql
 
     def __setattr__(self, instance, value) -> None:
         if instance not in self.__dict__ and instance[:1] != "_":
             raise AttributeError(f'"{instance}" is not a valid attribute for a link')
-        if instance == 'modes':
+        if instance == "modes":
             self.set_modes(value)
-        elif instance == 'a_node':
-            raise AttributeError('Setting a_node is not allowed')
-        elif instance == 'b_node':
-            raise AttributeError('Setting b_node is not allowed')
-        elif instance == 'link_id':
-            raise ValueError('Changing a link_id is not supported. Create a new one and delete this')
+        elif instance == "a_node":
+            raise AttributeError("Setting a_node is not allowed")
+        elif instance == "b_node":
+            raise AttributeError("Setting b_node is not allowed")
+        elif instance == "link_id":
+            raise ValueError("Changing a link_id is not supported. Create a new one and delete this")
         else:
             self.__dict__[instance] = value
diff --git a/aequilibrae/project/network/link_type.py b/aequilibrae/project/network/link_type.py
index 4f0f3a16a..be7a6dc8a 100644
--- a/aequilibrae/project/network/link_type.py
+++ b/aequilibrae/project/network/link_type.py
@@ -5,7 +5,8 @@
 
 class LinkType(SafeClass):
     """A link_type object represents a single record in the *link_types* table"""
-    __alowed_characters = string.ascii_letters + '_'
+
+    __alowed_characters = string.ascii_letters + "_"
 
     def delete(self):
         conn = database_connection()
@@ -21,10 +22,10 @@ def save(self):
         curr.execute(f'select count(*) from link_types where link_type_id="{self.link_type_id}"')
         if curr.fetchone()[0] == 0:
             data = [self.link_type_id, self.link_type]
-            curr.execute('Insert into link_types (link_type_id, link_type) values(?,?)', data)
+            curr.execute("Insert into link_types (link_type_id, link_type) values(?,?)", data)
 
         for key, value in self.__dict__.items():
-            if key != 'link_type_id' and key in self.__original__:
+            if key != "link_type_id" and key in self.__original__:
                 v_old = self.__original__.get(key, None)
                 if value != v_old and value is not None:
                     self.__original__[key] = value
@@ -33,16 +34,16 @@ def save(self):
         conn.close()
 
     def __setattr__(self, instance, value) -> None:
-        if instance == 'link_type':
+        if instance == "link_type":
             if isinstance(value, str):
                 if not len(value):
-                    raise ValueError('link_type cannot be zero-length')
+                    raise ValueError("link_type cannot be zero-length")
                 for letter in value:
                     if letter not in self.__alowed_characters:
                         raise ValueError('link_type can only contain letters and "_"')
             else:
-                raise ValueError('link_type must be string')
-        if instance == 'link_type_id':
-            raise ValueError('Changing a link_type_id is not supported. Create a new one and delete this')
+                raise ValueError("link_type must be string")
+        if instance == "link_type_id":
+            raise ValueError("Changing a link_type_id is not supported. Create a new one and delete this")
         else:
             self.__dict__[instance] = value
diff --git a/aequilibrae/project/network/link_types.py b/aequilibrae/project/network/link_types.py
index 983e3e357..511543b22 100644
--- a/aequilibrae/project/network/link_types.py
+++ b/aequilibrae/project/network/link_types.py
@@ -57,6 +57,7 @@ class LinkTypes:
         new_type.save()
 
     """
+
     __items = {}
 
     def __init__(self, net):
@@ -65,13 +66,13 @@ def __init__(self, net):
         self.curr = net.conn.cursor()
 
         tl = TableLoader()
-        link_types_list = tl.load_table(self.curr, 'link_types')
-        existing_list = [lt['link_type_id'] for lt in link_types_list]
+        link_types_list = tl.load_table(self.curr, "link_types")
+        existing_list = [lt["link_type_id"] for lt in link_types_list]
 
         self.__fields = [x for x in tl.fields]
         for lt in link_types_list:
-            if lt['link_type_id'] not in self.__items:
-                self.__items[lt['link_type_id']] = LinkType(lt)
+            if lt["link_type_id"] not in self.__items:
+                self.__items[lt["link_type_id"]] = LinkType(lt)
 
         to_del = [key for key in self.__items.keys() if key not in existing_list]
         for key in to_del:
@@ -79,13 +80,13 @@ def __init__(self, net):
 
     def new(self, link_type_id: str) -> LinkType:
         if link_type_id in self.__items:
-            raise ValueError(f'Link Type ID ({link_type_id}) already exists in the model. It must be unique.')
+            raise ValueError(f"Link Type ID ({link_type_id}) already exists in the model. It must be unique.")
 
         tp = {key: None for key in self.__fields}
-        tp['link_type_id'] = link_type_id
+        tp["link_type_id"] = link_type_id
         lt = LinkType(tp)
         self.__items[link_type_id] = lt
-        logger.warning('Link type has not yet been saved to the database. Do so explicitly')
+        logger.warning("Link type has not yet been saved to the database. Do so explicitly")
         return lt
 
     def delete(self, link_type_id: str) -> None:
@@ -96,14 +97,14 @@ def delete(self, link_type_id: str) -> None:
             del self.__items[link_type_id]
             self.conn.commit()
         except IntegrityError as e:
-            logger.error(f'Failed to remove link_type {link_type_id}. {e.args}')
+            logger.error(f"Failed to remove link_type {link_type_id}. {e.args}")
             raise e
-        logger.warning(f'Link type {link_type_id} was successfully removed from the project database')
+        logger.warning(f"Link type {link_type_id} was successfully removed from the project database")
 
     def get(self, link_type_id: str) -> LinkType:
         """Get a link_type from the network by its **link_type_id**"""
         if link_type_id not in self.__items:
-            raise ValueError(f'Link type {link_type_id} does not exist in the model')
+            raise ValueError(f"Link type {link_type_id} does not exist in the model")
         return self.__items[link_type_id]
 
     def get_by_name(self, link_type: str) -> LinkType:
@@ -114,7 +115,7 @@ def get_by_name(self, link_type: str) -> LinkType:
 
     def fields(self) -> FieldEditor:
         """Returns a FieldEditor class instance to edit the Link_Types table fields and their metadata"""
-        return FieldEditor('link_types')
+        return FieldEditor("link_types")
 
     def all_types(self) -> dict:
         """Returns a dictionary with all LinkType objects available in the model. link_type_id as key"""
@@ -125,10 +126,10 @@ def save(self):
             lt.save()
 
     def __copy__(self):
-        raise Exception('Link Types object cannot be copied')
+        raise Exception("Link Types object cannot be copied")
 
     def __deepcopy__(self, memodict=None):
-        raise Exception('Link Types object cannot be copied')
+        raise Exception("Link Types object cannot be copied")
 
     def __del__(self):
         self.__items.clear()
diff --git a/aequilibrae/project/network/links.py b/aequilibrae/project/network/links.py
index e01b23986..2be9d9f3c 100644
--- a/aequilibrae/project/network/links.py
+++ b/aequilibrae/project/network/links.py
@@ -42,7 +42,7 @@ class Links(BasicTable):
 
     def __init__(self):
         super().__init__()
-        self.__table_type__ = 'links'
+        self.__table_type__ = "links"
         if self.sql == "":
             self.refresh_fields()
 
@@ -56,7 +56,7 @@ def get(self, link_id: int) -> Link:
 
         Returns:
             *link* (:obj:`Link`): Link object for requested link_id
-            """
+        """
         link_id = int(link_id)
         if link_id in self.__items:
             link = self.__items[link_id]
@@ -71,9 +71,9 @@ def get(self, link_id: int) -> Link:
     def new(self) -> Link:
         """Creates a new link
 
-            Returns:
-                *link* (:obj:`Link`): A new link object populated only with link_id (not saved in the model yet)
-                """
+        Returns:
+            *link* (:obj:`Link`): A new link object populated only with link_id (not saved in the model yet)
+        """
 
         data = {key: None for key in self.__fields}
         data["direction"] = 0
@@ -92,7 +92,7 @@ def copy_link(self, link_id: int) -> Link:
 
         Returns:
             *link* (:obj:`Link`): Link object for requested link_id
-            """
+        """
 
         data = self.__link_data(int(link_id))
         data["link_id"] = self.__new_link_id()
@@ -136,7 +136,7 @@ def refresh_fields(self) -> None:
 
     @property
     def data(self) -> pd.DataFrame:
-        """ Returns all links data as a Pandas dataFrame
+        """Returns all links data as a Pandas dataFrame
 
         Returns:
             *table* (:obj:`DataFrame`): Pandas dataframe with all the links, complete with Geometry
diff --git a/aequilibrae/project/network/mode.py b/aequilibrae/project/network/mode.py
index a1a2c7ef7..a05e8d89a 100644
--- a/aequilibrae/project/network/mode.py
+++ b/aequilibrae/project/network/mode.py
@@ -6,18 +6,19 @@
 
 class Mode:
     """A mode object represents a single record in the *modes* table"""
-    __alowed_characters = string.ascii_letters + '_'
+
+    __alowed_characters = string.ascii_letters + "_"
 
     def __init__(self, mode_id: str) -> None:
         if mode_id is None:
-            raise ValueError('Mode IDs cannot be None')
+            raise ValueError("Mode IDs cannot be None")
 
         if len(mode_id) != 1 or mode_id not in string.ascii_letters:
-            raise ValueError('Mode IDs must be a single ascii character')
+            raise ValueError("Mode IDs must be a single ascii character")
         conn = database_connection()
         curr = conn.cursor()
 
-        curr.execute('pragma table_info(modes)')
+        curr.execute("pragma table_info(modes)")
         table_struct = curr.fetchall()
         self.__fields = [x[1] for x in table_struct]
         self.__original__ = {}
@@ -30,8 +31,8 @@ def __init__(self, mode_id: str) -> None:
             for k in self.__fields:
                 self.__dict__[k] = None
                 self.__original__[k] = None
-            self.__dict__['mode_id'] = mode_id
-            self.__original__['mode_id'] = mode_id
+            self.__dict__["mode_id"] = mode_id
+            self.__original__["mode_id"] = mode_id
         else:
             for k, v in zip(self.__fields, dt):
                 self.__dict__[k] = v
@@ -39,17 +40,17 @@ def __init__(self, mode_id: str) -> None:
         conn.close()
 
     def __setattr__(self, instance, value) -> None:
-        if instance == 'mode_name' and value is None:
-            raise ValueError('mode_name cannot be None')
+        if instance == "mode_name" and value is None:
+            raise ValueError("mode_name cannot be None")
 
-        if instance == 'mode_id':
-            raise ValueError('Changing a mode_id is not supported. Create a new one and delete this one')
+        if instance == "mode_id":
+            raise ValueError("Changing a mode_id is not supported. Create a new one and delete this one")
         else:
             self.__dict__[instance] = value
 
     def save(self):
         if self.mode_id not in self.__alowed_characters:
-            raise ValueError('mode_id needs to be a ascii letter')
+            raise ValueError("mode_id needs to be a ascii letter")
 
         for letter in self.mode_name:
             if letter not in self.__alowed_characters:
@@ -62,11 +63,11 @@ def save(self):
         if curr.fetchone()[0] == 0:
             raise ValueError("Mode does not exist in the model. You need to explicitly add it")
 
-        curr.execute('pragma table_info(modes)')
+        curr.execute("pragma table_info(modes)")
         table_struct = [x[1] for x in curr.fetchall()]
 
         for key, value in self.__dict__.items():
-            if key in table_struct and key != 'mode_id':
+            if key in table_struct and key != "mode_id":
                 v_old = self.__original__.get(key, None)
                 if value != v_old and value is not None:
                     self.__original__[key] = value
diff --git a/aequilibrae/project/network/modes.py b/aequilibrae/project/network/modes.py
index 845e78074..2321ec3dc 100644
--- a/aequilibrae/project/network/modes.py
+++ b/aequilibrae/project/network/modes.py
@@ -53,6 +53,7 @@ class Modes:
         new_mode.description = 'this is my new description'
         new_mode.save()
     """
+
     __items = {}
 
     def __init__(self, net):
@@ -62,14 +63,14 @@ def __init__(self, net):
         self.__update_list_of_modes()
 
     def add(self, mode: Mode) -> None:
-        """ We add a mode to the project"""
+        """We add a mode to the project"""
         self.__update_list_of_modes()
         if mode.mode_id in self.__all_modes:
             raise ValueError("Mode already exists in the model")
 
         self.curr.execute("insert into 'modes'(mode_id, mode_name) Values(?,?)", [mode.mode_id, mode.mode_name])
         self.conn.commit()
-        logger.info(f'mode {mode.mode_name}({mode.mode_id}) was added to the project')
+        logger.info(f"mode {mode.mode_name}({mode.mode_id}) was added to the project")
         mode.save()
         self.__update_list_of_modes()
 
@@ -79,21 +80,21 @@ def delete(self, mode_id: str) -> None:
             self.curr.execute(f'delete from modes where mode_id="{mode_id}"')
             self.conn.commit()
         except IntegrityError as e:
-            logger.error(f'Failed to remove mode {mode_id}. {e.args}')
+            logger.error(f"Failed to remove mode {mode_id}. {e.args}")
             raise e
-        logger.warning(f'Mode {mode_id} was successfully removed from the database')
+        logger.warning(f"Mode {mode_id} was successfully removed from the database")
         self.__update_list_of_modes()
 
     @property
     def fields(self) -> FieldEditor:
         """Returns a FieldEditor class instance to edit the Modes table fields and their metadata"""
-        return FieldEditor('modes')
+        return FieldEditor("modes")
 
     def get(self, mode_id: str) -> Mode:
         """Get a mode from the network by its **mode_id**"""
         self.__update_list_of_modes()
         if mode_id not in self.__all_modes:
-            raise ValueError(f'Mode {mode_id} does not exist in the model')
+            raise ValueError(f"Mode {mode_id} does not exist in the model")
         return Mode(mode_id)
 
     def get_by_name(self, mode: str) -> Mode:
@@ -102,7 +103,7 @@ def get_by_name(self, mode: str) -> Mode:
         self.curr.execute(f"select mode_id from 'modes' where mode_name='{mode}'")
         found = self.curr.fetchone()
         if len(found) == 0:
-            raise ValueError(f'Mode {mode} does not exist in the model')
+            raise ValueError(f"Mode {mode} does not exist in the model")
         return Mode(found[0])
 
     def all_modes(self) -> dict:
@@ -122,10 +123,10 @@ def __update_list_of_modes(self) -> None:
         self.__all_modes = [x[0] for x in self.curr.fetchall()]
 
     def __copy__(self):
-        raise Exception('Modes object cannot be copied')
+        raise Exception("Modes object cannot be copied")
 
     def __deepcopy__(self, memodict=None):
-        raise Exception('Modes object cannot be copied')
+        raise Exception("Modes object cannot be copied")
 
     def __del__(self):
         self.__items.clear()
@@ -133,4 +134,4 @@ def __del__(self):
     def __has_mode(self):
         curr = self.conn.cursor()
         curr.execute("SELECT name FROM sqlite_master WHERE type='table';")
-        return any(['modes' in x[0] for x in curr.fetchall()])
+        return any(["modes" in x[0] for x in curr.fetchall()])
diff --git a/aequilibrae/project/network/network.py b/aequilibrae/project/network/network.py
index 92a00b405..fac1ddc9b 100644
--- a/aequilibrae/project/network/network.py
+++ b/aequilibrae/project/network/network.py
@@ -34,6 +34,7 @@ class Network(WorkerThread):
     """
     Network class. Member of an AequilibraE Project
     """
+
     if pyqt:
         netsignal = SIGNAL(object)
 
@@ -116,13 +117,13 @@ def list_modes(self):
         return [x[0] for x in curr.fetchall()]
 
     def create_from_osm(
-            self,
-            west: float = None,
-            south: float = None,
-            east: float = None,
-            north: float = None,
-            place_name: str = None,
-            modes=["car", "transit", "bicycle", "walk"],
+        self,
+        west: float = None,
+        south: float = None,
+        east: float = None,
+        north: float = None,
+        place_name: str = None,
+        modes=["car", "transit", "bicycle", "walk"],
     ) -> None:
         """
         Downloads the network from Open-Street Maps
@@ -264,6 +265,7 @@ def build_graphs(self, fields: list = None, modes: list = None) -> None:
 
         """
         from aequilibrae.paths import Graph
+
         curr = self.conn.cursor()
 
         if fields is None:
@@ -353,7 +355,7 @@ def extent(self):
         return poly
 
     def convex_hull(self) -> Polygon:
-        """ Queries the model for the convex hull of the entire network
+        """Queries the model for the convex hull of the entire network
 
         Returns:
             *model coverage* (:obj:`Polygon`): Shapely (Multi)polygon of the model network.
diff --git a/aequilibrae/project/network/node.py b/aequilibrae/project/network/node.py
index d63ee50c2..4073ec49a 100644
--- a/aequilibrae/project/network/node.py
+++ b/aequilibrae/project/network/node.py
@@ -35,7 +35,7 @@ class Node(SafeClass):
 
         # We can just save the node
         node1.save()
-        """
+    """
 
     def __init__(self, dataset):
         super().__init__(dataset)
@@ -122,29 +122,29 @@ def __save_existing_node(self):
     def connect_mode(self, area: Polygon, mode_id: str, link_types="", connectors=1):
         """Adds centroid connectors for the desired mode to the network file
 
-           Centroid connectors are created by connecting the zone centroid to one or more nodes selected from
-           all those that satisfy the mode and link_types criteria and are inside the provided area.
+        Centroid connectors are created by connecting the zone centroid to one or more nodes selected from
+        all those that satisfy the mode and link_types criteria and are inside the provided area.
 
-           The selection of the nodes that will be connected is done simply by computing running the
-           `KMeans2 <https://docs.scipy.org/doc/scipy/reference/generated/scipy.cluster.vq.kmeans2.html>`_
-           clustering algorithm from SciPy and selecting the nodes closest to each cluster centroid.
+        The selection of the nodes that will be connected is done simply by computing running the
+        `KMeans2 <https://docs.scipy.org/doc/scipy/reference/generated/scipy.cluster.vq.kmeans2.html>`_
+        clustering algorithm from SciPy and selecting the nodes closest to each cluster centroid.
 
-           When there are no node candidates inside the provided area, is it progressively expanded until
-           at least one candidate is found.
+        When there are no node candidates inside the provided area, is it progressively expanded until
+        at least one candidate is found.
 
-           If fewer candidates than required connectors are found, all candidates are connected.
+        If fewer candidates than required connectors are found, all candidates are connected.
 
-               Args:
+            Args:
 
-                   *area* (:obj:`Polygon`): Initial area where AequilibraE will look for nodes to connect
+                *area* (:obj:`Polygon`): Initial area where AequilibraE will look for nodes to connect
 
-                   *mode_id* (:obj:`str`): Mode ID we are trying to connect
+                *mode_id* (:obj:`str`): Mode ID we are trying to connect
 
-                   *link_types* (:obj:`str`, `Optional`): String with all the link type IDs that can be considered.
-                   eg: yCdR. Defaults to ALL link types
+                *link_types* (:obj:`str`, `Optional`): String with all the link type IDs that can be considered.
+                eg: yCdR. Defaults to ALL link types
 
-                   *connectors* (:obj:`int`, `Optional`): Number of connectors to add. Defaults to 1
-               """
+                *connectors* (:obj:`int`, `Optional`): Number of connectors to add. Defaults to 1
+        """
         if self.is_centroid != 1 or self.__original__["is_centroid"] != 1:
             warn("Connecting a mode only makes sense for centroids and not for regular nodes")
             return
diff --git a/aequilibrae/project/network/nodes.py b/aequilibrae/project/network/nodes.py
index 165b5ef0f..9d65b37e5 100644
--- a/aequilibrae/project/network/nodes.py
+++ b/aequilibrae/project/network/nodes.py
@@ -36,7 +36,7 @@ class Nodes(BasicTable):
 
     def __init__(self):
         super().__init__()
-        self.__table_type__ = 'nodes'
+        self.__table_type__ = "nodes"
         self.__all_nodes = []
         if self.sql == "":
             self.refresh_fields()
@@ -51,7 +51,7 @@ def get(self, node_id: int) -> Node:
 
         Returns:
             *node* (:obj:`Node`): Node object for requested node_id
-            """
+        """
 
         if node_id in self.__items:
             node = self.__items[node_id]
@@ -110,7 +110,7 @@ def save(self):
 
     @property
     def data(self) -> pd.DataFrame:
-        """ Returns all nodes data as a Pandas dataFrame
+        """Returns all nodes data as a Pandas dataFrame
 
         Returns:
             *table* (:obj:`DataFrame`): Pandas dataframe with all the nodes, complete with Geometry
diff --git a/aequilibrae/project/network/osm_builder.py b/aequilibrae/project/network/osm_builder.py
index 9991ee050..a54184624 100644
--- a/aequilibrae/project/network/osm_builder.py
+++ b/aequilibrae/project/network/osm_builder.py
@@ -69,9 +69,9 @@ def data_structures(self):
         # So we get rid of everything we don't need
         for i in range(tot_items, 0, -1):
             item = self.osm_items.pop(-1)
-            if item['type'] == "way":
+            if item["type"] == "way":
                 alinks.append(item)
-            elif item['type'] == "node":
+            elif item["type"] == "node":
                 n.append(item)
             self.__emit_all(["Value", tot_items - i])
         gc.collect()
@@ -130,9 +130,9 @@ def importing_links(self, node_count):
             self.__emit_all(["Value", counter])
             counter += 1
             if counter % 1000 == 0:
-                logger.info(f'Inserting segments from {counter:,} out of {L:,} OSM link objects')
+                logger.info(f"Inserting segments from {counter:,} out of {L:,} OSM link objects")
             vars["osm_id"] = osm_id
-            vars['link_type'] = 'default'
+            vars["link_type"] = "default"
             linknodes = link["nodes"]
             linktags = link["tags"]
 
@@ -164,19 +164,22 @@ def importing_links(self, node_count):
 
             vars["modes"] = mode_codes.get(linktags.get("highway"), not_found_tags)
 
-            vars['link_type'] = self.__link_type_quick_reference.get(vars['link_type'].lower(),
-                                                                     self.__repair_link_type(vars['link_type']))
+            vars["link_type"] = self.__link_type_quick_reference.get(
+                vars["link_type"].lower(), self.__repair_link_type(vars["link_type"])
+            )
 
             if len(vars["modes"]) > 0:
                 for i in range(segments):
                     attributes = self.__build_link_data(vars, intersections, i, linknodes, node_ids, fields)
-                    sql = self.insert_qry.format(table, field_names, ','.join(['?'] * (len(attributes) - 1)))
+                    sql = self.insert_qry.format(table, field_names, ",".join(["?"] * (len(attributes) - 1)))
                     try:
                         self.curr.execute(sql, attributes)
-                        self.curr.execute('Select a_node, b_node from links where link_id=?', [vars["link_id"]])
+                        self.curr.execute("Select a_node, b_node from links where link_id=?", [vars["link_id"]])
                         a, b = self.curr.fetchone()
-                        self.curr.executemany('update nodes set osm_id=? where node_id=?',
-                                              [[linknodes[intersections[i]], a], [linknodes[intersections[i + 1]], b]])
+                        self.curr.executemany(
+                            "update nodes set osm_id=? where node_id=?",
+                            [[linknodes[intersections[i]], a], [linknodes[intersections[i + 1]], b]],
+                        )
                     except Exception as e:
                         data = list(vars.values())
                         logger.error("error when inserting link {}. Error {}".format(data, e.args))
@@ -197,13 +200,13 @@ def __worksetup(self):
 
     def __update_table_structure(self):
         curr = self.conn.cursor()
-        curr.execute('pragma table_info(Links)')
+        curr.execute("pragma table_info(Links)")
         structure = curr.fetchall()
         has_fields = [x[1].lower() for x in structure]
-        fields = [field.lower() for field in self.get_link_fields()] + ['osm_id']
+        fields = [field.lower() for field in self.get_link_fields()] + ["osm_id"]
         for field in [f for f in fields if f not in has_fields]:
             ltype = self.get_link_field_type(field).upper()
-            curr.execute(f'Alter table Links add column {field} {ltype}')
+            curr.execute(f"Alter table Links add column {field} {ltype}")
         self.conn.commit()
 
     def __build_link_data(self, vars, intersections, i, linknodes, node_ids, fields):
@@ -221,9 +224,12 @@ def __build_link_data(self, vars, intersections, i, linknodes, node_ids, fields)
             node_ids[linknodes[jj]] = vars["b_node"]
             self.node_start += 1
 
-        vars["distance"] = sum([haversine(self.nodes[x]["lon"], self.nodes[x]["lat"],
-                                          self.nodes[y]["lon"], self.nodes[y]["lat"])
-                                for x, y in zip(all_nodes[1:], all_nodes[:-1])])
+        vars["distance"] = sum(
+            [
+                haversine(self.nodes[x]["lon"], self.nodes[x]["lat"], self.nodes[y]["lon"], self.nodes[y]["lat"])
+                for x, y in zip(all_nodes[1:], all_nodes[:-1])
+            ]
+        )
 
         geometry = ["{} {}".format(self.nodes[x]["lon"], self.nodes[x]["lat"]) for x in all_nodes]
         geometry = "LINESTRING ({})".format(", ".join(geometry))
@@ -234,23 +240,23 @@ def __build_link_data(self, vars, intersections, i, linknodes, node_ids, fields)
 
     def __repair_link_type(self, link_type: str) -> str:
         original_link_type = link_type
-        link_type = ''.join([x for x in link_type if x in string.ascii_letters + '_']).lower()
+        link_type = "".join([x for x in link_type if x in string.ascii_letters + "_"]).lower()
 
-        split = link_type.split('_')
+        split = link_type.split("_")
         for i, piece in enumerate(split[1:]):
-            if piece in ['link', 'segment', 'stretch']:
-                link_type = '_'.join(split[0:i + 1])
+            if piece in ["link", "segment", "stretch"]:
+                link_type = "_".join(split[0 : i + 1])
 
         if len(link_type) == 0:
-            link_type = 'empty'
+            link_type = "empty"
 
         if len(self.__model_link_type_ids) >= 51 and link_type not in self.__model_link_types:
-            link_type = 'aggregate_link_type'
+            link_type = "aggregate_link_type"
 
         if link_type in self.__model_link_types:
             lt = self.__link_types.get_by_name(link_type)
             if original_link_type not in lt.description:
-                lt.description += f', {original_link_type}'
+                lt.description += f", {original_link_type}"
                 lt.save()
             self.__link_type_quick_reference[original_link_type.lower()] = link_type
             return link_type
@@ -305,16 +311,16 @@ def get_link_field_type(field_name):
         p = Parameters()
         fields = p.parameters["network"]["links"]["fields"]
 
-        if field_name[-3:].lower() in ['_ab', '_ba']:
+        if field_name[-3:].lower() in ["_ab", "_ba"]:
             field_name = field_name[:-3]
             for tp in fields["two-way"]:
                 if field_name in tp:
-                    return tp[field_name]['type']
+                    return tp[field_name]["type"]
         else:
 
             for tp in fields["one-way"]:
                 if field_name in tp:
-                    return tp[field_name]['type']
+                    return tp[field_name]["type"]
 
     @staticmethod
     def field_osm_source():
@@ -357,7 +363,7 @@ def modes_per_link_type(self):
 
         type_list = {k: "".join(set(v)) for k, v in type_list.items()}
 
-        return type_list, '{}'.format(notfound)
+        return type_list, "{}".format(notfound)
 
     @staticmethod
     def get_node_fields():
diff --git a/aequilibrae/project/network/osm_downloader.py b/aequilibrae/project/network/osm_downloader.py
index 297e6c085..adef51272 100644
--- a/aequilibrae/project/network/osm_downloader.py
+++ b/aequilibrae/project/network/osm_downloader.py
@@ -39,10 +39,10 @@ def __init__(self, polygons, modes):
         self.filter = self.get_osm_filter(modes)
         self.report = []
         self.json = []
-        par = Parameters().parameters['osm']
-        self.overpass_endpoint = par['overpass_endpoint']
-        self.timeout = par['timeout']
-        self.sleeptime = par['sleeptime']
+        par = Parameters().parameters["osm"]
+        self.overpass_endpoint = par["overpass_endpoint"]
+        self.timeout = par["timeout"]
+        self.sleeptime = par["sleeptime"]
 
     def doWork(self):
         infrastructure = 'way["highway"]'
@@ -52,9 +52,9 @@ def doWork(self):
         )
         self.__emit_all(["maxValue", len(self.polygons)])
         self.__emit_all(["Value", 0])
-        m = ''
+        m = ""
         if memory > 0:
-            m = f'[maxsize: {memory}]'
+            m = f"[maxsize: {memory}]"
         for counter, poly in enumerate(self.polygons):
             msg = f"Downloading polygon {counter + 1} of {len(self.polygons)}"
             logger.debug(msg)
@@ -69,7 +69,7 @@ def doWork(self):
                 infrastructure=infrastructure,
                 filters=self.filter,
                 timeout=self.timeout,
-                memory=m
+                memory=m,
             )
             json = self.overpass_request(data={"data": query_str}, timeout=self.timeout)
             if json["elements"]:
diff --git a/aequilibrae/project/network/osm_utils/osm_params.py b/aequilibrae/project/network/osm_utils/osm_params.py
index d6ebec98f..b38b50e0e 100644
--- a/aequilibrae/project/network/osm_utils/osm_params.py
+++ b/aequilibrae/project/network/osm_utils/osm_params.py
@@ -1,8 +1,8 @@
 import requests
 from aequilibrae.parameters import Parameters
 
-par = Parameters().parameters['osm']
-accept_language = par['accept_language']
+par = Parameters().parameters["osm"]
+accept_language = par["accept_language"]
 memory = 0
 
 user_agent = "AequilibraE (https://github.com/aequilibrae/aequilibrae-GUI)"
diff --git a/aequilibrae/project/network/osm_utils/place_getter.py b/aequilibrae/project/network/osm_utils/place_getter.py
index a805f534c..25fe4db1b 100644
--- a/aequilibrae/project/network/osm_utils/place_getter.py
+++ b/aequilibrae/project/network/osm_utils/place_getter.py
@@ -19,9 +19,9 @@ def placegetter(place: str) -> Tuple[Union[None, List[float]], list]:
     Adapted from http://www.github.com/gboeing/osmnx
     """
 
-    par = Parameters().parameters['osm']
-    nominatim_endpoint = par['nominatim_endpoint']
-    max_attempts = par['max_attempts']
+    par = Parameters().parameters["osm"]
+    nominatim_endpoint = par["nominatim_endpoint"]
+    max_attempts = par["max_attempts"]
 
     params = {"q": place, "format": "json"}
 
diff --git a/aequilibrae/project/network/safe_class.py b/aequilibrae/project/network/safe_class.py
index 6c90d9fc3..9ad72a936 100644
--- a/aequilibrae/project/network/safe_class.py
+++ b/aequilibrae/project/network/safe_class.py
@@ -6,30 +6,30 @@ class SafeClass:
 
     def __init__(self, data_set: dict) -> None:
         self.__original__ = {}
-        self._table = ''
+        self._table = ""
         self.__srid__ = 4326
         for k, v in data_set.items():
-            if k == 'geometry' and v is not None:
+            if k == "geometry" and v is not None:
                 v = shapely.wkb.loads(v)
             self.__dict__[k] = v
             self.__original__[k] = v
 
     def __copy__(self):
-        raise Exception('Object cannot be copied')
+        raise Exception("Object cannot be copied")
 
     def __deepcopy__(self, memodict=None):
-        raise Exception('Object cannot be copied')
+        raise Exception("Object cannot be copied")
 
     def _save_new_with_geometry(self):
         data = []
         up_keys = []
         for key, val in self.__dict__.items():
-            if key not in self.__original__ or key == 'geometry':
+            if key not in self.__original__ or key == "geometry":
                 continue
             up_keys.append(f'"{key}"')
             data.append(val)
-        markers = ','.join(['?'] * len(up_keys)) + ',GeomFromWKB(?, ?)'
-        up_keys.append('geometry')
+        markers = ",".join(["?"] * len(up_keys)) + ",GeomFromWKB(?, ?)"
+        up_keys.append("geometry")
         data.extend([self.geometry.wkb, self.__srid__])
         sql = f'Insert into {self._table} ({",".join(up_keys)}) values({markers})'
         return data, sql
diff --git a/aequilibrae/project/project.py b/aequilibrae/project/project.py
index c975ad004..4170b24f1 100644
--- a/aequilibrae/project/project.py
+++ b/aequilibrae/project/project.py
@@ -30,7 +30,7 @@ class Project:
 
         newfile = Project()
         newfile.new('path/to/new/project/folder')
-        """
+    """
 
     def __init__(self):
         self.path_to_file: str = None
@@ -142,8 +142,7 @@ def parameters(self) -> dict:
         return Parameters().parameters
 
     def check_file_indices(self) -> None:
-        """ Makes results_database.sqlite and the matrices folder compatible with project database
-        """
+        """Makes results_database.sqlite and the matrices folder compatible with project database"""
         raise NotImplementedError
 
     @property
diff --git a/aequilibrae/project/project_cleaning.py b/aequilibrae/project/project_cleaning.py
index 2519dbf36..d5f76ed2b 100644
--- a/aequilibrae/project/project_cleaning.py
+++ b/aequilibrae/project/project_cleaning.py
@@ -6,8 +6,10 @@ def clean():
     # extraneous nodes at a few key moments (i.e. opening and closing the model)
     conn = database_connection()
 
-    sqls = ['''DELETE from Nodes where is_centroid=0 and
-                                      (SELECT count(*) FROM links WHERE a_node = node_id OR b_node = node_id) = 0;''']
+    sqls = [
+        """DELETE from Nodes where is_centroid=0 and
+                                      (SELECT count(*) FROM links WHERE a_node = node_id OR b_node = node_id) = 0;"""
+    ]
 
     for sql in sqls:
         conn.execute(sql)
diff --git a/aequilibrae/project/project_creation.py b/aequilibrae/project/project_creation.py
index dd99bf3f9..169c07be7 100644
--- a/aequilibrae/project/project_creation.py
+++ b/aequilibrae/project/project_creation.py
@@ -6,7 +6,7 @@
 
 req_link_flds = ["link_id", "a_node", "b_node", "direction", "distance", "modes", "link_type"]
 req_node_flds = ["node_id", "is_centroid"]
-protected_fields = ['ogc_fid', 'geometry']
+protected_fields = ["ogc_fid", "geometry"]
 
 
 def initialize_tables(conn: Connection) -> None:
@@ -15,34 +15,34 @@ def initialize_tables(conn: Connection) -> None:
 
 
 def create_base_tables(conn: Connection) -> None:
-    spec_folder = join(dirname(realpath(__file__)), "database_specification", 'tables')
-    with open(join(spec_folder, 'table_list.txt'), 'r') as file_list:
+    spec_folder = join(dirname(realpath(__file__)), "database_specification", "tables")
+    with open(join(spec_folder, "table_list.txt"), "r") as file_list:
         all_tables = file_list.readlines()
     all_tables = [x.rstrip() for x in all_tables]
     for f in all_tables:
-        qry_file = join(spec_folder, f'{f}.sql')
+        qry_file = join(spec_folder, f"{f}.sql")
         run_queries_from_sql_file(conn, qry_file)
 
 
 def add_triggers(conn: Connection) -> None:
     """Adds consistency triggers to the project"""
-    spec_folder = join(dirname(realpath(__file__)), "database_specification", 'triggers')
-    with open(join(spec_folder, 'triggers_list.txt'), 'r') as file_list:
+    spec_folder = join(dirname(realpath(__file__)), "database_specification", "triggers")
+    with open(join(spec_folder, "triggers_list.txt"), "r") as file_list:
         all_trigger_sets = file_list.readlines()
     all_trigger_sets = [x.rstrip() for x in all_trigger_sets]
     for f in all_trigger_sets:
-        qry_file = join(spec_folder, f'{f}.sql')
+        qry_file = join(spec_folder, f"{f}.sql")
         run_queries_from_sql_file(conn, qry_file)
 
 
 def remove_triggers(conn: Connection) -> None:
-    spec_folder = join(dirname(realpath(__file__)), "database_specification", 'triggers')
-    with open(join(spec_folder, 'triggers_list.txt'), 'r') as file_list:
+    spec_folder = join(dirname(realpath(__file__)), "database_specification", "triggers")
+    with open(join(spec_folder, "triggers_list.txt"), "r") as file_list:
         all_trigger_sets = file_list.readlines()
 
-    create_drop_regex = re.compile(r'create\s+trigger\s+(\w+)', flags=re.I)
+    create_drop_regex = re.compile(r"create\s+trigger\s+(\w+)", flags=re.I)
     for table in all_trigger_sets:
-        qry_file = join(spec_folder, f'{table.rstrip()}.sql')
+        qry_file = join(spec_folder, f"{table.rstrip()}.sql")
 
         with open(qry_file, "r") as sql_file:
             query_list = sql_file.read()
@@ -50,18 +50,18 @@ def remove_triggers(conn: Connection) -> None:
         # Running one query/command at a time helps debugging in the case a particular command fails
         for cmd in query_list.split("--#"):
             for qry in cmd.split("\n"):
-                if qry[:2] == '--':
+                if qry[:2] == "--":
                     continue
-                while '  ' in qry:
-                    qry = qry.replace('  ', ' ')
+                while "  " in qry:
+                    qry = qry.replace("  ", " ")
 
                 m = re.search(create_drop_regex, qry)
                 if m:
                     try:
-                        conn.execute(f'drop trigger if exists {m.group(1).lower()}')
+                        conn.execute(f"drop trigger if exists {m.group(1).lower()}")
                     except Exception as e:
-                        logger.error(f'Failed removing triggers table - > {e.args}')
-                        logger.error(f'Point of failure - > {qry}')
+                        logger.error(f"Failed removing triggers table - > {e.args}")
+                        logger.error(f"Point of failure - > {qry}")
         conn.commit()
 
 
diff --git a/aequilibrae/project/spatialite_connection.py b/aequilibrae/project/spatialite_connection.py
index 08c6db8ae..51e16a406 100644
--- a/aequilibrae/project/spatialite_connection.py
+++ b/aequilibrae/project/spatialite_connection.py
@@ -5,11 +5,12 @@
 def spatialite_connection(conn: Connection) -> Connection:
     from aequilibrae.parameters import Parameters
     from aequilibrae import logger
+
     conn.enable_load_extension(True)
     par = Parameters()
     spatialite_path = par.parameters["system"]["spatialite_path"]
-    if spatialite_path not in os.environ['PATH']:
-        os.environ['PATH'] = spatialite_path + ';' + os.environ['PATH']
+    if spatialite_path not in os.environ["PATH"]:
+        os.environ["PATH"] = spatialite_path + ";" + os.environ["PATH"]
     try:
         conn.load_extension("mod_spatialite")
     except Exception as e:
diff --git a/aequilibrae/project/table_loader.py b/aequilibrae/project/table_loader.py
index 01d89e0c3..01a4a79c5 100644
--- a/aequilibrae/project/table_loader.py
+++ b/aequilibrae/project/table_loader.py
@@ -2,10 +2,10 @@
 from typing import List
 
 
-class TableLoader():
+class TableLoader:
     def __init__(self):
         self.fields = []
-        self.sql = ''
+        self.sql = ""
 
     def load_table(self, curr: Cursor, table_name: str) -> List[dict]:
         self.__get_table_struct(curr, table_name)
@@ -16,7 +16,7 @@ def load_structure(self, curr: Cursor, table_name: str) -> None:
         self.__get_table_struct(curr, table_name)
 
     def __get_table_struct(self, curr: Cursor, table_name: str) -> None:
-        curr.execute(f'pragma table_info({table_name})')
-        self.fields = [x[1].lower() for x in curr.fetchall() if x[1].lower() != 'ogc_fid']
-        keys = [f'"{fld}"' if fld != 'geometry' else 'ST_AsBinary("geometry")' for fld in self.fields]
+        curr.execute(f"pragma table_info({table_name})")
+        self.fields = [x[1].lower() for x in curr.fetchall() if x[1].lower() != "ogc_fid"]
+        keys = [f'"{fld}"' if fld != "geometry" else 'ST_AsBinary("geometry")' for fld in self.fields]
         self.sql = f'select {",".join(keys)} from "{table_name}"'
diff --git a/aequilibrae/project/zone.py b/aequilibrae/project/zone.py
index 9abe87530..9c54f3147 100644
--- a/aequilibrae/project/zone.py
+++ b/aequilibrae/project/zone.py
@@ -60,12 +60,12 @@ def save(self):
     def add_centroid(self, point: Point, robust=True) -> None:
         """Adds a centroid to the network file
 
-               Args:
-                   *point* (:obj:`Point`): Shapely Point corresponding to the desired centroid position.
-                   If None, uses the geometric center of the zone
-                   *robust* (:obj:`Bool`, Optional): Moves the centroid location around to avoid node conflict.
-                   Defaults to True.
-               """
+        Args:
+            *point* (:obj:`Point`): Shapely Point corresponding to the desired centroid position.
+            If None, uses the geometric center of the zone
+            *robust* (:obj:`Bool`, Optional): Moves the centroid location around to avoid node conflict.
+            Defaults to True.
+        """
 
         # This is VERY small in real-world terms (between zero and 11cm)
         shift = 0.000001
@@ -93,8 +93,7 @@ def add_centroid(self, point: Point, robust=True) -> None:
             test_list = self.conn.execute(check_sql, [point.wkb, point.wkb]).fetchone()
             while sum(test_list):
                 test_list = self.conn.execute(check_sql, [point.wkb, point.wkb]).fetchone()
-                point = Point(point.x + random.random() * shift,
-                              point.y + random.random() * shift)
+                point = Point(point.x + random.random() * shift, point.y + random.random() * shift)
 
         data = [self.zone_id, point.wkb, self.__srid__]
         self.conn.execute(sql, data)
@@ -103,26 +102,26 @@ def add_centroid(self, point: Point, robust=True) -> None:
     def connect_mode(self, mode_id: str, link_types="", connectors=1) -> None:
         """Adds centroid connectors for the desired mode to the network file
 
-           Centroid connectors are created by connecting the zone centroid to one or more nodes selected from
-           all those that satisfy the mode and link_types criteria and are inside the zone.
+        Centroid connectors are created by connecting the zone centroid to one or more nodes selected from
+        all those that satisfy the mode and link_types criteria and are inside the zone.
 
-           The selection of the nodes that will be connected is done simply by computing running the
-           `KMeans2 <https://docs.scipy.org/doc/scipy/reference/generated/scipy.cluster.vq.kmeans2.html>`_
-           clustering algorithm from SciPy and selecting the nodes closest to each cluster centroid.
+        The selection of the nodes that will be connected is done simply by computing running the
+        `KMeans2 <https://docs.scipy.org/doc/scipy/reference/generated/scipy.cluster.vq.kmeans2.html>`_
+        clustering algorithm from SciPy and selecting the nodes closest to each cluster centroid.
 
-           When there are no node candidates inside the zone, the search area is progressively expanded until
-           at least one candidate is found.
+        When there are no node candidates inside the zone, the search area is progressively expanded until
+        at least one candidate is found.
 
-           If fewer candidates than required connectors are found, all candidates are connected.
+        If fewer candidates than required connectors are found, all candidates are connected.
 
-               Args:
-                   *mode_id* (:obj:`str`): Mode ID we are trying to connect
+            Args:
+                *mode_id* (:obj:`str`): Mode ID we are trying to connect
 
-                   *link_types* (:obj:`str`, `Optional`): String with all the link type IDs that can be considered.
-                   eg: yCdR. Defaults to ALL link types
+                *link_types* (:obj:`str`, `Optional`): String with all the link type IDs that can be considered.
+                eg: yCdR. Defaults to ALL link types
 
-                   *connectors* (:obj:`int`, `Optional`): Number of connectors to add. Defaults to 1
-           """
+                *connectors* (:obj:`int`, `Optional`): Number of connectors to add. Defaults to 1
+        """
         connector_creation(
             self.geometry,
             zone_id=self.zone_id,
@@ -135,8 +134,8 @@ def connect_mode(self, mode_id: str, link_types="", connectors=1) -> None:
     def disconnect_mode(self, mode_id: str) -> None:
         """Removes centroid connectors for the desired mode from the network file
 
-               Args:
-                   *mode_id* (:obj:`str`): Mode ID we are trying to disconnect from this zone
+        Args:
+            *mode_id* (:obj:`str`): Mode ID we are trying to disconnect from this zone
         """
 
         curr = self.conn.cursor()
diff --git a/aequilibrae/project/zoning.py b/aequilibrae/project/zoning.py
index 0857c18b7..400cc5d5e 100644
--- a/aequilibrae/project/zoning.py
+++ b/aequilibrae/project/zoning.py
@@ -44,7 +44,7 @@ class Zoning(BasicTable):
     def __init__(self, network):
         super().__init__()
         self.network = network
-        self.__table_type__ = 'zones'
+        self.__table_type__ = "zones"
         self.__fields = []
         if self.__has_zoning():
             self.__load()
@@ -54,7 +54,7 @@ def new(self, zone_id: int) -> Zone:
 
         Returns:
             *zone* (:obj:`Zone`): A new zone object populated only with zone_id (but not saved in the model yet)
-            """
+        """
 
         if zone_id in self.__items:
             raise Exception(f"Zone ID {zone_id} already exists")
@@ -76,7 +76,7 @@ def create_zoning_layer(self):
             warn("zones table already exists. Nothing was done", Warning)
 
     def coverage(self) -> Polygon:
-        """ Returns a single polygon for the entire zoning coverage
+        """Returns a single polygon for the entire zoning coverage
 
         Returns:
             *model coverage* (:obj:`Polygon`): Shapely (Multi)polygon of the zoning system.
diff --git a/aequilibrae/starts_logging.py b/aequilibrae/starts_logging.py
index e552fc194..fac6d9228 100644
--- a/aequilibrae/starts_logging.py
+++ b/aequilibrae/starts_logging.py
@@ -34,7 +34,7 @@ def StartsLogging():
         if do_log:
             ch = logging.FileHandler(log_file)
         ch.setFormatter(formatter)
-        ch.name = 'aequilibrae'
+        ch.name = "aequilibrae"
         ch.setLevel(logging.DEBUG)
         logger.addHandler(ch)
     return logger
diff --git a/aequilibrae/transit/gtfs/gtfs.py b/aequilibrae/transit/gtfs/gtfs.py
index f605d3304..20ee181cf 100644
--- a/aequilibrae/transit/gtfs/gtfs.py
+++ b/aequilibrae/transit/gtfs/gtfs.py
@@ -9,13 +9,13 @@
 
 class GTFS:
     """
-     Reader for GTFS (from https://developers.google.com/transit/gtfs/reference/)
+    Reader for GTFS (from https://developers.google.com/transit/gtfs/reference/)
 
-     Provides a memory container for GTFS that can be:
+    Provides a memory container for GTFS that can be:
 
-        * Passed to transit assignment algorithms in memory
-        * Edited and saved back to disk
-        * Displayed in a GIS environment
+       * Passed to transit assignment algorithms in memory
+       * Edited and saved back to disk
+       * Displayed in a GIS environment
     """
 
     def __init__(self):
diff --git a/aequilibrae/transit/gtfs/gtfs_sqlite_db.py b/aequilibrae/transit/gtfs/gtfs_sqlite_db.py
index cc1f710eb..227dca79d 100644
--- a/aequilibrae/transit/gtfs/gtfs_sqlite_db.py
+++ b/aequilibrae/transit/gtfs/gtfs_sqlite_db.py
@@ -24,6 +24,7 @@
     pyqt = False
 else:
     from PyQt5.QtCore import pyqtSignal as SIGNAL
+
     pyqt = True
 
 
diff --git a/aequilibrae/utils/create_delaunay_network.py b/aequilibrae/utils/create_delaunay_network.py
index 10ae3ebc9..61374d03d 100644
--- a/aequilibrae/utils/create_delaunay_network.py
+++ b/aequilibrae/utils/create_delaunay_network.py
@@ -12,23 +12,23 @@
 from aequilibrae.matrix import AequilibraeMatrix
 from aequilibrae.project.database_connection import ENVIRON_VAR
 
-DELAUNAY_TABLE = 'delaunay_network'
+DELAUNAY_TABLE = "delaunay_network"
 
 
 class DelaunayAnalysis:
     def __init__(self):
         self.procedure_id = uuid.uuid4().hex
 
-    def create_network(self, source='zones', overwrite=False):
+    def create_network(self, source="zones", overwrite=False):
         """Creates a delaunay network based on the existing model
 
         Args:
             *source* (:obj:`str`, `Optional`): Source of the centroids/zones. Defaults to *zones*, but can be *network*
             *overwrite path* (:obj:`bool`, `Optional`): Whether we should overwrite am existing Delaunay Network.
             Defaults to False
-            """
+        """
 
-        if source not in ['zones', 'network']:
+        if source not in ["zones", "network"]:
             raise ValueError("Source must be 'zones' or 'network'")
 
         conn = database_connection()
@@ -37,50 +37,50 @@ def create_network(self, source='zones', overwrite=False):
         if DELAUNAY_TABLE in tables.name.values:
             if not overwrite:
                 raise ValueError("Delaunay network already exist. Use the overwrite flag to re-run it")
-            conn.execute(f'DROP TABLE {DELAUNAY_TABLE}')
-            conn.execute('delete from geometry_columns where f_table_name=?', [DELAUNAY_TABLE])
+            conn.execute(f"DROP TABLE {DELAUNAY_TABLE}")
+            conn.execute("delete from geometry_columns where f_table_name=?", [DELAUNAY_TABLE])
             conn.commit()
 
-        zone_sql = 'select zone_id node_id, X(st_centroid(geometry)) x, Y(st_centroid(geometry)) y from zones'
-        network_sql = 'select node_id, X(geometry) x, Y(geometry) y from nodes where is_centroid=1'
+        zone_sql = "select zone_id node_id, X(st_centroid(geometry)) x, Y(st_centroid(geometry)) y from zones"
+        network_sql = "select node_id, X(geometry) x, Y(geometry) y from nodes where is_centroid=1"
 
-        points = pd.read_sql(zone_sql, conn) if source == 'zones' else pd.read_sql(network_sql, conn)
-        dpoints = np.array(points[['x', 'y']])
+        points = pd.read_sql(zone_sql, conn) if source == "zones" else pd.read_sql(network_sql, conn)
+        dpoints = np.array(points[["x", "y"]])
         all_edges = Delaunay(np.array(dpoints)).simplices
         edges = []
         for triangle in all_edges:
             links = list(combinations(triangle, 2))
             for i in links:
                 f, t = sorted(list(i))
-                edges.append([points.at[f, 'node_id'], points.at[t, 'node_id']])
+                edges.append([points.at[f, "node_id"], points.at[t, "node_id"]])
 
         edges = pd.DataFrame(edges)
         edges.drop_duplicates(inplace=True)
-        edges.columns = ['a_node', 'b_node']
+        edges.columns = ["a_node", "b_node"]
         edges = edges.assign(direction=0, distance=0, link_id=np.arange(edges.shape[0]) + 1)
-        edges = edges[['link_id', 'direction', 'a_node', 'b_node', 'distance']]
+        edges = edges[["link_id", "direction", "a_node", "b_node", "distance"]]
         edges.to_sql(DELAUNAY_TABLE, conn, index=False)
 
         # Now we create the geometries for the delaunay triangulation
         conn.execute(f"select AddGeometryColumn( '{DELAUNAY_TABLE}', 'geometry', 4326, 'LINESTRING', 'XY', 0);")
         conn.execute("CREATE UNIQUE INDEX unique_link_id_delaunay on delaunay_network(link_id)")
 
-        node_geo_sql = '''INSERT INTO delaunay_network (link_id, geometry)
+        node_geo_sql = """INSERT INTO delaunay_network (link_id, geometry)
                              select lnk.link_id, MakeLine(nd.geometry, nf.geometry) from delaunay_network lnk
                                     inner join nodes nd on lnk.a_node=nd.node_id
                                     inner join nodes nf on lnk.b_node=nf.node_id
-                           ON CONFLICT(link_id) DO UPDATE SET geometry=excluded.geometry'''
+                           ON CONFLICT(link_id) DO UPDATE SET geometry=excluded.geometry"""
 
-        zone_geo_sql = '''INSERT INTO delaunay_network (link_id, geometry)
+        zone_geo_sql = """INSERT INTO delaunay_network (link_id, geometry)
                              select lnk.link_id, MakeLine(st_centroid(za.geometry), st_centroid(zb.geometry)) from delaunay_network lnk
                                     inner join zones za on lnk.a_node=za.zone_id
                                     inner join zones zb on lnk.b_node=zb.zone_id
-                          ON CONFLICT(link_id) DO UPDATE SET geometry=excluded.geometry;'''
+                          ON CONFLICT(link_id) DO UPDATE SET geometry=excluded.geometry;"""
 
-        sql = zone_geo_sql if source == 'zones' else node_geo_sql
+        sql = zone_geo_sql if source == "zones" else node_geo_sql
         conn.execute(sql)
         # Updates link distance
-        conn.execute('update delaunay_network set distance=GeodesicLength(geometry);')
+        conn.execute("update delaunay_network set distance=GeodesicLength(geometry);")
         conn.commit()
         conn.close()
 
@@ -93,31 +93,34 @@ def assign_matrix(self, matrix: AequilibraeMatrix, result_name: str):
         centroids = np.array(np.unique(np.hstack((df.a_node.values, df.b_node.values))), int)
 
         g = Graph()
-        g.mode = 'delaunay'
+        g.mode = "delaunay"
         g.network = df
         g.prepare_graph(centroids)
         g.set_blocked_centroid_flows(True)
 
-        tc = TrafficClass('delaunay', g, matrix)
+        tc = TrafficClass("delaunay", g, matrix)
         ta = TrafficAssignment()
         ta.set_classes([tc])
-        ta.set_time_field('distance')
-        ta.set_capacity_field('capacity')
-        ta.set_vdf('BPR')
+        ta.set_time_field("distance")
+        ta.set_capacity_field("capacity")
+        ta.set_vdf("BPR")
         ta.set_vdf_parameters({"alpha": 0, "beta": 1.0})
-        ta.set_algorithm('all-or-nothing')
+        ta.set_algorithm("all-or-nothing")
         ta.execute()
 
         report = {"setup": str(ta.info())}
-        data = [result_name, "Delaunay assignment", self.procedure_id, str(report), ta.procedure_date, '']
-        conn.execute("""Insert into results(table_name, procedure, procedure_id, procedure_report, timestamp,
-                                            description) Values(?,?,?,?,?,?)""", data)
+        data = [result_name, "Delaunay assignment", self.procedure_id, str(report), ta.procedure_date, ""]
+        conn.execute(
+            """Insert into results(table_name, procedure, procedure_id, procedure_report, timestamp,
+                                            description) Values(?,?,?,?,?,?)""",
+            data,
+        )
         conn.commit()
         conn.close()
 
         cols = []
         for x in matrix.view_names:
-            cols.extend([f'{x}_ab', f'{x}_ba', f'{x}_tot'])
+            cols.extend([f"{x}_ab", f"{x}_ba", f"{x}_tot"])
         df = ta.results()[cols]
         conn = sqlite3.connect(join(environ[ENVIRON_VAR], "results_database.sqlite"))
         df.to_sql(result_name, conn)
diff --git a/aequilibrae/utils/create_example.py b/aequilibrae/utils/create_example.py
index fd37294bd..cd3003c87 100644
--- a/aequilibrae/utils/create_example.py
+++ b/aequilibrae/utils/create_example.py
@@ -4,7 +4,7 @@
 from aequilibrae import Project
 
 
-def create_example(path: str, from_model='sioux_falls') -> Project:
+def create_example(path: str, from_model="sioux_falls") -> Project:
     """Copies an example model to a new project project and returns the project handle
 
     Args:
@@ -14,15 +14,15 @@ def create_example(path: str, from_model='sioux_falls') -> Project:
     Returns:
         *project* (:obj:`Project`): Aequilibrae Project handle (open)
 
-        """
+    """
     if os.path.isdir(path):
-        raise FileExistsError('Cannot overwrite an existing directory')
+        raise FileExistsError("Cannot overwrite an existing directory")
 
-    if not os.path.isfile(join(dirname(__file__), f'../reference_files/{from_model}.zip')):
-        raise FileExistsError('Example not found')
+    if not os.path.isfile(join(dirname(__file__), f"../reference_files/{from_model}.zip")):
+        raise FileExistsError("Example not found")
 
     os.mkdir(path)
-    zipfile.ZipFile(join(dirname(__file__), f'../reference_files/{from_model}.zip')).extractall(path)
+    zipfile.ZipFile(join(dirname(__file__), f"../reference_files/{from_model}.zip")).extractall(path)
     proj = Project()
     proj.open(path)
     return proj
diff --git a/aequilibrae/utils/worker_thread.py b/aequilibrae/utils/worker_thread.py
index 0f9395974..1494e5b2b 100644
--- a/aequilibrae/utils/worker_thread.py
+++ b/aequilibrae/utils/worker_thread.py
@@ -9,6 +9,7 @@
     from PyQt5.QtCore import QThread
     from PyQt5.QtCore import pyqtSignal
 else:
+
     class QThread:
         def __init__(self, *arg):
             pass
diff --git a/docs/source/conf.py b/docs/source/conf.py
index dfbe1b37e..7220ba096 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -57,13 +57,13 @@
     "sphinx.ext.coverage",
     "sphinx.ext.mathjax",
     "sphinx_autodoc_annotation",
-    'sphinx.ext.autosummary',
-    'sphinx_git',
+    "sphinx.ext.autosummary",
+    "sphinx_git",
 ]
 
 sphinx_gallery_conf = {
-    'examples_dirs': ['examples'],  # path to your example scripts
-    'gallery_dirs': ['_auto_examples'],  # path to where to save gallery generated output
+    "examples_dirs": ["examples"],  # path to your example scripts
+    "gallery_dirs": ["_auto_examples"],  # path to where to save gallery generated output
 }
 
 # Add any paths that contain templates here, relative to this directory.
@@ -88,11 +88,11 @@
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
 # This pattern also affects html_static_path and html_extra_path .
-exclude_patterns = ["_build", "Thumbs.db", ".DS_Store", '*.pyx']
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store", "*.pyx"]
 
 # The name of the Pygments (syntax highlighting) style to use.
 pygments_style = "sphinx"
-highlight_language = 'none'
+highlight_language = "none"
 # -- Options for HTML output -------------------------------------------------
 
 # The theme to use for HTML and HTML Help pages.  See the documentation for
@@ -136,18 +136,18 @@
 # -- Options for Texinfo output ----------------------------------------------
 
 autodoc_default_options = {
-    'members': 'var1, var2',
-    'member-order': 'bysource',
-    'special-members': '__init__',
-    'private-members': False,
-    'undoc-members': True,
-    'exclude-members': '__weakref__',
-    'inherited-members': False,
-    'show-inheritance': False,
-    'autodoc_inherit_docstrings': False
+    "members": "var1, var2",
+    "member-order": "bysource",
+    "special-members": "__init__",
+    "private-members": False,
+    "undoc-members": True,
+    "exclude-members": "__weakref__",
+    "inherited-members": False,
+    "show-inheritance": False,
+    "autodoc_inherit_docstrings": False,
 }
 
-autodoc_member_order = 'groupwise'
+autodoc_member_order = "groupwise"
 
 autoclass_content = "class"  # classes should include both the class' and the __init__ method's docstring
 
diff --git a/docs/source/examples/plot_delaunay_lines.py b/docs/source/examples/plot_delaunay_lines.py
index 905ee7165..f302f498a 100644
--- a/docs/source/examples/plot_delaunay_lines.py
+++ b/docs/source/examples/plot_delaunay_lines.py
@@ -32,7 +32,7 @@
 da = DelaunayAnalysis()
 
 # Let's create the triangulation based on the zones, but we could create based on the network (centroids) too
-da.create_network('zones')
+da.create_network("zones")
 
 # %%
 # Now we get the matrix we want and create the Delaunay Lines
@@ -40,19 +40,19 @@
 demand.computational_view(["matrix"])
 
 # And we will call it 'delaunay_test'./ It will also be saved in the results_database.sqlite
-da.assign_matrix(demand, 'delaunay_test')
+da.assign_matrix(demand, "delaunay_test")
 
 # %%
 # we retrieve the results
-conn = sqlite3.connect(join(fldr, 'results_database.sqlite'))
-results = pd.read_sql('Select * from delaunay_test', conn).set_index('link_id')
+conn = sqlite3.connect(join(fldr, "results_database.sqlite"))
+results = pd.read_sql("Select * from delaunay_test", conn).set_index("link_id")
 
 # %%
 # Now we get the matrix we want and create the Delaunay Lines
 
-links = pd.read_sql('Select link_id, st_asBinary(geometry) geometry from delaunay_network', project.conn)
+links = pd.read_sql("Select link_id, st_asBinary(geometry) geometry from delaunay_network", project.conn)
 links.geometry = links.geometry.apply(shapely.wkb.loads)
-links.set_index('link_id', inplace=True)
+links.set_index("link_id", inplace=True)
 
 df = links.join(results)
 
@@ -60,9 +60,9 @@
 
 for idx, lnk in df.iterrows():
     geo = lnk.geometry
-    plt.plot(*geo.xy, color='blue', linewidth=4 * lnk.matrix_tot / max_vol)
+    plt.plot(*geo.xy, color="blue", linewidth=4 * lnk.matrix_tot / max_vol)
 plt.show()
 
 # %%
 # Close the project
-project.close()
\ No newline at end of file
+project.close()
diff --git a/docs/source/examples/plot_display.py b/docs/source/examples/plot_display.py
index db7292b79..afcde06e9 100644
--- a/docs/source/examples/plot_display.py
+++ b/docs/source/examples/plot_display.py
@@ -14,7 +14,8 @@
 # %%
 from PIL import Image
 import matplotlib.pyplot as plt
-img = Image.open('plot_network_image.png')
+
+img = Image.open("plot_network_image.png")
 plt.imshow(img)
 
 
@@ -31,7 +32,7 @@
 fldr = join(gettempdir(), uuid4().hex)
 
 # Let's use the Nauru example project for display
-project = create_example(fldr, 'nauru')
+project = create_example(fldr, "nauru")
 
 # %%
 # We grab all the links data as a Pandas dataframe so we can process it easier
@@ -50,43 +51,55 @@
 # We do some Python magic to transform this dataset into the format required by Folium
 # We are only getting link_id and link_type into the map, but we could get other pieces of info as well
 for i, row in links.iterrows():
-    points = row.geometry.wkt.replace('LINESTRING ', '').replace('(', '').replace(')', '').split(', ')
-    points = '[[' + '],['.join([p.replace(' ', ', ') for p in points]) + ']]'
+    points = row.geometry.wkt.replace("LINESTRING ", "").replace("(", "").replace(")", "").split(", ")
+    points = "[[" + "],[".join([p.replace(" ", ", ") for p in points]) + "]]"
     # we need to take from x/y to lat/long
     points = [[x[1], x[0]] for x in eval(points)]
 
-    _ = folium.vector_layers.PolyLine(points, popup=f'<b>link_id: {row.link_id}</b>', tooltip=f'{row.modes}',
-                                      color='gray', weight=2).add_to(network_links)
+    _ = folium.vector_layers.PolyLine(
+        points, popup=f"<b>link_id: {row.link_id}</b>", tooltip=f"{row.modes}", color="gray", weight=2
+    ).add_to(network_links)
 
-    if 'w' in row.modes:
-        _ = folium.vector_layers.PolyLine(points, popup=f'<b>link_id: {row.link_id}</b>', tooltip=f'{row.modes}',
-                                             color='green', weight=4).add_to(walk)
+    if "w" in row.modes:
+        _ = folium.vector_layers.PolyLine(
+            points, popup=f"<b>link_id: {row.link_id}</b>", tooltip=f"{row.modes}", color="green", weight=4
+        ).add_to(walk)
 
-    if 'b' in row.modes:
-        _ = folium.vector_layers.PolyLine(points, popup=f'<b>link_id: {row.link_id}</b>', tooltip=f'{row.modes}',
-                                             color='green', weight=4).add_to(bike)
+    if "b" in row.modes:
+        _ = folium.vector_layers.PolyLine(
+            points, popup=f"<b>link_id: {row.link_id}</b>", tooltip=f"{row.modes}", color="green", weight=4
+        ).add_to(bike)
 
-    if 'c' in row.modes:
-        _ = folium.vector_layers.PolyLine(points, popup=f'<b>link_id: {row.link_id}</b>', tooltip=f'{row.modes}',
-                                             color='red', weight=4).add_to(car)
+    if "c" in row.modes:
+        _ = folium.vector_layers.PolyLine(
+            points, popup=f"<b>link_id: {row.link_id}</b>", tooltip=f"{row.modes}", color="red", weight=4
+        ).add_to(car)
 
-    if 't' in row.modes:
-        _ = folium.vector_layers.PolyLine(points, popup=f'<b>link_id: {row.link_id}</b>', tooltip=f'{row.modes}',
-                                             color='yellow', weight=4).add_to(transit)
+    if "t" in row.modes:
+        _ = folium.vector_layers.PolyLine(
+            points, popup=f"<b>link_id: {row.link_id}</b>", tooltip=f"{row.modes}", color="yellow", weight=4
+        ).add_to(transit)
 
 # And now we get the nodes
 
 for i, row in nodes.iterrows():
     point = (row.geometry.y, row.geometry.x)
 
-    _ = folium.vector_layers.CircleMarker(point, popup=f'<b>link_id: {row.node_id}</b>', tooltip=f'{row.modes}',
-                                          color='black', radius=5, fill=True, fillColor='black',
-                                          fillOpacity=1.0).add_to(network_nodes)
+    _ = folium.vector_layers.CircleMarker(
+        point,
+        popup=f"<b>link_id: {row.node_id}</b>",
+        tooltip=f"{row.modes}",
+        color="black",
+        radius=5,
+        fill=True,
+        fillColor="black",
+        fillOpacity=1.0,
+    ).add_to(network_nodes)
 
 # %%
 # We get the center of the region we are working with some SQL magic
 curr = project.conn.cursor()
-curr.execute('select avg(xmin), avg(ymin) from idx_links_geometry')
+curr.execute("select avg(xmin), avg(ymin) from idx_links_geometry")
 long, lat = curr.fetchone()
 
 # %%
@@ -104,4 +117,4 @@
 
 
 # %%
-project.close()
\ No newline at end of file
+project.close()
diff --git a/docs/source/examples/plot_find_disconnected.py b/docs/source/examples/plot_find_disconnected.py
index 11f3b51f8..9d7f6a531 100644
--- a/docs/source/examples/plot_find_disconnected.py
+++ b/docs/source/examples/plot_find_disconnected.py
@@ -33,16 +33,16 @@
 project = create_example(fldr, "nauru")
 
 # Let's analyze the mode car, or 'c' in our model
-mode = 'c'
+mode = "c"
 
 # %%
 # We need to create the graph, but before that we need to have at least one centroid in our network
 
 # We get an arbitrary node to set as centroid and allow for the construction of graphs
-centroid_count = project.conn.execute('select count(*) from nodes where is_centroid=1').fetchone()[0]
+centroid_count = project.conn.execute("select count(*) from nodes where is_centroid=1").fetchone()[0]
 
 if centroid_count == 0:
-    arbitrary_node = project.conn.execute('select node_id from nodes limit 1').fetchone()[0]
+    arbitrary_node = project.conn.execute("select node_id from nodes limit 1").fetchone()[0]
     nodes = project.network.nodes
     nd = nodes.get(arbitrary_node)
     nd.is_centroid = 1
@@ -62,12 +62,13 @@
 # %%
 # We set the graph for computation
 
-graph.set_graph('distance')
-graph.set_skimming('distance')
+graph.set_graph("distance")
+graph.set_skimming("distance")
 
 # Get the nodes that are part of the car network
-missing_nodes = [x[0] for x in
-                 project.conn.execute(f"Select node_id from nodes where instr(modes, '{mode}')").fetchall()]
+missing_nodes = [
+    x[0] for x in project.conn.execute(f"Select node_id from nodes where instr(modes, '{mode}')").fetchall()
+]
 missing_nodes = np.array(missing_nodes)
 
 # And prepare the path computation structure
@@ -81,25 +82,25 @@
 idx_islands = 0
 #
 while missing_nodes.shape[0] >= 2:
-    print(datetime.now().strftime("%H:%M:%S"), f' - Computing island: {idx_islands}')
+    print(datetime.now().strftime("%H:%M:%S"), f" - Computing island: {idx_islands}")
     res.reset()
     res.compute_path(missing_nodes[0], missing_nodes[1])
     res.predecessors[graph.nodes_to_indices[missing_nodes[0]]] = 0
     connected = graph.all_nodes[np.where(res.predecessors >= 0)]
     connected = np.intersect1d(missing_nodes, connected)
     missing_nodes = np.setdiff1d(missing_nodes, connected)
-    print(f'    Nodes to find: {missing_nodes.shape[0]:,}')
-    df = pd.DataFrame({'node_id': connected, 'island': idx_islands})
+    print(f"    Nodes to find: {missing_nodes.shape[0]:,}")
+    df = pd.DataFrame({"node_id": connected, "island": idx_islands})
     islands.append(df)
     idx_islands += 1
 
-print(f'\nWe found {idx_islands} islands')
+print(f"\nWe found {idx_islands} islands")
 # %%
 # consolidate everything into a single DataFrame
 islands = pd.concat(islands)
 
 # And save to disk alongside our model
-islands.to_csv(join(fldr, 'island_outputs_complete.csv'), index=False)
+islands.to_csv(join(fldr, "island_outputs_complete.csv"), index=False)
 
 # If you join the node_id field in the csv file generated above with the a_node or b_node fields
 # in the links table, you will have the corresponding links in each disjoint island found
diff --git a/docs/source/examples/plot_forecasting.py b/docs/source/examples/plot_forecasting.py
index 6651d6e65..5a7535ab7 100644
--- a/docs/source/examples/plot_forecasting.py
+++ b/docs/source/examples/plot_forecasting.py
@@ -74,7 +74,7 @@
 assig = TrafficAssignment()
 
 # Creates the assignment class
-assigclass = TrafficClass(name='car', graph=graph, matrix=demand)
+assigclass = TrafficClass(name="car", graph=graph, matrix=demand)
 
 # The first thing to do is to add at list of traffic classes to be assigned
 assig.add_class(assigclass)
@@ -330,7 +330,7 @@
 assig = TrafficAssignment()
 
 # Creates the assignment class
-assigclass = TrafficClass(name='car', graph=graph, matrix=demand)
+assigclass = TrafficClass(name="car", graph=graph, matrix=demand)
 
 # The first thing to do is to add at list of traffic classes to be assigned
 assig.add_class(assigclass)
diff --git a/docs/source/examples/plot_from_layer.py b/docs/source/examples/plot_from_layer.py
index 96b0939ce..68f8f07b8 100644
--- a/docs/source/examples/plot_from_layer.py
+++ b/docs/source/examples/plot_from_layer.py
@@ -32,7 +32,7 @@
 # we will download from the AequilibraE website)
 # With data, we load it on Pandas
 dest_path = join(fldr, "queluz.csv")
-urllib.request.urlretrieve('https://aequilibrae.com/data/queluz.csv', dest_path)
+urllib.request.urlretrieve("https://aequilibrae.com/data/queluz.csv", dest_path)
 
 df = pd.read_csv(dest_path)
 
@@ -76,7 +76,7 @@
 # the model
 
 # We get all the unique mode combinations and merge into a single string
-all_variations_string = ''.join(df.modes.unique())
+all_variations_string = "".join(df.modes.unique())
 
 # We then get all the unique modes in that string above
 all_modes = set(all_variations_string)
@@ -90,7 +90,7 @@
 for i, mode_id in enumerate(modes_to_add):
     new_mode = md.new(mode_id)
     # You would need to figure out the right name for each one, but this will do
-    new_mode.mode_name = f'Mode_from_original_data_{mode_id}'
+    new_mode.mode_name = f"Mode_from_original_data_{mode_id}"
     # new_type.description = 'Your custom description here if you have one'
 
     # It is a little different, because you need to add it to the project
@@ -104,7 +104,7 @@
 links = project.network.links
 link_data = links.fields
 # Create the field and add a good description for it
-link_data.add('source_id', 'link_id from the data source')
+link_data.add("source_id", "link_id from the data source")
 
 # We need to refresh the fields so the adding method can see it
 links.refresh_fields()
@@ -135,18 +135,19 @@
 # We do some Python magic to transform this dataset into the format required by Folium
 # We are only getting link_id and link_type into the map, but we could get other pieces of info as well
 for i, row in links.iterrows():
-    points = row.geometry.wkt.replace('LINESTRING ', '').replace('(', '').replace(')', '').split(', ')
-    points = '[[' + '],['.join([p.replace(' ', ', ') for p in points]) + ']]'
+    points = row.geometry.wkt.replace("LINESTRING ", "").replace("(", "").replace(")", "").split(", ")
+    points = "[[" + "],[".join([p.replace(" ", ", ") for p in points]) + "]]"
     # we need to take from x/y to lat/long
     points = [[x[1], x[0]] for x in eval(points)]
 
-    line = folium.vector_layers.PolyLine(points, popup=f'<b>link_id: {row.link_id}</b>', tooltip=f'{row.link_type}',
-                                         color='blue', weight=10).add_to(network_links)
+    line = folium.vector_layers.PolyLine(
+        points, popup=f"<b>link_id: {row.link_id}</b>", tooltip=f"{row.link_type}", color="blue", weight=10
+    ).add_to(network_links)
 
 # %%
 # We get the center of the region we are working with some SQL magic
 curr = project.conn.cursor()
-curr.execute('select avg(xmin), avg(ymin) from idx_links_geometry')
+curr.execute("select avg(xmin), avg(ymin) from idx_links_geometry")
 long, lat = curr.fetchone()
 
 # %%
@@ -164,13 +165,13 @@
 from PIL import Image
 import matplotlib.pyplot as plt
 
-pic = 'https://upload.wikimedia.org/wikipedia/commons/2/2c/Ponte_Governador_Mario_Covas_01.jpg'
-pic_local = join(fldr, 'queluz.jpg')
-headers = {'User-Agent': "AequilibraE (https://aequilibrae.com/; contact@aequilibrae.com)  python-library/0.7"}
+pic = "https://upload.wikimedia.org/wikipedia/commons/2/2c/Ponte_Governador_Mario_Covas_01.jpg"
+pic_local = join(fldr, "queluz.jpg")
+headers = {"User-Agent": "AequilibraE (https://aequilibrae.com/; contact@aequilibrae.com)  python-library/0.7"}
 
 response = requests.get(pic, headers=headers)
 if response.status_code == 200:
-    with open(pic_local, 'wb') as f:
+    with open(pic_local, "wb") as f:
         f.write(response.content)
 
     img = Image.open(pic_local)
diff --git a/docs/source/examples/plot_from_osm.py b/docs/source/examples/plot_from_osm.py
index d8e88b907..33e513adc 100644
--- a/docs/source/examples/plot_from_osm.py
+++ b/docs/source/examples/plot_from_osm.py
@@ -26,7 +26,7 @@
 
 # We can create from a bounding box
 # or from a named place. For the sake of this example, we will choose the small nation of Nauru
-project.network.create_from_osm(place_name='Nauru')
+project.network.create_from_osm(place_name="Nauru")
 
 # %%
 # We grab all the links data as a Pandas dataframe so we can process it easier
@@ -38,18 +38,19 @@
 # We do some Python magic to transform this dataset into the format required by Folium
 # We are only getting link_id and link_type into the map, but we could get other pieces of info as well
 for i, row in links.iterrows():
-    points = row.geometry.wkt.replace('LINESTRING ', '').replace('(', '').replace(')', '').split(', ')
-    points = '[[' + '],['.join([p.replace(' ', ', ') for p in points]) + ']]'
+    points = row.geometry.wkt.replace("LINESTRING ", "").replace("(", "").replace(")", "").split(", ")
+    points = "[[" + "],[".join([p.replace(" ", ", ") for p in points]) + "]]"
     # we need to take from x/y to lat/long
     points = [[x[1], x[0]] for x in eval(points)]
 
-    line = folium.vector_layers.PolyLine(points, popup=f'<b>link_id: {row.link_id}</b>', tooltip=f'{row.link_type}',
-                                         color='blue', weight=10).add_to(network_links)
+    line = folium.vector_layers.PolyLine(
+        points, popup=f"<b>link_id: {row.link_id}</b>", tooltip=f"{row.link_type}", color="blue", weight=10
+    ).add_to(network_links)
 
 # %%
 # We get the center of the region we are working with some SQL magic
 curr = project.conn.cursor()
-curr.execute('select avg(xmin), avg(ymin) from idx_links_geometry')
+curr.execute("select avg(xmin), avg(ymin) from idx_links_geometry")
 long, lat = curr.fetchone()
 
 # %%
@@ -67,5 +68,6 @@
 # %%
 from PIL import Image
 import matplotlib.pyplot as plt
-img = Image.open('nauru.png')
+
+img = Image.open("nauru.png")
 plt.imshow(img)
diff --git a/docs/source/examples/plot_logging_to_terminal.py b/docs/source/examples/plot_logging_to_terminal.py
index eef5da984..238b33a8b 100644
--- a/docs/source/examples/plot_logging_to_terminal.py
+++ b/docs/source/examples/plot_logging_to_terminal.py
@@ -37,5 +37,5 @@
 from PIL import Image
 import matplotlib.pyplot as plt
 
-img = Image.open('plot_logging_to_terminal_image.png')
+img = Image.open("plot_logging_to_terminal_image.png")
 plt.imshow(img)
diff --git a/docs/source/examples/plot_moving_link_extremity.py b/docs/source/examples/plot_moving_link_extremity.py
index 16259c73f..44248e15e 100644
--- a/docs/source/examples/plot_moving_link_extremity.py
+++ b/docs/source/examples/plot_moving_link_extremity.py
@@ -45,19 +45,19 @@
 # We do NOT recommend this, though....  It is very slow for real networks
 # We plot the entire network
 curr = project.conn.cursor()
-curr.execute('Select link_id from links;')
+curr.execute("Select link_id from links;")
 
 for lid in curr.fetchall():
     geo = links.get(lid[0]).geometry
-    plt.plot(*geo.xy, color='blue')
+    plt.plot(*geo.xy, color="blue")
 
 all_nodes = project.network.nodes
 curr = project.conn.cursor()
-curr.execute('Select node_id from nodes;')
+curr.execute("Select node_id from nodes;")
 
 for nid in curr.fetchall():
     geo = all_nodes.get(nid[0]).geometry
-    plt.plot(*geo.xy, 'ro', color='black')
+    plt.plot(*geo.xy, "ro", color="black")
 
 plt.show()
 
diff --git a/docs/source/examples/plot_moving_nodes.py b/docs/source/examples/plot_moving_nodes.py
index c43a4bd39..abfa4ce29 100644
--- a/docs/source/examples/plot_moving_nodes.py
+++ b/docs/source/examples/plot_moving_nodes.py
@@ -38,13 +38,13 @@
 # We plot the entire network
 links.refresh()
 curr = project.conn.cursor()
-curr.execute('Select link_id from links;')
+curr.execute("Select link_id from links;")
 
 for lid in curr.fetchall():
     geo = links.get(lid[0]).geometry
-    plt.plot(*geo.xy, color='blue')
+    plt.plot(*geo.xy, color="blue")
 
-plt.plot(*node.geometry.xy, 'ro', color='black')
+plt.plot(*node.geometry.xy, "ro", color="black")
 
 plt.show()
 
diff --git a/docs/source/examples/plot_path_and_skimming.py b/docs/source/examples/plot_path_and_skimming.py
index fb45819e5..e9cd9b904 100644
--- a/docs/source/examples/plot_path_and_skimming.py
+++ b/docs/source/examples/plot_path_and_skimming.py
@@ -39,16 +39,16 @@
 
 # %%
 # we grab the graph for cars
-graph = project.network.graphs['c']
+graph = project.network.graphs["c"]
 
 # we also see what graphs are available
 # project.network.graphs.keys()
 
 # let's say we want to minimize distance
-graph.set_graph('distance')
+graph.set_graph("distance")
 
 # And will skim time and distance while we are at it
-graph.set_skimming(['free_flow_time', 'distance'])
+graph.set_skimming(["free_flow_time", "distance"])
 
 # And we will allow paths to be compute going through other centroids/centroid connectors
 # required for the Sioux Falls network, as all nodes are centroids
@@ -98,14 +98,14 @@
 
 # We plot the entire network
 curr = project.conn.cursor()
-curr.execute('Select link_id from links;')
+curr.execute("Select link_id from links;")
 
 for lid in curr.fetchall():
     geo = links.get(lid[0]).geometry
-    plt.plot(*geo.xy, color='red')
+    plt.plot(*geo.xy, color="red")
 
 path_geometry = linemerge(links.get(lid).geometry for lid in res.path)
-plt.plot(*path_geometry.xy, color='blue', linestyle='dashed', linewidth=2)
+plt.plot(*path_geometry.xy, color="blue", linestyle="dashed", linewidth=2)
 plt.show()
 
 # %% md
@@ -143,12 +143,12 @@
 # %%
 
 # We can save it to the project if we want
-skm.save_to_project('base_skims')
+skm.save_to_project("base_skims")
 
 # We can also retrieve this skim record to write something to its description
 matrices = project.matrices
-mat_record = matrices.get_record('base_skims')
-mat_record.description = 'minimized FF travel time while also skimming distance for just a few nodes'
+mat_record = matrices.get_record("base_skims")
+mat_record.description = "minimized FF travel time while also skimming distance for just a few nodes"
 mat_record.save()
 
 # %%
diff --git a/docs/source/examples/plot_splitting_link.py b/docs/source/examples/plot_splitting_link.py
index 64c935a0b..92fde1555 100644
--- a/docs/source/examples/plot_splitting_link.py
+++ b/docs/source/examples/plot_splitting_link.py
@@ -51,31 +51,31 @@
 # %%
 # We can plot the two links only
 plt.clf()
-plt.plot(*link.geometry.xy, color='blue')
-plt.plot(*new_link.geometry.xy, color='blue')
+plt.plot(*link.geometry.xy, color="blue")
+plt.plot(*new_link.geometry.xy, color="blue")
 
 for node in [link.a_node, link.b_node, new_link.b_node]:
     geo = all_nodes.get(node).geometry
-    plt.plot(*geo.xy, 'ro', color='black')
+    plt.plot(*geo.xy, "ro", color="black")
 plt.show()
 
 # %%
 # Or we plot the entire network
 plt.clf()
 curr = project.conn.cursor()
-curr.execute('Select link_id from links;')
+curr.execute("Select link_id from links;")
 
 for lid in curr.fetchall():
     geo = links.get(lid[0]).geometry
-    plt.plot(*geo.xy, color='blue')
+    plt.plot(*geo.xy, color="blue")
 
 all_nodes = project.network.nodes
 curr = project.conn.cursor()
-curr.execute('Select node_id from nodes;')
+curr.execute("Select node_id from nodes;")
 
 for nid in curr.fetchall():
     geo = all_nodes.get(nid[0]).geometry
-    plt.plot(*geo.xy, 'ro', color='black')
+    plt.plot(*geo.xy, "ro", color="black")
 
 plt.show()
 
diff --git a/docs/website/check_documentation_versions.py b/docs/website/check_documentation_versions.py
index 436da853b..12b5a9edb 100644
--- a/docs/website/check_documentation_versions.py
+++ b/docs/website/check_documentation_versions.py
@@ -8,6 +8,7 @@
 except ImportError as e:
     sys.path.insert(0, npth)
     from aequilibrae.paths.__version__ import release_version
+
     print(e.args)
 
 # We check if the reference to all existing versions were added by checking
@@ -15,5 +16,5 @@
 with open(os.path.join(npth, "docs/source/index.rst"), mode="r") as f:
     txt = f.read()
 
-assert (f'`{release_version}' in txt)
-assert (f'V.{release_version}' in txt)
+assert f"`{release_version}" in txt
+assert f"V.{release_version}" in txt
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 000000000..3b67022cb
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,4 @@
+[tool.black]
+line-length = 120
+target-version = ['py36', 'py37', 'py38']
+include = '\.pyi?$'
\ No newline at end of file


Test patch:
diff --git a/.github/workflows/unit_tests.yml b/.github/workflows/unit_tests.yml
index a0667156e..da82558b2 100644
--- a/.github/workflows/unit_tests.yml
+++ b/.github/workflows/unit_tests.yml
@@ -22,6 +22,9 @@ jobs:
       - name: Lint with flake8
         run: flake8
 
+      - name: Check code format with Black
+        run: black --check .
+
   testing:
     needs: linting
     runs-on: ${{ matrix.os}}
diff --git a/test_requirements.txt b/test_requirements.txt
index 4e0752b3b..8f6855960 100644
--- a/test_requirements.txt
+++ b/test_requirements.txt
@@ -6,4 +6,5 @@ coveralls
 flake8
 tables
 wheel
-openmatrix
\ No newline at end of file
+openmatrix
+black
\ No newline at end of file
diff --git a/tests/aequilibrae/distribution/test_gravityApplication.py b/tests/aequilibrae/distribution/test_gravityApplication.py
index f076eb113..d521812cc 100644
--- a/tests/aequilibrae/distribution/test_gravityApplication.py
+++ b/tests/aequilibrae/distribution/test_gravityApplication.py
@@ -8,7 +8,7 @@
 zones = 10
 
 # row vector
-args = {"entries": zones, "field_names": [u"rows"], "data_types": [np.float64], "memory_mode": True}
+args = {"entries": zones, "field_names": ["rows"], "data_types": [np.float64], "memory_mode": True}
 
 row_vector = AequilibraeData()
 row_vector.create_empty(**args)
diff --git a/tests/aequilibrae/distribution/test_gravityCalibration.py b/tests/aequilibrae/distribution/test_gravityCalibration.py
index 274898233..b564cb913 100644
--- a/tests/aequilibrae/distribution/test_gravityCalibration.py
+++ b/tests/aequilibrae/distribution/test_gravityCalibration.py
@@ -40,7 +40,7 @@ def test_calibrate(self):
     def test_calibrate_with_omx(self):
         imped = AequilibraeMatrix()
         imped.load(siouxfalls_skims)
-        imped.computational_view(['free_flow_time'])
+        imped.computational_view(["free_flow_time"])
 
         mat = AequilibraeMatrix()
         mat.load(siouxfalls_demand)
diff --git a/tests/aequilibrae/distribution/test_ipf.py b/tests/aequilibrae/distribution/test_ipf.py
index c9661181f..02fa147f3 100644
--- a/tests/aequilibrae/distribution/test_ipf.py
+++ b/tests/aequilibrae/distribution/test_ipf.py
@@ -14,7 +14,7 @@
 
 class TestIpf(TestCase):
     def setUp(self) -> None:
-        os.environ['PATH'] = os.path.join(gettempdir(), 'temp_data') + ';' + os.environ['PATH']
+        os.environ["PATH"] = os.path.join(gettempdir(), "temp_data") + ";" + os.environ["PATH"]
 
         self.proj_dir = os.path.join(gettempdir(), uuid.uuid4().hex)
         copytree(siouxfalls_project, self.proj_dir)
@@ -24,8 +24,8 @@ def test_fit(self):
         proj.open(self.proj_dir)
         mats = proj.matrices
         mats.update_database()
-        seed = mats.get_matrix('SiouxFalls_omx')
-        seed.computational_view('matrix')
+        seed = mats.get_matrix("SiouxFalls_omx")
+        seed.computational_view("matrix")
         # row vector
         args = {"entries": seed.zones, "field_names": ["rows"], "data_types": [np.float64], "memory_mode": True}
         row_vector = AequilibraeData()
@@ -52,12 +52,12 @@ def test_fit(self):
         }
 
         with self.assertRaises(TypeError):
-            fratar = Ipf(data='test', test='data')
+            fratar = Ipf(data="test", test="data")
             fratar.fit()
 
         with self.assertRaises(ValueError):
             fratar = Ipf(**args)
-            fratar.parameters = ['test']
+            fratar.parameters = ["test"]
             fratar.fit()
 
         fratar = Ipf(**args)
@@ -65,14 +65,16 @@ def test_fit(self):
 
         result = fratar.output
 
-        self.assertAlmostEqual(np.nansum(result.matrix_view), np.nansum(row_vector.data["rows"]), 4,
-                               "Ipf did not converge")
+        self.assertAlmostEqual(
+            np.nansum(result.matrix_view), np.nansum(row_vector.data["rows"]), 4, "Ipf did not converge"
+        )
         self.assertGreater(fratar.parameters["convergence level"], fratar.gap, "Ipf did not converge")
 
-        mr = fratar.save_to_project('my_matrix_ipf', 'my_matrix_ipf.aem')
+        mr = fratar.save_to_project("my_matrix_ipf", "my_matrix_ipf.aem")
 
-        self.assertTrue(os.path.isfile(os.path.join(mats.fldr, 'my_matrix_ipf.aem')),
-                        'Did not save file to the appropriate place')
+        self.assertTrue(
+            os.path.isfile(os.path.join(mats.fldr, "my_matrix_ipf.aem")), "Did not save file to the appropriate place"
+        )
 
-        self.assertEqual(mr.procedure_id, fratar.procedure_id, 'procedure ID saved wrong')
+        self.assertEqual(mr.procedure_id, fratar.procedure_id, "procedure ID saved wrong")
         proj.close()
diff --git a/tests/aequilibrae/log/test_log.py b/tests/aequilibrae/log/test_log.py
index 13030c7e2..73f93ae5b 100644
--- a/tests/aequilibrae/log/test_log.py
+++ b/tests/aequilibrae/log/test_log.py
@@ -9,7 +9,7 @@
 
 class TestLog(TestCase):
     def setUp(self) -> None:
-        os.environ['PATH'] = os.path.join(gettempdir(), 'temp_data') + ';' + os.environ['PATH']
+        os.environ["PATH"] = os.path.join(gettempdir(), "temp_data") + ";" + os.environ["PATH"]
         self.proj_dir = os.path.join(gettempdir(), uuid.uuid4().hex)
         copytree(siouxfalls_project, self.proj_dir)
 
@@ -22,12 +22,12 @@ def tearDown(self) -> None:
     def test_contents(self):
         log = self.project.log()
         cont = log.contents()
-        self.assertEqual(len(cont), 4, 'Returned the wrong amount of data from the log')
+        self.assertEqual(len(cont), 4, "Returned the wrong amount of data from the log")
 
     def test_clear(self):
         log = self.project.log()
         log.clear()
 
-        with open(os.path.join(self.proj_dir, "aequilibrae.log"), 'r') as file:
+        with open(os.path.join(self.proj_dir, "aequilibrae.log"), "r") as file:
             q = file.readlines()
-        self.assertEqual(len(q), 0, 'Failed to clear the log file')
+        self.assertEqual(len(q), 0, "Failed to clear the log file")
diff --git a/tests/aequilibrae/matrix/test_aequilibraeMatrix.py b/tests/aequilibrae/matrix/test_aequilibraeMatrix.py
index 7b408b785..ff79229d3 100644
--- a/tests/aequilibrae/matrix/test_aequilibraeMatrix.py
+++ b/tests/aequilibrae/matrix/test_aequilibraeMatrix.py
@@ -74,7 +74,7 @@ def test_computational_view(self):
             self.fail("Computational view returns the wrong number of matrices")
 
         self.new_matrix.computational_view(["mat"])
-        self.new_matrix.matrix_view[:, :] = np.arange(zones ** 2).reshape(zones, zones)
+        self.new_matrix.matrix_view[:, :] = np.arange(zones**2).reshape(zones, zones)
         if np.sum(self.new_matrix.mat) != np.sum(self.new_matrix.matrix_view):
             self.fail("Assigning to matrix view did not work")
         self.new_matrix.setName("Test matrix - " + str(random.randint(1, 10)))
diff --git a/tests/aequilibrae/paths/test_mc_traffic_assignment.py b/tests/aequilibrae/paths/test_mc_traffic_assignment.py
index 3502d1334..03057b8d6 100644
--- a/tests/aequilibrae/paths/test_mc_traffic_assignment.py
+++ b/tests/aequilibrae/paths/test_mc_traffic_assignment.py
@@ -28,18 +28,18 @@ def setUp(self) -> None:
         self.moto_graph = self.project.network.graphs["M"]  # type: Graph
 
         for graph in [self.car_graph, self.truck_graph, self.moto_graph]:
-            graph.set_skimming(['free_flow_time'])
+            graph.set_skimming(["free_flow_time"])
             graph.set_graph("free_flow_time")
             graph.set_blocked_centroid_flows(False)
 
         self.car_matrix = self.project.matrices.get_matrix("demand_mc")
-        self.car_matrix.computational_view(['car'])
+        self.car_matrix.computational_view(["car"])
 
         self.truck_matrix = self.project.matrices.get_matrix("demand_mc")
-        self.truck_matrix.computational_view(['trucks'])
+        self.truck_matrix.computational_view(["trucks"])
 
         self.moto_matrix = self.project.matrices.get_matrix("demand_mc")
-        self.moto_matrix.computational_view(['motorcycle'])
+        self.moto_matrix.computational_view(["motorcycle"])
 
         self.assignment = TrafficAssignment()
         self.carclass = TrafficClass("car", self.car_graph, self.car_matrix)
@@ -69,7 +69,7 @@ def test_execute_and_save_results(self):
         self.assignment.set_classes([self.carclass, self.truckclass, self.motoclass])
 
         for cls in self.assignment.classes:
-            cls.graph.set_skimming(['free_flow_time', 'distance'])
+            cls.graph.set_skimming(["free_flow_time", "distance"])
         self.assignment.set_vdf("BPR")
         self.assignment.set_vdf_parameters({"alpha": 0.15, "beta": 4.0})
         self.assignment.set_vdf_parameters({"alpha": "b", "beta": "power"})
diff --git a/tests/aequilibrae/paths/test_network_skimming.py b/tests/aequilibrae/paths/test_network_skimming.py
index bd053fc31..fcf5a69a3 100644
--- a/tests/aequilibrae/paths/test_network_skimming.py
+++ b/tests/aequilibrae/paths/test_network_skimming.py
@@ -16,7 +16,7 @@
 
 class TestNetwork_skimming(TestCase):
     def setUp(self) -> None:
-        os.environ['PATH'] = os.path.join(gettempdir(), 'temp_data') + ';' + os.environ['PATH']
+        os.environ["PATH"] = os.path.join(gettempdir(), "temp_data") + ";" + os.environ["PATH"]
 
         self.proj_dir = os.path.join(gettempdir(), uuid.uuid4().hex)
 
@@ -30,12 +30,12 @@ def tearDown(self) -> None:
         try:
             rmtree(self.proj_dir)
         except Exception as e:
-            print(f'Failed to remove at {e.args}')
+            print(f"Failed to remove at {e.args}")
 
     def test_network_skimming(self):
 
         self.network.build_graphs()
-        graph = self.network.graphs['c']
+        graph = self.network.graphs["c"]
         graph.set_graph(cost_field="distance")
         graph.set_skimming("distance")
         graph.set_blocked_centroid_flows(False)
@@ -57,18 +57,18 @@ def test_network_skimming(self):
         if skm.report:
             self.fail("Skimming returned an error:" + str(skm.report))
 
-        fn = 'test_Skimming'
-        skm.save_to_project(fn, format='omx')
-        matrix_dir = join(self.proj_dir, 'matrices')
+        fn = "test_Skimming"
+        skm.save_to_project(fn, format="omx")
+        matrix_dir = join(self.proj_dir, "matrices")
 
-        if not isfile(join(matrix_dir, f'{fn}.omx')):
-            self.fail('Did not save project to project')
+        if not isfile(join(matrix_dir, f"{fn}.omx")):
+            self.fail("Did not save project to project")
 
         matrices = self.project.matrices
         mat = matrices.get_record(fn)
-        self.assertEqual(mat.name, fn, 'Matrix record name saved wrong')
-        self.assertEqual(mat.file_name, f'{fn}.omx', 'matrix file_name saved  wrong')
-        self.assertEqual(mat.cores, 1, 'matrix saved number of matrix cores wrong')
-        self.assertEqual(mat.procedure, 'Network skimming', 'Matrix saved wrong procedure name')
-        self.assertEqual(mat.procedure_id, skm.procedure_id, 'Procedure ID saved  wrong')
-        self.assertEqual(mat.timestamp, skm.procedure_date, 'Procedure ID saved  wrong')
+        self.assertEqual(mat.name, fn, "Matrix record name saved wrong")
+        self.assertEqual(mat.file_name, f"{fn}.omx", "matrix file_name saved  wrong")
+        self.assertEqual(mat.cores, 1, "matrix saved number of matrix cores wrong")
+        self.assertEqual(mat.procedure, "Network skimming", "Matrix saved wrong procedure name")
+        self.assertEqual(mat.procedure_id, skm.procedure_id, "Procedure ID saved  wrong")
+        self.assertEqual(mat.timestamp, skm.procedure_date, "Procedure ID saved  wrong")
diff --git a/tests/aequilibrae/paths/test_parallel_numpy.py b/tests/aequilibrae/paths/test_parallel_numpy.py
index 2a4a61e83..bb9634e43 100644
--- a/tests/aequilibrae/paths/test_parallel_numpy.py
+++ b/tests/aequilibrae/paths/test_parallel_numpy.py
@@ -11,21 +11,21 @@ def test_sum_axis1(self):
         b = np.sum(source, axis=1)
 
         sum_axis1(target, source, 1)
-        self.assertEqual((b - target).max(), 0, 'Sum Axis 1 failed')
+        self.assertEqual((b - target).max(), 0, "Sum Axis 1 failed")
 
     def test_linear_combination(self):
         target = np.zeros((50, 1))
         source = np.random.rand(50).reshape(50, 1)
 
         linear_combination(target, source, target, 0.05, 1)
-        self.assertEqual((source - target * 20).max(), 0, 'Linear combination failed')
+        self.assertEqual((source - target * 20).max(), 0, "Linear combination failed")
 
     def test_linear_combination_skims(self):
         target = np.zeros((5, 5, 1))
         source = np.random.rand(25).reshape(5, 5, 1)
 
         linear_combination_skims(target, source, target, 0.8, 1)
-        self.assertEqual((source - target * 5 / 4).max(), 0, 'Linear combination failed')
+        self.assertEqual((source - target * 5 / 4).max(), 0, "Linear combination failed")
 
     def test_triple_linear_combination(self):
         pass
@@ -39,9 +39,9 @@ def test_copy_one_dimension(self):
 
         copy_one_dimension(target, source, 1)
 
-        self.assertEqual(target.sum(), source.sum(), 'Copying one dimension returned different values')
+        self.assertEqual(target.sum(), source.sum(), "Copying one dimension returned different values")
         if target.sum() == 0:
-            self.fail('Target and source are the other way around for copying one dimension')
+            self.fail("Target and source are the other way around for copying one dimension")
 
     def test_copy_two_dimensions(self):
         target = np.zeros(50).reshape(10, 5)
@@ -49,9 +49,9 @@ def test_copy_two_dimensions(self):
 
         copy_two_dimensions(target, source, 1)
 
-        self.assertEqual(target.sum(), source.sum(), 'Copying one dimension returned different values')
+        self.assertEqual(target.sum(), source.sum(), "Copying one dimension returned different values")
         if target.sum() == 0:
-            self.fail('Target and source are the other way around for copying one dimension')
+            self.fail("Target and source are the other way around for copying one dimension")
 
     def test_copy_three_dimensions(self):
         target = np.zeros(50).reshape(5, 2, 5)
@@ -59,10 +59,10 @@ def test_copy_three_dimensions(self):
 
         copy_three_dimensions(target, source, 1)
 
-        self.assertEqual(target.sum(), source.sum(), 'Copying one dimension returned different values')
+        self.assertEqual(target.sum(), source.sum(), "Copying one dimension returned different values")
         if target.sum() == 0:
-            self.fail('Target and source are the other way around for copying one dimension')
+            self.fail("Target and source are the other way around for copying one dimension")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()
diff --git a/tests/aequilibrae/paths/test_pathDisconnected_net.py b/tests/aequilibrae/paths/test_pathDisconnected_net.py
index d2198ca42..3128ef3b1 100644
--- a/tests/aequilibrae/paths/test_pathDisconnected_net.py
+++ b/tests/aequilibrae/paths/test_pathDisconnected_net.py
@@ -27,7 +27,7 @@ def tearDown(self) -> None:
         self.project.close()
 
     def test_path_disconnected_delete_link(self):
-        self.project.conn.executemany('delete from Links where link_id=?', [[2], [4], [5], [14]])
+        self.project.conn.executemany("delete from Links where link_id=?", [[2], [4], [5], [14]])
         self.project.conn.commit()
 
         self.project.network.build_graphs()
@@ -37,9 +37,9 @@ def test_path_disconnected_delete_link(self):
         self.r = PathResults()
         self.r.prepare(self.g)
         self.r.compute_path(1, 5)
-        self.assertEqual(None, self.r.path, 'Failed to return None for disconnected')
+        self.assertEqual(None, self.r.path, "Failed to return None for disconnected")
         self.r.compute_path(1, 2)
-        self.assertEqual(len(self.r.path), 1, 'Returned the wrong thing for existing path on disconnected network')
+        self.assertEqual(len(self.r.path), 1, "Returned the wrong thing for existing path on disconnected network")
 
     def test_path_disconnected_penalize_link_in_memory(self):
         links = [2, 4, 5, 14]
@@ -52,6 +52,6 @@ def test_path_disconnected_penalize_link_in_memory(self):
         r = PathResults()
         r.prepare(g)
         r.compute_path(1, 5)
-        self.assertEqual(None, r.path, 'Failed to return None for disconnected')
+        self.assertEqual(None, r.path, "Failed to return None for disconnected")
         r.compute_path(1, 2)
-        self.assertEqual(len(r.path), 1, 'Returned the wrong thing for existing path on disconnected network')
+        self.assertEqual(len(r.path), 1, "Returned the wrong thing for existing path on disconnected network")
diff --git a/tests/aequilibrae/paths/test_pathResults.py b/tests/aequilibrae/paths/test_pathResults.py
index a44115073..4fe1911ec 100644
--- a/tests/aequilibrae/paths/test_pathResults.py
+++ b/tests/aequilibrae/paths/test_pathResults.py
@@ -90,7 +90,7 @@ def test_update_trace(self):
 
 class TestBlockingTrianglePathResults(TestCase):
     def setUp(self) -> None:
-        os.environ['PATH'] = os.path.join(gettempdir(), 'temp_data') + ';' + os.environ['PATH']
+        os.environ["PATH"] = os.path.join(gettempdir(), "temp_data") + ";" + os.environ["PATH"]
         self.proj_dir = os.path.join(gettempdir(), uuid.uuid4().hex)
         copytree(triangle_graph_blocking, self.proj_dir)
         self.project = Project()
@@ -182,13 +182,13 @@ def test_compute_paths_centroid_last_node_id(self):
         # centroids if we were skimming and one of them had the highest node_id
         # in the entire network
         zipfile.ZipFile(st_varent_network).extractall(gettempdir())
-        self.st_varent = join(gettempdir(), 'St_Varent')
+        self.st_varent = join(gettempdir(), "St_Varent")
         self.project = Project()
         self.project.open(self.st_varent)
         self.project.network.build_graphs()
         self.g = self.project.network.graphs["c"]  # type: Graph
         self.g.set_graph("distance")
-        self.g.set_skimming('distance')
+        self.g.set_skimming("distance")
 
         self.r = PathResults()
         self.r.prepare(self.g)
diff --git a/tests/aequilibrae/paths/test_traffic_assignment_save_path_files.py b/tests/aequilibrae/paths/test_traffic_assignment_save_path_files.py
index 6c4731dfc..6fc79f27d 100644
--- a/tests/aequilibrae/paths/test_traffic_assignment_save_path_files.py
+++ b/tests/aequilibrae/paths/test_traffic_assignment_save_path_files.py
@@ -19,7 +19,7 @@ def setUp(self) -> None:
 
         proj_path = os.path.join(gettempdir(), "test_traffic_assignment_path_files" + uuid.uuid4().hex)
         os.mkdir(proj_path)
-        zipfile.ZipFile(join(dirname(siouxfalls_project), 'sioux_falls_single_class.zip')).extractall(proj_path)
+        zipfile.ZipFile(join(dirname(siouxfalls_project), "sioux_falls_single_class.zip")).extractall(proj_path)
         self.project = Project()
         self.project.open(proj_path)
         self.project.network.build_graphs()
diff --git a/tests/aequilibrae/paths/test_vdf.py b/tests/aequilibrae/paths/test_vdf.py
index fea84c4b9..439008cbd 100644
--- a/tests/aequilibrae/paths/test_vdf.py
+++ b/tests/aequilibrae/paths/test_vdf.py
@@ -5,7 +5,9 @@
 class TestVDF(TestCase):
     def test_functions_available(self):
         v = VDF()
-        self.assertEqual(v.functions_available(), ["bpr", "bpr2", "conical", "inrets"], "VDF class returning wrong availability")
+        self.assertEqual(
+            v.functions_available(), ["bpr", "bpr2", "conical", "inrets"], "VDF class returning wrong availability"
+        )
         self.assertEqual(v.apply_vdf, None, "VDF is missing term")
         self.assertEqual(v.apply_derivative, None, "VDF is missing term")
 
diff --git a/tests/aequilibrae/project/test_about.py b/tests/aequilibrae/project/test_about.py
index e7b081c66..4bfbdbaad 100644
--- a/tests/aequilibrae/project/test_about.py
+++ b/tests/aequilibrae/project/test_about.py
@@ -12,7 +12,7 @@
 
 class TestAbout(TestCase):
     def setUp(self) -> None:
-        os.environ['PATH'] = os.path.join(tempfile.gettempdir(), 'temp_data') + ';' + os.environ['PATH']
+        os.environ["PATH"] = os.path.join(tempfile.gettempdir(), "temp_data") + ";" + os.environ["PATH"]
         self.temp_proj_folder = os.path.join(tempfile.gettempdir(), uuid.uuid4().hex)
         copytree(siouxfalls_project, self.temp_proj_folder)
         self.proj = Project()
@@ -29,17 +29,29 @@ def test_create_and_list(self):
             self.proj.about.create()
 
         list = self.proj.about.list_fields()
-        expected = ['model_name', 'region', 'description', 'author', 'license', 'scenario_name', 'year',
-                    'scenario_description', 'model_version', 'project_id', 'aequilibrae_version', 'projection']
+        expected = [
+            "model_name",
+            "region",
+            "description",
+            "author",
+            "license",
+            "scenario_name",
+            "year",
+            "scenario_description",
+            "model_version",
+            "project_id",
+            "aequilibrae_version",
+            "projection",
+        ]
 
         failed = set(list).symmetric_difference(set(expected))
         if failed:
-            self.fail('About table does not have all expected fields')
+            self.fail("About table does not have all expected fields")
 
     # idea from https://stackoverflow.com/a/2030081/1480643
     def randomword(self, length):
-        letters = string.ascii_lowercase + '_'
-        return ''.join(random.choice(letters) for i in range(length))
+        letters = string.ascii_lowercase + "_"
+        return "".join(random.choice(letters) for i in range(length))
 
     def test_add_info_field(self):
         self.proj.about.create()
@@ -57,19 +69,19 @@ def test_add_info_field(self):
         charac = [x[0] for x in curr.fetchall()]
         for k in all_added:
             if k not in charac:
-                self.fail(f'Failed to add {k}')
+                self.fail(f"Failed to add {k}")
 
         # Should fail when trying to add a repeated guy
         with self.assertRaises(sqlite3.IntegrityError):
-            self.proj.about.add_info_field('description')
+            self.proj.about.add_info_field("description")
 
         # Should fail when trying to add a repeated guy
         with self.assertRaises(ValueError):
-            self.proj.about.add_info_field('descr1ption')
+            self.proj.about.add_info_field("descr1ption")
 
     def test_write_back(self):
         self.proj.about.create()
-        self.proj.about.add_info_field('good_info_field_perhaps')
+        self.proj.about.add_info_field("good_info_field_perhaps")
 
         val = self.randomword(random.randint(1, 15))
         self.proj.about.good_info_field_perhaps = val
@@ -84,5 +96,5 @@ def test_write_back(self):
 
         self.proj = Project()
         self.proj.open(self.temp_proj_folder)
-        self.assertEqual(val, self.proj.about.good_info_field_perhaps, 'failed to save data to about table')
-        self.assertEqual(val2, self.proj.about.description, 'failed to save data to about table')
+        self.assertEqual(val, self.proj.about.good_info_field_perhaps, "failed to save data to about table")
+        self.assertEqual(val2, self.proj.about.description, "failed to save data to about table")
diff --git a/tests/aequilibrae/project/test_database_connection.py b/tests/aequilibrae/project/test_database_connection.py
index 70efd7a67..d93dcc5cc 100644
--- a/tests/aequilibrae/project/test_database_connection.py
+++ b/tests/aequilibrae/project/test_database_connection.py
@@ -8,7 +8,7 @@
 
 class TestDatabaseConnection(TestCase):
     def setUp(self) -> None:
-        os.environ['PATH'] = os.path.join(tempfile.gettempdir(), 'temp_data') + ';' + os.environ['PATH']
+        os.environ["PATH"] = os.path.join(tempfile.gettempdir(), "temp_data") + ";" + os.environ["PATH"]
 
     def test_database_connection(self):
         # Errors when project does not exist
@@ -25,7 +25,7 @@ def test_connection_with_new_project(self):
         proj.open(temp_proj_folder)
         conn = database_connection()
         cursor = conn.cursor()
-        cursor.execute('select count(*) from links')
+        cursor.execute("select count(*) from links")
 
         self.assertEqual(cursor.fetchone()[0], 0, "Returned more links thant it should have")
         proj.close()
diff --git a/tests/aequilibrae/project/test_link.py b/tests/aequilibrae/project/test_link.py
index 1729711e5..bead1f796 100644
--- a/tests/aequilibrae/project/test_link.py
+++ b/tests/aequilibrae/project/test_link.py
@@ -13,7 +13,7 @@
 
 class TestLink(TestCase):
     def setUp(self) -> None:
-        os.environ['PATH'] = os.path.join(gettempdir(), '../../temp_data') + ';' + os.environ['PATH']
+        os.environ["PATH"] = os.path.join(gettempdir(), "../../temp_data") + ";" + os.environ["PATH"]
 
         self.proj_dir = os.path.join(gettempdir(), uuid.uuid4().hex)
         copytree(siouxfalls_project, self.proj_dir)
@@ -35,7 +35,7 @@ def tearDown(self) -> None:
         try:
             rmtree(self.proj_dir)
         except Exception as e:
-            print(f'Failed to remove at {e.args}')
+            print(f"Failed to remove at {e.args}")
 
     def test_delete(self):
         self.link.delete()
@@ -43,14 +43,14 @@ def test_delete(self):
         with self.assertRaises(Exception):
             _ = self.links.get(self.lid)
 
-        self.curr.execute('Select count(*) from links where link_id=?', [self.lid])
+        self.curr.execute("Select count(*) from links where link_id=?", [self.lid])
 
-        self.assertEqual(0, self.curr.fetchone()[0], f'Failed to delete link {self.lid}')
+        self.assertEqual(0, self.curr.fetchone()[0], f"Failed to delete link {self.lid}")
 
     def test_save(self):
         self.link.save()
         extension = random()
-        name = 'just a non-important value'
+        name = "just a non-important value"
 
         geo = substring(self.link.geometry, 0, extension, normalized=True)
 
@@ -61,54 +61,54 @@ def test_save(self):
         self.links.refresh()
         link2 = self.links.get(self.lid)
 
-        self.assertEqual(link2.name, name, 'Failed to save the link name')
-        self.assertAlmostEqual(link2.geometry, geo, 3, 'Failed to save the link geometry')
+        self.assertEqual(link2.name, name, "Failed to save the link name")
+        self.assertAlmostEqual(link2.geometry, geo, 3, "Failed to save the link geometry")
 
         tot_prev = self.network.count_links()
         lnk = self.links.new()
         lnk.geometry = substring(self.link.geometry, 0, 0.88, normalized=True)
-        lnk.modes = 'c'
+        lnk.modes = "c"
         lnk.save()
 
-        self.assertEqual(tot_prev + 1, self.network.count_links(), 'Failed to save new link')
+        self.assertEqual(tot_prev + 1, self.network.count_links(), "Failed to save new link")
 
     def test_set_modes(self):
-        self.link.set_modes('cbt')
+        self.link.set_modes("cbt")
 
-        self.assertEqual(self.link.modes, 'cbt', 'Did not set modes correctly')
+        self.assertEqual(self.link.modes, "cbt", "Did not set modes correctly")
         self.link.save()
 
-        self.assertEqual(self.__check_mode(), 'cbt')
+        self.assertEqual(self.__check_mode(), "cbt")
 
     def test_add_mode(self):
-        for mode in [1, ['cbt']]:
+        for mode in [1, ["cbt"]]:
             with self.assertRaises(TypeError):
                 self.link.add_mode(mode)
         with self.assertRaises(ValueError):
-            self.link.add_mode('bt')
+            self.link.add_mode("bt")
 
-        self.link.add_mode('b')
+        self.link.add_mode("b")
         self.link.save()
-        self.assertEqual(self.__check_mode(), 'cb')
+        self.assertEqual(self.__check_mode(), "cb")
 
-        mode = self.modes.get('t')
+        mode = self.modes.get("t")
         self.link.add_mode(mode)
         self.link.save()
-        self.assertEqual(self.__check_mode(), 'cbt')
+        self.assertEqual(self.__check_mode(), "cbt")
 
     def test_drop_mode(self):
-        self.link.set_modes('cbt')
+        self.link.set_modes("cbt")
         self.link.save()
-        self.assertEqual(self.__check_mode(), 'cbt')
+        self.assertEqual(self.__check_mode(), "cbt")
 
-        self.link.drop_mode('t')
+        self.link.drop_mode("t")
         self.link.save()
-        self.assertEqual(self.__check_mode(), 'cb')
+        self.assertEqual(self.__check_mode(), "cb")
 
-        mode = self.modes.get('b')
+        mode = self.modes.get("b")
         self.link.drop_mode(mode)
         self.link.save()
-        self.assertEqual(self.__check_mode(), 'c')
+        self.assertEqual(self.__check_mode(), "c")
 
     def test_data_fields(self):
 
@@ -116,17 +116,17 @@ def test_data_fields(self):
         while link2.link_id == self.link.link_id:
             link2 = self.links.get(randint(1, 24))
 
-        self.assertEqual(link2.data_fields(), self.link.data_fields(), 'Different links have different data fields')
+        self.assertEqual(link2.data_fields(), self.link.data_fields(), "Different links have different data fields")
 
         fields = sorted(link2.data_fields())
-        self.curr.execute('pragma table_info(links)')
+        self.curr.execute("pragma table_info(links)")
         dt = self.curr.fetchall()
 
-        data_fields = sorted([x[1] for x in dt if x[1] != 'ogc_fid'])
+        data_fields = sorted([x[1] for x in dt if x[1] != "ogc_fid"])
 
-        self.assertEqual(sorted(fields), sorted(data_fields), 'Link has unexpected set of fields')
+        self.assertEqual(sorted(fields), sorted(data_fields), "Link has unexpected set of fields")
 
     def __check_mode(self):
-        sql = 'Select modes from links where link_id=?'
+        sql = "Select modes from links where link_id=?"
         self.curr.execute(sql, [self.lid])
         return self.curr.fetchone()[0]
diff --git a/tests/aequilibrae/project/test_link_type.py b/tests/aequilibrae/project/test_link_type.py
index 4e9f1f31c..31112f29f 100644
--- a/tests/aequilibrae/project/test_link_type.py
+++ b/tests/aequilibrae/project/test_link_type.py
@@ -18,8 +18,8 @@ def setUp(self) -> None:
         self.proj.open(self.temp_proj_folder)
         self.curr = self.proj.conn.cursor()
 
-        letters = [random.choice(string.ascii_letters + '_') for x in range(20)]
-        self.random_string = ''.join(letters)
+        letters = [random.choice(string.ascii_letters + "_") for x in range(20)]
+        self.random_string = "".join(letters)
 
     def tearDown(self) -> None:
         self.proj.close()
@@ -30,15 +30,15 @@ def test_changing_link_type_id(self):
         lt = random.choice([x for x in ltypes.all_types().values()])
 
         with self.assertRaises(ValueError):
-            lt.link_type_id = 'test my description'
+            lt.link_type_id = "test my description"
 
         with self.assertRaises(ValueError):
-            lt.link_type_id = 'K'
+            lt.link_type_id = "K"
 
     def test_empty(self):
         ltypes = self.proj.network.link_types
 
-        newt = ltypes.new('Z')
+        newt = ltypes.new("Z")
         # a.link_type = 'just a_test'
         with self.assertRaises(IntegrityError):
             newt.save()
@@ -46,7 +46,7 @@ def test_empty(self):
     def test_save(self):
         ltypes = self.proj.network.link_types
 
-        newt = ltypes.new('Z')
+        newt = ltypes.new("Z")
         newt.link_type = self.random_string
         newt.description = self.random_string[::-1]
         newt.save()
diff --git a/tests/aequilibrae/project/test_link_type_triggers.py b/tests/aequilibrae/project/test_link_type_triggers.py
index c02c6cdc0..9fa803c3d 100644
--- a/tests/aequilibrae/project/test_link_type_triggers.py
+++ b/tests/aequilibrae/project/test_link_type_triggers.py
@@ -20,13 +20,13 @@ def setUp(self) -> None:
         self.curr = self.proj.conn.cursor()
 
         # Modes to add
-        sql = 'INSERT INTO modes (mode_name, mode_id) VALUES (?, ?);'
-        for mid in ['p', 'l', 'g', 'x', 'y', 'd', 'k', 'a', 'r', 'n', 'm']:
-            self.curr.execute(sql, [f'mode_{mid}', mid])
+        sql = "INSERT INTO modes (mode_name, mode_id) VALUES (?, ?);"
+        for mid in ["p", "l", "g", "x", "y", "d", "k", "a", "r", "n", "m"]:
+            self.curr.execute(sql, [f"mode_{mid}", mid])
 
         self.proj.conn.commit()
 
-        root = os.path.dirname(os.path.realpath(__file__)).replace('tests', '')
+        root = os.path.dirname(os.path.realpath(__file__)).replace("tests", "")
         qry_file = os.path.join(root, "database_specification/triggers/link_type_table_triggers.sql")
         with open(qry_file, "r") as sql_file:
             self.queries = sql_file.read()
@@ -38,7 +38,7 @@ def setUp(self) -> None:
             curr.execute("SELECT rtreecheck('idx_nodes_geometry');")
         except Exception as e:
             self.rtree = False
-            warn(f'RTREE not available --> {e.args}')
+            warn(f"RTREE not available --> {e.args}")
 
     def tearDown(self) -> None:
         self.proj.close()
@@ -47,20 +47,20 @@ def __get_query(self, qry: str) -> str:
         for query in self.queries:
             if qry in query:
                 return query
-        raise FileNotFoundError('QUERY DOES NOT EXIST')
+        raise FileNotFoundError("QUERY DOES NOT EXIST")
 
     def test_all_tests_considered(self):
         tests_added = list(self.__dir__())
-        tests_added = [x[5:] for x in tests_added if x[:5] == 'test_']
+        tests_added = [x[5:] for x in tests_added if x[:5] == "test_"]
 
         for trigger in self.queries:
-            if 'TRIGGER' in trigger.upper():
+            if "TRIGGER" in trigger.upper():
                 found = [x for x in tests_added if x in trigger]
                 if not found:
-                    self.fail(f'Trigger not tested. {trigger}')
+                    self.fail(f"Trigger not tested. {trigger}")
 
     def test_link_type_single_letter_update(self):
-        cmd = self.__get_query('link_type_single_letter_update')
+        cmd = self.__get_query("link_type_single_letter_update")
         sql = "UPDATE 'link_types' SET link_type_id= 'ttt' where link_type_id='t'"
         self.curr.execute(sql)
 
@@ -71,17 +71,17 @@ def test_link_type_single_letter_update(self):
             self.curr.execute(sql)
 
     def test_link_type_single_letter_insert(self):
-        cmd = self.__get_query('link_type_single_letter_insert')
+        cmd = self.__get_query("link_type_single_letter_insert")
         sql = "INSERT INTO 'link_types' (link_type, link_type_id) VALUES(?, ?)"
-        self.curr.execute(sql, ['test1a', 'more_than_one'])
+        self.curr.execute(sql, ["test1a", "more_than_one"])
 
         self.curr.execute(cmd)
 
         with self.assertRaises(sqlite3.IntegrityError):
-            self.curr.execute(sql, ['test1b', 'mm'])
+            self.curr.execute(sql, ["test1b", "mm"])
 
     def test_link_type_keep_if_in_use_updating(self):
-        cmd = self.__get_query('link_type_keep_if_in_use_updating')
+        cmd = self.__get_query("link_type_keep_if_in_use_updating")
 
         sql = "UPDATE 'link_types' SET link_type= 'ttt' where link_type='test'"
         self.curr.execute(sql)
@@ -93,7 +93,7 @@ def test_link_type_keep_if_in_use_updating(self):
             self.curr.execute(sql)
 
     def test_link_type_keep_if_in_use_deleting(self):
-        cmd = self.__get_query('link_type_keep_if_in_use_deleting')
+        cmd = self.__get_query("link_type_keep_if_in_use_deleting")
 
         sql = "DELETE FROM 'link_types' where link_type='test3'"
         self.curr.execute(sql)
@@ -105,7 +105,7 @@ def test_link_type_keep_if_in_use_deleting(self):
             self.curr.execute(sql)
 
     def test_link_type_on_links_update(self):
-        cmd = self.__get_query('link_type_on_links_update')
+        cmd = self.__get_query("link_type_on_links_update")
 
         sql = "UPDATE 'links' SET link_type= 'rrr' where link_type='test3'"
         self.curr.execute(sql)
@@ -117,37 +117,37 @@ def test_link_type_on_links_update(self):
             self.curr.execute(sql)
 
     def test_link_type_on_links_insert(self):
-        cmd = self.__get_query('link_type_on_links_insert')
+        cmd = self.__get_query("link_type_on_links_insert")
 
         if self.rtree:
-            self.curr.execute('pragma table_info(links)')
+            self.curr.execute("pragma table_info(links)")
             f = self.curr.fetchall()
             fields = {x[1]: x[0] for x in f}
 
-            sql = 'select * from links where link_id=70'
+            sql = "select * from links where link_id=70"
             self.curr.execute(sql)
             a = [x for x in self.curr.fetchone()]
-            a[fields['link_type']] = 'something indeed silly123'
-            a[fields['link_id']] = 456789
-            a[fields['a_node']] = 777
-            a[fields['b_node']] = 999
+            a[fields["link_type"]] = "something indeed silly123"
+            a[fields["link_id"]] = 456789
+            a[fields["a_node"]] = 777
+            a[fields["b_node"]] = 999
             a[0] = 456789
 
-            idx = ','.join(['?'] * len(a))
-            self.curr.execute(f'insert into links values ({idx})', a)
-            self.curr.execute('delete from links where link_id=456789')
+            idx = ",".join(["?"] * len(a))
+            self.curr.execute(f"insert into links values ({idx})", a)
+            self.curr.execute("delete from links where link_id=456789")
 
             self.curr.execute(cmd)
 
             with self.assertRaises(sqlite3.IntegrityError):
-                self.curr.execute(f'insert into links values ({idx})', a)
+                self.curr.execute(f"insert into links values ({idx})", a)
 
-            self.curr.execute('select link_type from link_types;')
-            a[fields['link_type']] = self.curr.fetchone()[0]
-            self.curr.execute(f'insert into links values ({idx})', a)
+            self.curr.execute("select link_type from link_types;")
+            a[fields["link_type"]] = self.curr.fetchone()[0]
+            self.curr.execute(f"insert into links values ({idx})", a)
 
     def test_link_type_on_links_delete_protected_link_type(self):
-        cmd = self.__get_query('link_type_on_links_delete_protected_link_type')
+        cmd = self.__get_query("link_type_on_links_delete_protected_link_type")
 
         self.curr.execute(cmd)
         with self.assertRaises(sqlite3.IntegrityError):
@@ -157,7 +157,7 @@ def test_link_type_on_links_delete_protected_link_type(self):
             self.curr.execute('delete from link_types where link_type_id="y"')
 
     def test_link_type_id_keep_if_protected_type(self):
-        cmd = self.__get_query('link_type_id_keep_if_protected_type')
+        cmd = self.__get_query("link_type_id_keep_if_protected_type")
 
         self.curr.execute(cmd)
 
@@ -168,7 +168,7 @@ def test_link_type_id_keep_if_protected_type(self):
             self.curr.execute('update link_types set link_type_id="x" where link_type_id="z"')
 
     def test_link_type_keep_if_protected_type(self):
-        cmd = self.__get_query('link_type_keep_if_protected_type')
+        cmd = self.__get_query("link_type_keep_if_protected_type")
         self.curr.execute(cmd)
 
         with self.assertRaises(sqlite3.IntegrityError):
@@ -178,60 +178,60 @@ def test_link_type_keep_if_protected_type(self):
             self.curr.execute('update link_types set link_type="xsdfg" where link_type_id="y"')
 
     def test_link_type_on_nodes_table_update_nodes_link_type(self):
-        cmd = self.__get_query('link_type_on_nodes_table_update_nodes_link_type')
+        cmd = self.__get_query("link_type_on_nodes_table_update_nodes_link_type")
         self.curr.execute(cmd)
 
         self.curr.execute('update nodes set link_types="qwerrreyrtuyiuio" where node_id=1')
 
-        self.curr.execute('select link_types from nodes where node_id=1')
+        self.curr.execute("select link_types from nodes where node_id=1")
         lts = self.curr.fetchone()[0]
 
-        self.assertEqual(lts, 'etuw', 'link_types was allowed to be corrupted in the nodes table')
+        self.assertEqual(lts, "etuw", "link_types was allowed to be corrupted in the nodes table")
 
     def test_link_type_on_nodes_table_update_links_link_type(self):
-        cmd = self.__get_query('link_type_on_nodes_table_update_links_link_type')
+        cmd = self.__get_query("link_type_on_nodes_table_update_links_link_type")
         self.curr.execute(cmd)
 
         self.curr.execute('update links set link_type="test" where link_id=15')
 
-        self.curr.execute('select link_types from nodes where node_id=6')
+        self.curr.execute("select link_types from nodes where node_id=6")
         lts = self.curr.fetchone()[0]
 
-        self.assertEqual(lts, 'rtw', 'link_types on nodes table not updated with new link type in the links')
+        self.assertEqual(lts, "rtw", "link_types on nodes table not updated with new link type in the links")
 
-        self.curr.execute('select link_types from nodes where node_id=5')
+        self.curr.execute("select link_types from nodes where node_id=5")
         lts = self.curr.fetchone()[0]
 
-        self.assertEqual(lts, 'ertw', 'link_types was allowed to be corrupted in the nodes table')
+        self.assertEqual(lts, "ertw", "link_types was allowed to be corrupted in the nodes table")
 
     def test_link_type_on_nodes_table_update_links_a_node(self):
-        cmd = self.__get_query('link_type_on_nodes_table_update_links_a_node')
+        cmd = self.__get_query("link_type_on_nodes_table_update_links_a_node")
         self.curr.execute(cmd)
 
-        self.curr.execute('update links set a_node=1 where link_id=15')
+        self.curr.execute("update links set a_node=1 where link_id=15")
 
-        self.curr.execute('select link_types from nodes where node_id=1')
+        self.curr.execute("select link_types from nodes where node_id=1")
         lts = self.curr.fetchone()[0]
 
-        self.assertEqual(lts, 'etuw', 'link_types on nodes table not updated with new link type in the links')
+        self.assertEqual(lts, "etuw", "link_types on nodes table not updated with new link type in the links")
 
-        self.curr.execute('select link_types from nodes where node_id=6')
+        self.curr.execute("select link_types from nodes where node_id=6")
         lts = self.curr.fetchone()[0]
 
-        self.assertEqual(lts, 'rw', 'link_types was allowed to be corrupted in the nodes table')
+        self.assertEqual(lts, "rw", "link_types was allowed to be corrupted in the nodes table")
 
     def test_link_type_on_nodes_table_update_links_b_node(self):
-        cmd = self.__get_query('link_type_on_nodes_table_update_links_b_node')
+        cmd = self.__get_query("link_type_on_nodes_table_update_links_b_node")
         self.curr.execute(cmd)
 
-        self.curr.execute('update links set b_node=1 where link_id=15')
+        self.curr.execute("update links set b_node=1 where link_id=15")
 
-        self.curr.execute('select link_types from nodes where node_id=1')
+        self.curr.execute("select link_types from nodes where node_id=1")
         lts = self.curr.fetchone()[0]
 
-        self.assertEqual(lts, 'etuw', 'link_types on nodes table not updated with new link type in the links')
+        self.assertEqual(lts, "etuw", "link_types on nodes table not updated with new link type in the links")
 
-        self.curr.execute('select link_types from nodes where node_id=5')
+        self.curr.execute("select link_types from nodes where node_id=5")
         lts = self.curr.fetchone()[0]
 
-        self.assertEqual(lts, 'ertw', 'link_types was allowed to be corrupted in the nodes table')
+        self.assertEqual(lts, "ertw", "link_types was allowed to be corrupted in the nodes table")
diff --git a/tests/aequilibrae/project/test_link_types.py b/tests/aequilibrae/project/test_link_types.py
index af34f37d6..7c633ce86 100644
--- a/tests/aequilibrae/project/test_link_types.py
+++ b/tests/aequilibrae/project/test_link_types.py
@@ -17,8 +17,8 @@ def setUp(self) -> None:
         self.proj.open(self.temp_proj_folder)
         self.curr = self.proj.conn.cursor()
 
-        letters = [random.choice(string.ascii_letters + '_') for x in range(20)]
-        self.random_string = ''.join(letters)
+        letters = [random.choice(string.ascii_letters + "_") for x in range(20)]
+        self.random_string = "".join(letters)
 
     def tearDown(self) -> None:
         self.proj.close()
@@ -27,14 +27,14 @@ def test_add(self):
         lt = self.proj.network.link_types
         existing = list(lt.all_types().keys())
 
-        newlt = lt.new('G')
-        newlt.link_type = 'unique_link_type'
+        newlt = lt.new("G")
+        newlt.link_type = "unique_link_type"
         newlt.save()
 
         nowexisting = list(lt.all_types().keys())
 
         n = [x for x in nowexisting if x not in existing][0]
-        self.assertEqual('G', n, 'Failed to add link type')
+        self.assertEqual("G", n, "Failed to add link type")
 
     def test_delete(self):
         lt = self.proj.network.link_types
@@ -45,27 +45,27 @@ def test_delete(self):
 
         difference = [x for x in existing if x not in remaining]
 
-        self.assertEqual(deleted, difference[0], 'Failed to delete link type')
+        self.assertEqual(deleted, difference[0], "Failed to delete link type")
 
     def test_get_and_get_by_name(self):
         lt = self.proj.network.link_types
-        ltget = lt.get('y')
-        ltgetbn = lt.get_by_name('default')
+        ltget = lt.get("y")
+        ltgetbn = lt.get_by_name("default")
 
-        self.assertEqual(ltget.link_type_id, ltgetbn.link_type_id, 'Get methods returned different things')
-        self.assertEqual(ltget.link_type, ltgetbn.link_type, 'Get methods returned different things')
-        self.assertEqual(ltget.description, ltgetbn.description, 'Get methods returned different things')
-        self.assertEqual(ltget.lanes, ltgetbn.lanes, 'Get methods returned different things')
-        self.assertEqual(ltget.lane_capacity, ltgetbn.lane_capacity, 'Get methods returned different things')
-        self.assertEqual(ltget.link_type, 'default', 'Get methods returned different things')
+        self.assertEqual(ltget.link_type_id, ltgetbn.link_type_id, "Get methods returned different things")
+        self.assertEqual(ltget.link_type, ltgetbn.link_type, "Get methods returned different things")
+        self.assertEqual(ltget.description, ltgetbn.description, "Get methods returned different things")
+        self.assertEqual(ltget.lanes, ltgetbn.lanes, "Get methods returned different things")
+        self.assertEqual(ltget.lane_capacity, ltgetbn.lane_capacity, "Get methods returned different things")
+        self.assertEqual(ltget.link_type, "default", "Get methods returned different things")
 
     def test_all_types(self):
         lt = self.proj.network.link_types
         all_lts = set([x for x in lt.all_types().keys()])
 
         c = self.proj.conn.cursor()
-        c.execute('select link_type_id from link_types')
+        c.execute("select link_type_id from link_types")
         reallts = set([x[0] for x in c.fetchall()])
 
         diff = all_lts.symmetric_difference(reallts)
-        self.assertEqual(diff, set(), 'Getting all link_types failed')
+        self.assertEqual(diff, set(), "Getting all link_types failed")
diff --git a/tests/aequilibrae/project/test_links.py b/tests/aequilibrae/project/test_links.py
index 3e9d8d59b..f4bc67ff6 100644
--- a/tests/aequilibrae/project/test_links.py
+++ b/tests/aequilibrae/project/test_links.py
@@ -12,7 +12,7 @@
 
 class TestLinks(TestCase):
     def setUp(self) -> None:
-        os.environ['PATH'] = os.path.join(gettempdir(), 'temp_data') + ';' + os.environ['PATH']
+        os.environ["PATH"] = os.path.join(gettempdir(), "temp_data") + ";" + os.environ["PATH"]
 
         self.proj_dir = os.path.join(gettempdir(), uuid.uuid4().hex)
         copytree(siouxfalls_project, self.proj_dir)
@@ -28,7 +28,7 @@ def tearDown(self) -> None:
         try:
             rmtree(self.proj_dir)
         except Exception as e:
-            print(f'Failed to remove at {e.args}')
+            print(f"Failed to remove at {e.args}")
 
     def test_get(self):
         links = self.network.links
@@ -36,16 +36,16 @@ def test_get(self):
             _ = links.get(123456)
 
         link = links.get(1)
-        self.assertEqual(link.capacity_ab, 25900.20064, 'Did not populate link correctly')
+        self.assertEqual(link.capacity_ab, 25900.20064, "Did not populate link correctly")
 
     def test_new(self):
         links = self.network.links
         new_link = links.new()
 
-        self.curr.execute('Select max(link_id) + 1 from Links')
+        self.curr.execute("Select max(link_id) + 1 from Links")
         id = self.curr.fetchone()[0]
-        self.assertEqual(new_link.link_id, id, 'Did not populate new link ID properly')
-        self.assertEqual(new_link.geometry, None, 'Did not populate new geometry properly')
+        self.assertEqual(new_link.link_id, id, "Did not populate new link ID properly")
+        self.assertEqual(new_link.geometry, None, "Did not populate new geometry properly")
 
     def test_copy_link(self):
         links = self.network.links
@@ -71,13 +71,13 @@ def test_delete(self):
 
         _ = links.get(10)
 
-        self.curr.execute('Select count(*) from Links')
+        self.curr.execute("Select count(*) from Links")
         tot = self.curr.fetchone()[0]
         links.delete(10)
         links.delete(11)
-        self.curr.execute('Select count(*) from Links')
+        self.curr.execute("Select count(*) from Links")
         tot2 = self.curr.fetchone()[0]
-        self.assertEqual(tot, tot2 + 2, 'Did not delete the link properly')
+        self.assertEqual(tot, tot2 + 2, "Did not delete the link properly")
 
         with self.assertRaises(ValueError):
             links.delete(123456)
@@ -90,13 +90,13 @@ def test_fields(self):
         f_editor = links.fields
 
         fields = sorted(f_editor.all_fields())
-        self.curr.execute('pragma table_info(links)')
+        self.curr.execute("pragma table_info(links)")
         dt = self.curr.fetchall()
 
-        actual_fields = set([x[1].replace('_ab', '').replace('_ba', '') for x in dt if x[1] != 'ogc_fid'])
+        actual_fields = set([x[1].replace("_ab", "").replace("_ba", "") for x in dt if x[1] != "ogc_fid"])
         actual_fields = sorted(list(actual_fields))
 
-        self.assertEqual(fields, actual_fields, 'Table editor is weird for table links')
+        self.assertEqual(fields, actual_fields, "Table editor is weird for table links")
 
     def test_refresh(self):
         links = self.network.links
@@ -107,11 +107,11 @@ def test_refresh(self):
 
         link1.capacity_ba = val
         link1_again = links.get(1)
-        self.assertEqual(link1_again.capacity_ba, val, 'Did not preserve correctly')
+        self.assertEqual(link1_again.capacity_ba, val, "Did not preserve correctly")
 
         links.refresh()
         link1 = links.get(1)
-        self.assertEqual(link1.capacity_ba, original_value, 'Did not reset correctly')
+        self.assertEqual(link1.capacity_ba, original_value, "Did not reset correctly")
 
     def test_copy(self):
         nodes = self.network.nodes
diff --git a/tests/aequilibrae/project/test_mode.py b/tests/aequilibrae/project/test_mode.py
index 09c8d63fa..e67483d02 100644
--- a/tests/aequilibrae/project/test_mode.py
+++ b/tests/aequilibrae/project/test_mode.py
@@ -12,21 +12,21 @@
 
 class TestMode(TestCase):
     def setUp(self) -> None:
-        os.environ['PATH'] = os.path.join(tempfile.gettempdir(), 'temp_data') + ';' + os.environ['PATH']
+        os.environ["PATH"] = os.path.join(tempfile.gettempdir(), "temp_data") + ";" + os.environ["PATH"]
         self.temp_proj_folder = os.path.join(tempfile.gettempdir(), uuid.uuid4().hex)
         copytree(no_triggers_project, self.temp_proj_folder)
         self.proj = Project()
         self.proj.open(self.temp_proj_folder)
         self.curr = self.proj.conn.cursor()
 
-        letters = [random.choice(string.ascii_letters + '_') for x in range(20)]
-        self.random_string = ''.join(letters)
+        letters = [random.choice(string.ascii_letters + "_") for x in range(20)]
+        self.random_string = "".join(letters)
 
     def tearDown(self) -> None:
         self.proj.close()
 
     def test_build(self):
-        for val in ['1', 'ab', '', None]:
+        for val in ["1", "ab", "", None]:
             with self.assertRaises(ValueError):
                 m = Mode(val)
 
@@ -36,9 +36,9 @@ def test_build(self):
             del m
 
     def test_changing_mode_id(self):
-        m = Mode('c')
+        m = Mode("c")
         with self.assertRaises(ValueError):
-            m.mode_id = 'test my description'
+            m.mode_id = "test my description"
 
     def test_save(self):
         self.curr.execute("select mode_id from 'modes'")
@@ -56,12 +56,12 @@ def test_save(self):
         self.assertEqual(mname, self.random_string, "Didn't save the mode name correctly")
 
     def test_empty(self):
-        a = Mode('k')
-        a.mode_name = 'just a_test'
+        a = Mode("k")
+        a.mode_name = "just a_test"
         with self.assertRaises(ValueError):
             a.save()
 
-        a = Mode('l')
-        a.mode_name = 'just_a_test_test_with_l'
+        a = Mode("l")
+        a.mode_name = "just_a_test_test_with_l"
         with self.assertRaises(ValueError):
             a.save()
diff --git a/tests/aequilibrae/project/test_modes.py b/tests/aequilibrae/project/test_modes.py
index f760d7aa8..9db0cbade 100644
--- a/tests/aequilibrae/project/test_modes.py
+++ b/tests/aequilibrae/project/test_modes.py
@@ -13,7 +13,7 @@
 
 class TestModes(TestCase):
     def setUp(self) -> None:
-        os.environ['PATH'] = os.path.join(tempfile.gettempdir(), 'temp_data') + ';' + os.environ['PATH']
+        os.environ["PATH"] = os.path.join(tempfile.gettempdir(), "temp_data") + ";" + os.environ["PATH"]
         self.temp_proj_folder = os.path.join(tempfile.gettempdir(), uuid.uuid4().hex)
         copytree(siouxfalls_project, self.temp_proj_folder)
         self.proj = Project()
@@ -24,32 +24,32 @@ def tearDown(self) -> None:
         self.proj.close()
 
     def test_add(self):
-        new_mode = Mode('F')
-        name = [random.choice(string.ascii_letters + '_') for x in range(random.randint(1, 20))]
-        name = ''.join(name)
+        new_mode = Mode("F")
+        name = [random.choice(string.ascii_letters + "_") for x in range(random.randint(1, 20))]
+        name = "".join(name)
         new_mode.mode_name = name
         self.proj.network.modes.add(new_mode)
 
         self.curr.execute('select mode_name from modes where mode_id="F"')
-        self.assertEqual(self.curr.fetchone()[0], name, 'Could not save the mode properly to the database')
+        self.assertEqual(self.curr.fetchone()[0], name, "Could not save the mode properly to the database")
 
     def test_drop(self):
-        self.proj.network.modes.delete('b')
+        self.proj.network.modes.delete("b")
 
         with self.assertRaises(IntegrityError):
-            self.proj.network.modes.delete('c')
+            self.proj.network.modes.delete("c")
 
     def test_get(self):
-        c = self.proj.network.modes.get('c')
-        self.assertEqual('All motorized vehicles', c.description)
+        c = self.proj.network.modes.get("c")
+        self.assertEqual("All motorized vehicles", c.description)
         del c
 
         with self.assertRaises(ValueError):
-            _ = self.proj.network.modes.get('f')
+            _ = self.proj.network.modes.get("f")
 
     def test_new(self):
         modes = self.proj.network.modes
-        self.assertIsInstance(modes.new('h'), Mode, 'Returned wrong type')
+        self.assertIsInstance(modes.new("h"), Mode, "Returned wrong type")
 
         m = list(modes.all_modes().keys())[0]
         with self.assertRaises(ValueError):
@@ -58,4 +58,4 @@ def test_new(self):
     def test_fields(self):
         fields = self.proj.network.modes.fields
         fields.all_fields()
-        self.assertEqual(fields._table, 'modes', 'Returned wrong table handler')
+        self.assertEqual(fields._table, "modes", "Returned wrong table handler")
diff --git a/tests/aequilibrae/project/test_modes_table_triggers.py b/tests/aequilibrae/project/test_modes_table_triggers.py
index 917b0dd9d..1a6875602 100644
--- a/tests/aequilibrae/project/test_modes_table_triggers.py
+++ b/tests/aequilibrae/project/test_modes_table_triggers.py
@@ -13,7 +13,7 @@
 
 class TestProject(TestCase):
     def setUp(self) -> None:
-        os.environ['PATH'] = os.path.join(tempfile.gettempdir(), 'temp_data') + ';' + os.environ['PATH']
+        os.environ["PATH"] = os.path.join(tempfile.gettempdir(), "temp_data") + ";" + os.environ["PATH"]
         self.temp_proj_folder = os.path.join(tempfile.gettempdir(), uuid.uuid4().hex)
         copytree(no_triggers_project, self.temp_proj_folder)
         self.proj = Project()
@@ -21,9 +21,9 @@ def setUp(self) -> None:
         self.curr = self.proj.conn.cursor()
 
         # Modes to add
-        sql = 'INSERT INTO modes (mode_name, mode_id) VALUES (?, ?);'
-        for mid in ['p', 'l', 'g', 'x', 'y', 'd', 'k', 'a', 'r', 'n', 'm']:
-            self.curr.execute(sql, [f'mode_{mid}', mid])
+        sql = "INSERT INTO modes (mode_name, mode_id) VALUES (?, ?);"
+        for mid in ["p", "l", "g", "x", "y", "d", "k", "a", "r", "n", "m"]:
+            self.curr.execute(sql, [f"mode_{mid}", mid])
 
         self.proj.conn.commit()
 
@@ -33,9 +33,9 @@ def setUp(self) -> None:
             curr.execute("SELECT rtreecheck('idx_nodes_geometry');")
         except Exception as e:
             self.rtree = False
-            warn(f'RTREE not available --> {e.args}')
+            warn(f"RTREE not available --> {e.args}")
 
-        root = os.path.dirname(os.path.realpath(__file__)).replace('tests', '')
+        root = os.path.dirname(os.path.realpath(__file__)).replace("tests", "")
         qry_file = os.path.join(root, "database_specification/triggers/modes_table_triggers.sql")
         with open(qry_file, "r") as sql_file:
             self.queries = sql_file.read()
@@ -48,20 +48,20 @@ def __get_query(self, qry: str) -> str:
         for query in self.queries:
             if qry in query:
                 return query
-        raise FileNotFoundError('QUERY DOES NOT EXIST')
+        raise FileNotFoundError("QUERY DOES NOT EXIST")
 
     def test_all_tests_considered(self):
         tests_added = list(self.__dir__())
-        tests_added = [x[5:] for x in tests_added if x[:5] == 'test_']
+        tests_added = [x[5:] for x in tests_added if x[:5] == "test_"]
 
         for trigger in self.queries:
-            if 'TRIGGER' in trigger.upper():
+            if "TRIGGER" in trigger.upper():
                 found = [x for x in tests_added if x in trigger]
                 if not found:
-                    self.fail(f'Trigger not tested. {trigger}')
+                    self.fail(f"Trigger not tested. {trigger}")
 
     def test_mode_single_letter_update(self):
-        cmd = self.__get_query('mode_single_letter_update')
+        cmd = self.__get_query("mode_single_letter_update")
 
         sql = "UPDATE 'modes' SET mode_id= 'ttt' where mode_id='b'"
         self.curr.execute(sql)
@@ -73,18 +73,18 @@ def test_mode_single_letter_update(self):
             self.curr.execute(sql)
 
     def test_mode_single_letter_insert(self):
-        cmd = self.__get_query('mode_single_letter_insert')
+        cmd = self.__get_query("mode_single_letter_insert")
 
         sql = "INSERT INTO 'modes' (mode_name, mode_id) VALUES(?, ?)"
-        self.curr.execute(sql, ['testasdasd', 'pp'])
+        self.curr.execute(sql, ["testasdasd", "pp"])
 
         self.curr.execute(cmd)
 
         with self.assertRaises(sqlite3.IntegrityError):
-            self.curr.execute(sql, ['test1b', 'mm'])
+            self.curr.execute(sql, ["test1b", "mm"])
 
     def test_mode_keep_if_in_use_updating(self):
-        cmd = self.__get_query('mode_keep_if_in_use_updating')
+        cmd = self.__get_query("mode_keep_if_in_use_updating")
 
         sql = "UPDATE 'modes' SET mode_id= 'h' where mode_id='g'"
         self.curr.execute(sql)
@@ -96,7 +96,7 @@ def test_mode_keep_if_in_use_updating(self):
             self.curr.execute(sql)
 
     def test_mode_keep_if_in_use_deleting(self):
-        cmd = self.__get_query('mode_keep_if_in_use_deleting')
+        cmd = self.__get_query("mode_keep_if_in_use_deleting")
 
         sql = "DELETE FROM 'modes' where mode_id='p'"
         self.curr.execute(sql)
@@ -108,7 +108,7 @@ def test_mode_keep_if_in_use_deleting(self):
             self.curr.execute(sql)
 
     def test_modes_on_links_update(self):
-        cmd = self.__get_query('modes_on_links_update')
+        cmd = self.__get_query("modes_on_links_update")
 
         sql = "UPDATE 'links' SET modes= 'qwerty' where link_id=55"
         self.curr.execute(sql)
@@ -120,7 +120,7 @@ def test_modes_on_links_update(self):
             self.curr.execute(sql)
 
     def test_modes_length_on_links_update(self):
-        cmd = self.__get_query('modes_length_on_links_update')
+        cmd = self.__get_query("modes_length_on_links_update")
 
         sql = "UPDATE 'links' SET modes= '' where modes='wb'"
         self.curr.execute(sql)
@@ -132,7 +132,7 @@ def test_modes_length_on_links_update(self):
             self.curr.execute(sql)
 
     def test_modes_on_nodes_table_update_a_node(self):
-        cmd = self.__get_query('modes_on_nodes_table_update_a_node')
+        cmd = self.__get_query("modes_on_nodes_table_update_a_node")
 
         sql = "UPDATE 'links' SET a_node= 1 where a_node=3"
         self.curr.execute(sql)
@@ -140,13 +140,13 @@ def test_modes_on_nodes_table_update_a_node(self):
         sql = "SELECT modes from nodes where node_id=1"
         self.curr.execute(sql)
         i = self.curr.fetchone()[0]
-        self.assertEqual(i, 'ct')
+        self.assertEqual(i, "ct")
 
         self.curr.execute(cmd)
 
-        k = ''
+        k = ""
         for n in [2, 5]:
-            for f in ['a_node', 'b_node']:
+            for f in ["a_node", "b_node"]:
                 self.curr.execute(f"SELECT modes from links where {f}={n}")
                 k += self.curr.fetchone()[0]
 
@@ -161,14 +161,14 @@ def test_modes_on_nodes_table_update_a_node(self):
         self.assertEqual(i, existing)
 
     def test_modes_on_nodes_table_update_b_node(self):
-        cmd = self.__get_query('modes_on_nodes_table_update_b_node')
+        cmd = self.__get_query("modes_on_nodes_table_update_b_node")
         sql = "UPDATE 'links' SET b_node= 1 where b_node=3"
         self.curr.execute(sql)
 
         sql = "SELECT modes from nodes where node_id=1"
         self.curr.execute(sql)
         i = self.curr.fetchone()[0]
-        self.assertEqual(i, 'ct')
+        self.assertEqual(i, "ct")
 
         self.curr.execute(cmd)
 
@@ -178,17 +178,17 @@ def test_modes_on_nodes_table_update_b_node(self):
         sql = "SELECT modes from nodes where node_id=2"
         self.curr.execute(sql)
         i = self.curr.fetchone()[0]
-        self.assertEqual(i, 'ctw')
+        self.assertEqual(i, "ctw")
 
     def test_modes_on_nodes_table_update_links_modes(self):
-        cmd = self.__get_query('modes_on_nodes_table_update_links_modes')
+        cmd = self.__get_query("modes_on_nodes_table_update_links_modes")
         sql = "UPDATE 'links' SET modes= 'x' where a_node=24"
         self.curr.execute(sql)
 
         sql = "SELECT modes from nodes where node_id=24"
         self.curr.execute(sql)
         i = self.curr.fetchone()[0]
-        self.assertEqual(i, 'c')
+        self.assertEqual(i, "c")
 
         self.curr.execute(cmd)
 
@@ -198,8 +198,8 @@ def test_modes_on_nodes_table_update_links_modes(self):
         sql = "SELECT modes from nodes where node_id=24"
         self.curr.execute(sql)
         i = self.curr.fetchone()[0]
-        self.assertIn('c', i)
-        self.assertIn('y', i)
+        self.assertIn("c", i)
+        self.assertIn("y", i)
 
         sql = "UPDATE 'links' SET 'modes'= 'r' where b_node=24"
         self.curr.execute(sql)
@@ -207,83 +207,83 @@ def test_modes_on_nodes_table_update_links_modes(self):
         sql = "SELECT modes from nodes where node_id=24"
         self.curr.execute(sql)
         i = self.curr.fetchone()[0]
-        self.assertIn('r', i)
-        self.assertIn('y', i)
+        self.assertIn("r", i)
+        self.assertIn("y", i)
 
     def test_modes_on_links_insert(self):
-        cmd = self.__get_query('modes_on_links_insert')
+        cmd = self.__get_query("modes_on_links_insert")
         if self.rtree:
-            self.curr.execute('pragma table_info(links)')
+            self.curr.execute("pragma table_info(links)")
             f = self.curr.fetchall()
             fields = {x[1]: x[0] for x in f}
 
-            sql = 'select * from links where link_id=10'
+            sql = "select * from links where link_id=10"
             self.curr.execute(sql)
             a = [x for x in self.curr.fetchone()]
-            a[fields['modes']] = 'as12'
-            a[fields['link_id']] = 1234
-            a[fields['a_node']] = 999
-            a[fields['b_node']] = 888
+            a[fields["modes"]] = "as12"
+            a[fields["link_id"]] = 1234
+            a[fields["a_node"]] = 999
+            a[fields["b_node"]] = 888
             a[0] = 1234
 
-            idx = ','.join(['?'] * len(a))
-            self.curr.execute(f'insert into links values ({idx})', a)
-            self.curr.execute('delete from links where link_id=1234')
+            idx = ",".join(["?"] * len(a))
+            self.curr.execute(f"insert into links values ({idx})", a)
+            self.curr.execute("delete from links where link_id=1234")
 
             self.curr.execute(cmd)
 
             with self.assertRaises(sqlite3.IntegrityError):
-                self.curr.execute(f'insert into links values ({idx})', a)
+                self.curr.execute(f"insert into links values ({idx})", a)
 
     def test_modes_length_on_links_insert(self):
-        cmd = self.__get_query('modes_length_on_links_insert')
+        cmd = self.__get_query("modes_length_on_links_insert")
         if self.rtree:
-            self.curr.execute('pragma table_info(links)')
+            self.curr.execute("pragma table_info(links)")
             f = self.curr.fetchall()
             fields = {x[1]: x[0] for x in f}
 
-            sql = 'select * from links where link_id=70'
+            sql = "select * from links where link_id=70"
             self.curr.execute(sql)
             a = [x for x in self.curr.fetchone()]
-            a[fields['modes']] = ''
-            a[fields['link_id']] = 4321
-            a[fields['a_node']] = 888
-            a[fields['b_node']] = 999
+            a[fields["modes"]] = ""
+            a[fields["link_id"]] = 4321
+            a[fields["a_node"]] = 888
+            a[fields["b_node"]] = 999
             a[0] = 4321
 
-            idx = ','.join(['?'] * len(a))
-            self.curr.execute(f'insert into links values ({idx})', a)
-            self.curr.execute('delete from links where link_id=4321')
+            idx = ",".join(["?"] * len(a))
+            self.curr.execute(f"insert into links values ({idx})", a)
+            self.curr.execute("delete from links where link_id=4321")
 
             self.curr.execute(cmd)
 
             with self.assertRaises(sqlite3.IntegrityError):
-                self.curr.execute(f'insert into links values ({idx})', a)
+                self.curr.execute(f"insert into links values ({idx})", a)
 
     def test_keep_at_least_one(self):
-        cmd = self.__get_query('mode_keep_at_least_one')
+        cmd = self.__get_query("mode_keep_at_least_one")
 
-        self.curr.execute('Delete from modes;')
-        self.curr.execute('select count(*) from modes;')
-        self.assertEqual(self.curr.fetchone()[0], 0, 'We were not able to clear the m odes table as expected')
+        self.curr.execute("Delete from modes;")
+        self.curr.execute("select count(*) from modes;")
+        self.assertEqual(self.curr.fetchone()[0], 0, "We were not able to clear the m odes table as expected")
 
         self.curr.execute('insert into modes(mode_id, mode_name) VALUES("k", "some_name")')
         self.curr.execute(cmd)
         with self.assertRaises(sqlite3.IntegrityError):
-            self.curr.execute('Delete from modes;')
+            self.curr.execute("Delete from modes;")
 
     def test_modes_on_nodes_table_update_nodes_modes(self):
-        cmd = self.__get_query('modes_on_nodes_table_update_nodes_modes')
-        self.curr.execute('select node_id, modes from nodes where length(modes)>0')
+        cmd = self.__get_query("modes_on_nodes_table_update_nodes_modes")
+        self.curr.execute("select node_id, modes from nodes where length(modes)>0")
         dt = self.curr.fetchall()
 
         x = choice(dt)
 
         self.curr.execute(f'update nodes set modes="abcdefgq" where node_id={x[0]}')
-        self.curr.execute(f'select node_id, modes from nodes where node_id={x[0]}')
+        self.curr.execute(f"select node_id, modes from nodes where node_id={x[0]}")
         z = self.curr.fetchone()
         if z == x:
-            self.fail('Modes field on nodes layer is being preserved by unknown mechanism')
+            self.fail("Modes field on nodes layer is being preserved by unknown mechanism")
 
         self.curr.execute(cmd)
 
@@ -294,12 +294,12 @@ def test_modes_on_nodes_table_update_nodes_modes(self):
         # We try to force the change to make sure it was correctly filled to begin with
         self.curr.execute(f'update nodes set modes="hgfedcba" where node_id={y[0]}')
 
-        self.curr.execute(f'select node_id, modes from nodes where node_id={y[0]}')
+        self.curr.execute(f"select node_id, modes from nodes where node_id={y[0]}")
         k = self.curr.fetchone()
 
         self.curr.execute(f'update nodes set modes="abcdefgq" where node_id={y[0]}')
 
-        self.curr.execute(f'select node_id, modes from nodes where node_id={y[0]}')
+        self.curr.execute(f"select node_id, modes from nodes where node_id={y[0]}")
         z = self.curr.fetchone()
 
-        self.assertEqual(z, k, 'Failed to preserve the information on modes for the nodes')
+        self.assertEqual(z, k, "Failed to preserve the information on modes for the nodes")
diff --git a/tests/aequilibrae/project/test_network.py b/tests/aequilibrae/project/test_network.py
index 6fd3a8eba..d42fd8eef 100644
--- a/tests/aequilibrae/project/test_network.py
+++ b/tests/aequilibrae/project/test_network.py
@@ -17,7 +17,7 @@
 
 class TestNetwork(TestCase):
     def setUp(self) -> None:
-        os.environ['PATH'] = os.path.join(gettempdir(), 'temp_data') + ';' + os.environ['PATH']
+        os.environ["PATH"] = os.path.join(gettempdir(), "temp_data") + ";" + os.environ["PATH"]
         self.proj_path = os.path.join(gettempdir(), uuid.uuid4().hex)
         copytree(siouxfalls_project, self.proj_path)
         self.siouxfalls = Project()
@@ -29,7 +29,7 @@ def tearDown(self) -> None:
 
     def test_create_from_osm(self):
         thresh = 0.05
-        if os.environ.get('GITHUB_WORKFLOW', 'ERROR') == 'Code coverage':
+        if os.environ.get("GITHUB_WORKFLOW", "ERROR") == "Code coverage":
             thresh = 1.01
 
         if random() < thresh:
@@ -47,7 +47,7 @@ def test_create_from_osm(self):
             osmids = curr.fetchone()[0]
 
             if osmids == 0:
-                warn('COULD NOT RETRIEVE DATA FROM OSM')
+                warn("COULD NOT RETRIEVE DATA FROM OSM")
                 return
 
             if osmids >= lks:
@@ -61,11 +61,11 @@ def test_create_from_osm(self):
             self.project.close()
             self.siouxfalls.open(self.proj_path)
         else:
-            print('Skipped check to not load OSM servers')
+            print("Skipped check to not load OSM servers")
 
     def test_count_centroids(self):
         items = self.siouxfalls.network.count_centroids()
-        self.assertEqual(24, items, 'Wrong number of centroids found')
+        self.assertEqual(24, items, "Wrong number of centroids found")
 
         nodes = self.siouxfalls.network.nodes
         node = nodes.get(1)
@@ -73,12 +73,12 @@ def test_count_centroids(self):
         node.save()
 
         items = self.siouxfalls.network.count_centroids()
-        self.assertEqual(23, items, 'Wrong number of centroids found')
+        self.assertEqual(23, items, "Wrong number of centroids found")
 
     def test_count_links(self):
         items = self.siouxfalls.network.count_links()
-        self.assertEqual(76, items, 'Wrong number of links found')
+        self.assertEqual(76, items, "Wrong number of links found")
 
     def test_count_nodes(self):
         items = self.siouxfalls.network.count_nodes()
-        self.assertEqual(24, items, 'Wrong number of nodes found')
+        self.assertEqual(24, items, "Wrong number of nodes found")
diff --git a/tests/aequilibrae/project/test_network_triggers.py b/tests/aequilibrae/project/test_network_triggers.py
index bf06f4c76..a6563798b 100644
--- a/tests/aequilibrae/project/test_network_triggers.py
+++ b/tests/aequilibrae/project/test_network_triggers.py
@@ -12,8 +12,8 @@
 
 class TestNetworkTriggers(TestCase):
     def setUp(self) -> None:
-        os.environ['PATH'] = os.path.join(gettempdir(), 'temp_data') + ';' + os.environ['PATH']
-        self.proj_path = os.path.join(gettempdir(), f'aeq_{uuid.uuid4().hex}')
+        os.environ["PATH"] = os.path.join(gettempdir(), "temp_data") + ";" + os.environ["PATH"]
+        self.proj_path = os.path.join(gettempdir(), f"aeq_{uuid.uuid4().hex}")
         copytree(siouxfalls_project, self.proj_path)
         self.siouxfalls = Project()
         self.siouxfalls.open(self.proj_path)
@@ -25,7 +25,7 @@ def tearDown(self) -> None:
 
     def test_delete_links_delete_nodes(self):
         items = self.siouxfalls.network.count_nodes()
-        self.assertEqual(24, items, 'Wrong number of nodes found')
+        self.assertEqual(24, items, "Wrong number of nodes found")
         links = self.siouxfalls.network.links
         nodes = self.siouxfalls.network.nodes
 
@@ -39,15 +39,15 @@ def test_delete_links_delete_nodes(self):
             link.delete()
         # Since node 1 is no longer a centroid, we should have only 23 nodes in the network
         items = self.siouxfalls.network.count_nodes()
-        self.assertEqual(23, items, 'Wrong number of nodes found')
+        self.assertEqual(23, items, "Wrong number of nodes found")
 
     def test_add_regular_link(self):
         # Add a regular link to see if it fails when creating it
         # It happened at some point
         curr = self.siouxfalls.conn.cursor()
-        data = [123456, 'c', 'default', LineString([Point(0, 0), Point(1, 1)]).wkb]
+        data = [123456, "c", "default", LineString([Point(0, 0), Point(1, 1)]).wkb]
 
-        sql = 'insert into links (link_id, modes, link_type, geometry) Values(?,?,?,GeomFromWKB(?, 4326));'
+        sql = "insert into links (link_id, modes, link_type, geometry) Values(?,?,?,GeomFromWKB(?, 4326));"
         curr.execute(sql, data)
         self.siouxfalls.conn.commit()
 
@@ -60,11 +60,11 @@ def test_add_regular_node_change_centroid_id(self):
 
         data = [987654, 1, Point(0, 0).wkb]
 
-        sql = 'insert into nodes (node_id, is_centroid, geometry) Values(?,?,GeomFromWKB(?, 4326));'
+        sql = "insert into nodes (node_id, is_centroid, geometry) Values(?,?,GeomFromWKB(?, 4326));"
         curr.execute(sql, data)
         self.siouxfalls.conn.commit()
-        self.assertEqual(nodes + 1, network.count_nodes(), 'Failed to insert node')
+        self.assertEqual(nodes + 1, network.count_nodes(), "Failed to insert node")
 
-        curr.execute('Update nodes set is_centroid=0 where node_id=?', data[:1])
+        curr.execute("Update nodes set is_centroid=0 where node_id=?", data[:1])
         self.siouxfalls.conn.commit()
-        self.assertEqual(nodes, network.count_nodes(), 'Failed to delete node when changing centroid flag')
+        self.assertEqual(nodes, network.count_nodes(), "Failed to delete node when changing centroid flag")
diff --git a/tests/aequilibrae/project/test_nodes.py b/tests/aequilibrae/project/test_nodes.py
index 758ab15a7..bbb80127c 100644
--- a/tests/aequilibrae/project/test_nodes.py
+++ b/tests/aequilibrae/project/test_nodes.py
@@ -17,7 +17,7 @@
 
 class TestNodes(TestCase):
     def setUp(self) -> None:
-        os.environ['PATH'] = os.path.join(gettempdir(), 'temp_data') + ';' + os.environ['PATH']
+        os.environ["PATH"] = os.path.join(gettempdir(), "temp_data") + ";" + os.environ["PATH"]
 
         self.proj_dir = os.path.join(gettempdir(), uuid.uuid4().hex)
         copytree(siouxfalls_project, self.proj_dir)
@@ -33,14 +33,14 @@ def tearDown(self) -> None:
         try:
             rmtree(self.proj_dir)
         except Exception as e:
-            print(f'Failed to remove at {e.args}')
+            print(f"Failed to remove at {e.args}")
 
     def test_get(self):
         nodes = self.network.nodes
         nd = randint(1, 24)
         node = nodes.get(nd)
 
-        self.assertEqual(node.node_id, nd, 'get node returned wrong object')
+        self.assertEqual(node.node_id, nd, "get node returned wrong object")
 
         # Make sure that if we renumber itg we would not get it again
         node.renumber(200)
@@ -64,26 +64,26 @@ def test_save(self):
         nodes.save()
         for nd, coords in zip(chosen, coords):
             x, y = coords
-            self.curr.execute('Select is_centroid, asBinary(geometry) from nodes where node_id=?;', [nd])
+            self.curr.execute("Select is_centroid, asBinary(geometry) from nodes where node_id=?;", [nd])
             flag, wkb = self.curr.fetchone()
-            self.assertEqual(flag, 0, 'Saving of is_centroid failed')
+            self.assertEqual(flag, 0, "Saving of is_centroid failed")
 
             geo = shapely.wkb.loads(wkb)
-            self.assertEqual(geo.x, x, 'Geometry X saved wrong')
-            self.assertEqual(geo.y, y, 'Geometry Y saved wrong')
+            self.assertEqual(geo.x, x, "Geometry X saved wrong")
+            self.assertEqual(geo.y, y, "Geometry Y saved wrong")
 
     def test_fields(self):
         nodes = self.network.nodes
         f_editor = nodes.fields
 
         fields = sorted(f_editor.all_fields())
-        self.curr.execute('pragma table_info(nodes)')
+        self.curr.execute("pragma table_info(nodes)")
         dt = self.curr.fetchall()
 
-        actual_fields = set([x[1] for x in dt if x[1] != 'ogc_fid'])
+        actual_fields = set([x[1] for x in dt if x[1] != "ogc_fid"])
         actual_fields = sorted(list(actual_fields))
 
-        self.assertEqual(fields, actual_fields, 'Table editor is weird for table nodes')
+        self.assertEqual(fields, actual_fields, "Table editor is weird for table nodes")
 
     def test_copy(self):
         nodes = self.network.nodes
@@ -101,9 +101,9 @@ def test_new_centroid(self):
         tot_prev_centr = self.network.count_centroids()
         tot_prev_nodes = self.network.count_nodes()
         node = nodes.new_centroid(100)
-        self.assertEqual(1, node.is_centroid, 'Creating new centroid returned wrong is_centroid value')
+        self.assertEqual(1, node.is_centroid, "Creating new centroid returned wrong is_centroid value")
         node.geometry = Point(1, 1)
         node.save()
 
-        self.assertEqual(tot_prev_centr + 1, self.network.count_centroids(), 'Failed to add centroids')
-        self.assertEqual(tot_prev_nodes + 1, self.network.count_nodes(), 'Failed to add centroids')
+        self.assertEqual(tot_prev_centr + 1, self.network.count_centroids(), "Failed to add centroids")
+        self.assertEqual(tot_prev_nodes + 1, self.network.count_nodes(), "Failed to add centroids")
diff --git a/tests/aequilibrae/project/test_osm_downloader.py b/tests/aequilibrae/project/test_osm_downloader.py
index b8ccd0c6b..2490be669 100644
--- a/tests/aequilibrae/project/test_osm_downloader.py
+++ b/tests/aequilibrae/project/test_osm_downloader.py
@@ -11,11 +11,11 @@
 
 class TestOSMDownloader(TestCase):
     def setUp(self) -> None:
-        os.environ['PATH'] = os.path.join(gettempdir(), 'temp_data') + ';' + os.environ['PATH']
+        os.environ["PATH"] = os.path.join(gettempdir(), "temp_data") + ";" + os.environ["PATH"]
 
     def test_do_work(self):
         thresh = 0.05
-        if os.environ.get('GITHUB_WORKFLOW', 'ERROR') == 'Code coverage':
+        if os.environ.get("GITHUB_WORKFLOW", "ERROR") == "Code coverage":
             thresh = 1.01
 
         if random() < thresh:
@@ -24,11 +24,11 @@ def test_do_work(self):
             if self.o.json:
                 self.fail("It found links in the middle of the ocean")
         else:
-            print('Skipped check to not load OSM servers')
+            print("Skipped check to not load OSM servers")
 
     def test_do_work2(self):
         thresh = 0.05
-        if os.environ.get('GITHUB_WORKFLOW', 'ERROR') == 'Code coverage':
+        if os.environ.get("GITHUB_WORKFLOW", "ERROR") == "Code coverage":
             thresh = 1.01
 
         if random() < thresh:
@@ -43,4 +43,4 @@ def test_do_work2(self):
             if len(self.o.json[0]["elements"]) < 10:
                 self.fail("It found too few elements in the middle of the Grand Canyon")
         else:
-            print('Skipped check to not load OSM servers')
+            print("Skipped check to not load OSM servers")
diff --git a/tests/aequilibrae/project/test_place_getter.py b/tests/aequilibrae/project/test_place_getter.py
index d160b0167..4b1515f7b 100644
--- a/tests/aequilibrae/project/test_place_getter.py
+++ b/tests/aequilibrae/project/test_place_getter.py
@@ -7,7 +7,7 @@
 class Test(TestCase):
     def test_placegetter(self):
         thresh = 0.05
-        if os.environ.get('GITHUB_WORKFLOW', 'ERROR') == 'Code coverage':
+        if os.environ.get("GITHUB_WORKFLOW", "ERROR") == "Code coverage":
             thresh = 1.01
 
         if random() < thresh:
@@ -20,4 +20,4 @@ def test_placegetter(self):
             if place is not None:
                 self.fail("Returned a bounding box for a place that does not exist")
         else:
-            print('Skipped check to not load OSM servers')
+            print("Skipped check to not load OSM servers")
diff --git a/tests/aequilibrae/project/test_project.py b/tests/aequilibrae/project/test_project.py
index 710366f05..2b5e22e5f 100644
--- a/tests/aequilibrae/project/test_project.py
+++ b/tests/aequilibrae/project/test_project.py
@@ -39,7 +39,7 @@ def test_creation(self):
         fields = curr.fetchall()
         fields = [x[1] for x in fields]
 
-        if 'distance' not in fields:
+        if "distance" not in fields:
             self.fail("Table LINKS was not created correctly")
 
         curr = self.proj.conn.cursor()
@@ -47,8 +47,8 @@ def test_creation(self):
         nfields = curr.fetchall()
         nfields = [x[1] for x in nfields]
 
-        if 'is_centroid' not in nfields:
-            self.fail('Table NODES was not created correctly')
+        if "is_centroid" not in nfields:
+            self.fail("Table NODES was not created correctly")
 
     def test_close(self):
 
diff --git a/tests/aequilibrae/project/test_zone.py b/tests/aequilibrae/project/test_zone.py
index 358761952..a87b035cf 100644
--- a/tests/aequilibrae/project/test_zone.py
+++ b/tests/aequilibrae/project/test_zone.py
@@ -15,7 +15,6 @@
 
 
 class TestZone(TestCase):
-
     def setUp(self) -> None:
         self.temp_proj_folder = join(gettempdir(), uuid4().hex)
         copytree(siouxfalls_project, self.temp_proj_folder)
@@ -27,7 +26,7 @@ def tearDown(self) -> None:
         try:
             rmtree(self.temp_proj_folder)
         except Exception as e:
-            warn(f'Error: {e.args}')
+            warn(f"Error: {e.args}")
 
     def test_delete(self):
         zones = self.proj.zoning
@@ -45,14 +44,14 @@ def test_save(self):
         zn.save()
 
         curr = self.proj.conn.cursor()
-        curr.execute('Select area from Zones where zone_id=2')
+        curr.execute("Select area from Zones where zone_id=2")
         self.assertEqual(curr.fetchone()[0], area, "Zone didn't save area properly")
 
         geo = Point(0, 0).buffer(1)
         zn.geometry = geo
         zn.save()
         curr = self.proj.conn.cursor()
-        curr.execute('Select asBinary(geometry) from Zones where zone_id=2')
+        curr.execute("Select asBinary(geometry) from Zones where zone_id=2")
         wkb = curr.fetchone()[0]
         self.assertEqual(shapely.wkb.loads(wkb), MultiPolygon([geo]), "Zone didn't save geometry properly")
 
@@ -61,14 +60,14 @@ def test_save(self):
         zn2.geometry = geo
         zn2.save()
         curr = self.proj.conn.cursor()
-        curr.execute('Select asBinary(geometry) from Zones where zone_id=1')
+        curr.execute("Select asBinary(geometry) from Zones where zone_id=1")
         wkb = curr.fetchone()[0]
         self.assertEqual(shapely.wkb.loads(wkb), geo, "Zone didn't save geometry properly")
 
     def __change_project(self):
         self.proj.close()
         self.proj = Project()
-        self.proj = create_example(join(gettempdir(), uuid4().hex), 'nauru')
+        self.proj = create_example(join(gettempdir(), uuid4().hex), "nauru")
         zones = 5
         network = self.proj.network
         nodes = network.nodes
@@ -82,8 +81,10 @@ def __change_project(self):
 
         curr = self.proj.conn.cursor()
         b = extent.bounds
-        curr.execute('select st_asbinary(HexagonalGrid(GeomFromWKB(?), ?, 0, GeomFromWKB(?)))',
-                     [extent.wkb, zone_side, Point(b[2], b[3]).wkb])
+        curr.execute(
+            "select st_asbinary(HexagonalGrid(GeomFromWKB(?), ?, 0, GeomFromWKB(?)))",
+            [extent.wkb, zone_side, Point(b[2], b[3]).wkb],
+        )
         grid = curr.fetchone()[0]
         grid = shapely.wkb.loads(grid)
 
@@ -143,19 +144,19 @@ def test_connect_mode(self):
         zone1 = zones.get(1)
         zone1.add_centroid(None)
 
-        zone1.connect_mode('c')
+        zone1.connect_mode("c")
 
-        curr.execute('Select count(*) from links where a_node=?', [1])
-        self.assertIsNot(0, curr.fetchone()[0], 'failed to add connectors')
+        curr.execute("Select count(*) from links where a_node=?", [1])
+        self.assertIsNot(0, curr.fetchone()[0], "failed to add connectors")
 
-        zone1.connect_mode('t')
-        curr.execute('''Select count(*) from links where a_node=? and instr(modes,'t')>0''', [1])
-        self.assertIsNot(0, curr.fetchone()[0], 'failed to add connectors for mode t')
+        zone1.connect_mode("t")
+        curr.execute("""Select count(*) from links where a_node=? and instr(modes,'t')>0""", [1])
+        self.assertIsNot(0, curr.fetchone()[0], "failed to add connectors for mode t")
 
         # Cannot connect a centroid that does not exist
         with self.assertRaises(ValueError):
             zone2 = zones.get(2)
-            zone2.connect_mode('c')
+            zone2.connect_mode("c")
 
     def test_disconnect_mode(self):
         self.__change_project()
@@ -164,16 +165,16 @@ def test_disconnect_mode(self):
         zone1 = zones.get(1)
         zone1.add_centroid(None)
 
-        zone1.connect_mode('c')
-        zone1.connect_mode('w')
-        curr.execute('''select COUNT(*) from links where a_node=1''')
+        zone1.connect_mode("c")
+        zone1.connect_mode("w")
+        curr.execute("""select COUNT(*) from links where a_node=1""")
         tot = curr.fetchone()[0]
-        curr.execute('''Update links set modes = modes || 'w' where instr(modes,'w')=0''')
+        curr.execute("""Update links set modes = modes || 'w' where instr(modes,'w')=0""")
         self.proj.conn.commit()
-        zone1.disconnect_mode('w')
+        zone1.disconnect_mode("w")
 
-        curr.execute('''select COUNT(*) from links where a_node=1''')
-        self.assertIsNot(tot, curr.fetchone()[0], 'failed to delete links')
+        curr.execute("""select COUNT(*) from links where a_node=1""")
+        self.assertIsNot(tot, curr.fetchone()[0], "failed to delete links")
 
-        curr.execute('''Select count(*) from links where a_node=1 and instr(modes,'w')>0''')
-        self.assertEqual(curr.fetchone()[0], 0, 'Failed to remove mode from all connectors')
+        curr.execute("""Select count(*) from links where a_node=1 and instr(modes,'w')>0""")
+        self.assertEqual(curr.fetchone()[0], 0, "Failed to remove mode from all connectors")
diff --git a/tests/aequilibrae/transit/test_GTFS.py b/tests/aequilibrae/transit/test_GTFS.py
index d9bd93689..348f1295e 100644
--- a/tests/aequilibrae/transit/test_GTFS.py
+++ b/tests/aequilibrae/transit/test_GTFS.py
@@ -11,8 +11,8 @@
 class TestGTFS(TestCase):
     def setUp(self) -> None:
         spatialite_folder = dirname(dirname(dirname(dirname(os.path.abspath(__file__)))))
-        spatialite_folder = join(spatialite_folder, 'aequilibrae/project')
-        os.environ['PATH'] = f'{spatialite_folder};' + os.environ['PATH']
+        spatialite_folder = join(spatialite_folder, "aequilibrae/project")
+        os.environ["PATH"] = f"{spatialite_folder};" + os.environ["PATH"]
 
         self.gtfs = GTFS()
         self.gtfs.source_folder = gtfs_folder
diff --git a/tests/aequilibrae/transit/test_create_gtfsdb.py b/tests/aequilibrae/transit/test_create_gtfsdb.py
index 6f197726d..435456a42 100644
--- a/tests/aequilibrae/transit/test_create_gtfsdb.py
+++ b/tests/aequilibrae/transit/test_create_gtfsdb.py
@@ -10,8 +10,8 @@
 class TestCreate_gtfsdb(TestCase):
     def setUp(self) -> None:
         spatialite_folder = dirname(dirname(dirname(dirname(os.path.abspath(__file__)))))
-        spatialite_folder = join(spatialite_folder, 'aequilibrae/project')
-        os.environ['PATH'] = f'{spatialite_folder};' + os.environ['PATH']
+        spatialite_folder = join(spatialite_folder, "aequilibrae/project")
+        os.environ["PATH"] = f"{spatialite_folder};" + os.environ["PATH"]
 
     def tearDown(self) -> None:
         if os.path.isfile(gtfs_db_output):
diff --git a/tests/aequilibrae/utils/test_create_delaunay_network.py b/tests/aequilibrae/utils/test_create_delaunay_network.py
index ee2012dfb..54d2c60ee 100644
--- a/tests/aequilibrae/utils/test_create_delaunay_network.py
+++ b/tests/aequilibrae/utils/test_create_delaunay_network.py
@@ -16,13 +16,13 @@ def tearDown(self) -> None:
     def test_create_delaunay_network(self):
         da = DelaunayAnalysis()
         with self.assertRaises(ValueError):
-            da.create_network('nodes')
+            da.create_network("nodes")
 
         da.create_network()
-        self.assertEqual(59, self.proj.conn.execute('select count(*) from delaunay_network').fetchone()[0])
+        self.assertEqual(59, self.proj.conn.execute("select count(*) from delaunay_network").fetchone()[0])
 
-        da.create_network('network', True)
-        self.assertEqual(62, self.proj.conn.execute('select count(*) from delaunay_network').fetchone()[0])
+        da.create_network("network", True)
+        self.assertEqual(62, self.proj.conn.execute("select count(*) from delaunay_network").fetchone()[0])
 
         with self.assertRaises(ValueError):
             da.create_network()
@@ -32,4 +32,4 @@ def test_assign_matrix(self):
         demand.computational_view(["matrix"])
         da = DelaunayAnalysis()
         da.create_network()
-        da.assign_matrix(demand, 'delaunay_test')
+        da.assign_matrix(demand, "delaunay_test")
diff --git a/tests/compile.py b/tests/compile.py
index 0fa7329e7..1e40ee800 100644
--- a/tests/compile.py
+++ b/tests/compile.py
@@ -3,7 +3,9 @@
 import sys
 from os.path import join, dirname
 
-pth = join(dirname(dirname(__file__)), 'aequilibrae', 'paths')
+pth = join(dirname(dirname(__file__)), "aequilibrae", "paths")
 
 os.chdir(pth)
-subprocess.Popen(f"{sys.executable} setup_Assignment.py build_ext --inplace", shell=True, stdout=subprocess.PIPE).stdout.read()
+subprocess.Popen(
+    f"{sys.executable} setup_Assignment.py build_ext --inplace", shell=True, stdout=subprocess.PIPE
+).stdout.read()
diff --git a/tests/data/reference_files.py b/tests/data/reference_files.py
index d48339ba9..2067d1a89 100644
--- a/tests/data/reference_files.py
+++ b/tests/data/reference_files.py
@@ -1,7 +1,7 @@
 import tempfile
 from os.path import dirname, abspath, join
 
-data_folder = join(dirname(dirname(abspath(__file__))), 'data')
+data_folder = join(dirname(dirname(abspath(__file__))), "data")
 
 # For the graph tests
 test_network = join(dirname(dirname(abspath(__file__))), "data", "Final_Network.shp")
@@ -31,4 +31,4 @@
 #
 no_triggers_project = join(dirname(dirname(abspath(__file__))), "data/no_triggers_project")
 
-st_varent_network = join(dirname(abspath(__file__)), 'St_Varent_issue307.zip')
+st_varent_network = join(dirname(abspath(__file__)), "St_Varent_issue307.zip")
diff --git a/tests/setup_windows_spatialite.py b/tests/setup_windows_spatialite.py
index 434182d0e..900a93615 100644
--- a/tests/setup_windows_spatialite.py
+++ b/tests/setup_windows_spatialite.py
@@ -5,34 +5,36 @@
 from os.path import join
 from os import walk
 
-pth = 'https://github.com/AequilibraE/aequilibrae/releases/download/V0.6.0.post1/mod_spatialite-NG-win-amd64.zip'
+pth = "https://github.com/AequilibraE/aequilibrae/releases/download/V0.6.0.post1/mod_spatialite-NG-win-amd64.zip"
 
 outfolder = gettempdir()
 
 dest_path = join(outfolder, "mod_spatialite-NG-win-amd64.zip")
 urllib.request.urlretrieve(pth, dest_path)
 
-fldr = join(outfolder, 'temp_data')
+fldr = join(outfolder, "temp_data")
 zipfile.ZipFile(dest_path).extractall(fldr)
 
-if 'WINDOWS' in platform.platform().upper():
+if "WINDOWS" in platform.platform().upper():
     # We now set sqlite. Only needed in thge windows server in Github
-    plats = {'x86': 'https://sqlite.org/2020/sqlite-dll-win32-x86-3320100.zip',
-             'x64': 'https://sqlite.org/2020/sqlite-dll-win64-x64-3320100.zip'}
+    plats = {
+        "x86": "https://sqlite.org/2020/sqlite-dll-win32-x86-3320100.zip",
+        "x64": "https://sqlite.org/2020/sqlite-dll-win64-x64-3320100.zip",
+    }
 
-    outfolder = 'C:/'
+    outfolder = "C:/"
     zip_path64 = join(outfolder, "sqlite-dll-win64-x64-3320100.zip")
-    urllib.request.urlretrieve(plats['x64'], zip_path64)
+    urllib.request.urlretrieve(plats["x64"], zip_path64)
 
     zip_path86 = join(outfolder, "sqlite-dll-win32-x86-3320100.zip")
-    urllib.request.urlretrieve(plats['x86'], zip_path86)
+    urllib.request.urlretrieve(plats["x86"], zip_path86)
 
-    root = 'C:/hostedtoolcache/windows/Python/'
-    file = 'sqlite3.dll'
+    root = "C:/hostedtoolcache/windows/Python/"
+    file = "sqlite3.dll"
     for d, subD, f in walk(root):
         if file in f:
-            if 'x64' in d:
+            if "x64" in d:
                 zipfile.ZipFile(zip_path64).extractall(d)
             else:
                 zipfile.ZipFile(zip_path86).extractall(d)
-            print(f'Replaces {d}')
+            print(f"Replaces {d}")