Lint: Blackens code base

Daniel G. A. Smith · Daniel G. A. Smith · commit cc252dbba31e · 2019-12-10T16:45:20.000-05:00
diff --git a/Makefile b/Makefile
@@ -9,8 +9,8 @@ install:
 
 .PHONY: format
 format:
-	$(autoflake)
-	$(isort)
+#	$(autoflake)
+#	$(isort)
 	$(black)
 
 .PHONY: lint
diff --git a/qcengine/config.py b/qcengine/config.py
@@ -71,14 +71,19 @@ class NodeDescriptor(pydantic.BaseModel):
     memory_safety_factor: int = 10  # Percentage of memory as a safety factor
 
     # Specifications
-    ncores: Optional[int] = pydantic.Field(None, description="""Number of cores accessible to each task on this node
+    ncores: Optional[int] = pydantic.Field(
+        None,
+        description="""Number of cores accessible to each task on this node
     
-    The default value, ``None``, will allow QCEngine to autodetect the number of cores.""")
+    The default value, ``None``, will allow QCEngine to autodetect the number of cores.""",
+    )
     jobs_per_node: int = 2
     retries: int = 0
 
     # Cluster options
-    is_batch_node: bool = pydantic.Field(False, help="""Whether the node running QCEngine is a batch node
+    is_batch_node: bool = pydantic.Field(
+        False,
+        help="""Whether the node running QCEngine is a batch node
     
     Some clusters are configured such that tasks are launched from a special "batch" or "MOM" onto the compute nodes.
     The compute nodes on such clusters often have a different CPU architecture than the batch nodes and 
@@ -89,9 +94,11 @@ class NodeDescriptor(pydantic.BaseModel):
     
     ``is_batch_node`` is used when creating the task configuration as a means of determining whether
     ``mpiexec_command`` must always be used even for serial jobs (e.g., getting the version number)
-    """)
+    """,
+    )
     mpiexec_command: Optional[str] = pydantic.Field(
-        None, description="""Invocation for launching node-parallel tasks with MPI
+        None,
+        description="""Invocation for launching node-parallel tasks with MPI
         
         The invocation need not specify the number of nodes, tasks, or cores per node.
         Information about the task configuration will be added to the command by use of
@@ -112,7 +119,7 @@ class NodeDescriptor(pydantic.BaseModel):
         ``aprun -n {total_ranks} -N {ranks_per_node} -d {cores_per_rank} -j 1``.
         The appropriate number of ranks per node will be determined based on the number of
         cores per node and the number of cores per rank.
-        """
+        """,
     )
 
     def __init__(self, **data: Dict[str, Any]):
@@ -121,10 +128,10 @@ def __init__(self, **data: Dict[str, Any]):
 
         if self.mpiexec_command is not None:
             # Ensure that the mpiexec_command contains necessary information
-            if not ('{total_ranks}' in self.mpiexec_command or '{nnodes}' in self.mpiexec_command):
-                raise ValueError('mpiexec_command must contain either {total_ranks} or {nnodes}')
-            if '{ranks_per_node}' not in self.mpiexec_command:
-                raise ValueError('mpiexec_command must explicitly state the number of ranks per node')
+            if not ("{total_ranks}" in self.mpiexec_command or "{nnodes}" in self.mpiexec_command):
+                raise ValueError("mpiexec_command must contain either {total_ranks} or {nnodes}")
+            if "{ranks_per_node}" not in self.mpiexec_command:
+                raise ValueError("mpiexec_command must explicitly state the number of ranks per node")
 
     class Config:
         extra = "forbid"
@@ -301,8 +308,10 @@ def get_config(*, hostname: Optional[str] = None, local_options: Dict[str, Any]
 
     # Make sure mpirun command is defined if needed
     if config["use_mpiexec"] and config["mpiexec_command"] is None:
-        raise ValueError("You need to define the mpiexec command for this node. "
-                         "See: https://qcengine.readthedocs.io/en/stable/environment.html")
+        raise ValueError(
+            "You need to define the mpiexec command for this node. "
+            "See: https://qcengine.readthedocs.io/en/stable/environment.html"
+        )
 
     return TaskConfig(**config)
 
diff --git a/qcengine/programs/entos.py b/qcengine/programs/entos.py
@@ -202,7 +202,7 @@ def build_input(
             energy_keywords_from_input_model = {
                 "dft": {"xc": input_model.model.method.upper(), **scf_keywords_from_input_model},
                 "hf": {**scf_keywords_from_input_model},
-                "xtb": {"charge": input_model.molecule.molecular_charge,},
+                "xtb": {"charge": input_model.molecule.molecular_charge},
             }
 
             # Resolve keywords (extra options) for the energy command
@@ -222,22 +222,22 @@ def build_input(
                         **structure,
                         **energy_keywords_from_input_model[energy_command],
                         **energy_keywords_extra,
-                    },
+                    }
                 }
             # Create the input dictionary for a gradient call
             elif input_model.driver == "gradient":
                 input_dict = {
                     "gradient": {
                         **structure,
-                        energy_command: {**energy_keywords_from_input_model[energy_command], **energy_keywords_extra,},
-                    },
+                        energy_command: {**energy_keywords_from_input_model[energy_command], **energy_keywords_extra},
+                    }
                 }
             elif input_model.driver == "hessian":
                 input_dict = {
                     "hessian": {
                         **structure,
                         energy_command: {**energy_keywords_from_input_model[energy_command], **energy_keywords_extra},
-                    },
+                    }
                 }
             else:
                 raise NotImplementedError(f"Driver {input_model.driver} not implemented for entos.")
diff --git a/qcengine/programs/nwchem/germinate.py b/qcengine/programs/nwchem/germinate.py
@@ -170,8 +170,7 @@ def muster_modelchem(method: str, derint: int, use_tce: bool) -> Tuple[str, Dict
 
     elif method == "tce":
         raise InputError(
-            f"Do not specify TCE as a method. Instead specify the desired method "
-            f'as a keyword and "qc_module=True".'
+            f"Do not specify TCE as a method. Instead specify the desired method " f'as a keyword and "qc_module=True".'
         )
 
     elif method in _xc_functionals:
diff --git a/qcengine/programs/nwchem/harvester.py b/qcengine/programs/nwchem/harvester.py
@@ -57,7 +57,7 @@ def harvest_outfile_pass(outtext):
     version = ""
     error = ""  # TODO (wardlt): The error string is never used.
 
-    NUMBER = r'(?x:' + regex.NUMBER + ')'
+    NUMBER = r"(?x:" + regex.NUMBER + ")"
     # fmt: off
 
     # Process version
@@ -590,17 +590,21 @@ def harvest_outfile_pass(outtext):
             psivar['NWCHEM ERROR CODE'] = mobj.group(1)
             # TODO process errors into error var
 
+    # fmt: on
+
     # Get the size of the basis sets, etc
-    mobj = re.search(r'No. of atoms\s+:\s+(\d+)', outtext, re.MULTILINE)
+    mobj = re.search(r"No. of atoms\s+:\s+(\d+)", outtext, re.MULTILINE)
     if mobj:
         psivar["N ATOMS"] = mobj.group(1)
-    mobj = re.search(r"No. of electrons\s+:\s+(\d+)\s+Alpha electrons\s+:\s+(\d+)\s+Beta electrons\s+:\s+(\d+)",
-                     outtext, re.MULTILINE)
+    mobj = re.search(
+        r"No. of electrons\s+:\s+(\d+)\s+Alpha electrons\s+:\s+(\d+)\s+Beta electrons\s+:\s+(\d+)",
+        outtext,
+        re.MULTILINE,
+    )
     if mobj:
         psivar["N ALPHA ELECTRONS"] = mobj.group(2)
         psivar["N BETA ELECTRONS"] = mobj.group(3)
-    mobj = re.search(r"AO basis - number of functions:\s+(\d+)\s+number of shells:\s+(\d+)",
-                     outtext, re.MULTILINE)
+    mobj = re.search(r"AO basis - number of functions:\s+(\d+)\s+number of shells:\s+(\d+)", outtext, re.MULTILINE)
     if mobj:
         psivar["N MO"] = mobj.group(2)
         psivar["N BASIS"] = mobj.group(1)
@@ -670,28 +674,30 @@ def extract_formatted_properties(psivars: PreservingDict) -> AtomicResultPropert
     output = dict()
 
     # Extract the Calc Info
-    output.update({
-        'calcinfo_nbasis': psivars.get('N BASIS', None),
-        'calcinfo_nmo': psivars.get('N MO', None),
-        'calcinfo_natom': psivars.get('N ATOMS', None),
-        'calcinfo_nalpha': psivars.get('N ALPHA ELECTRONS', None),
-        'calcinfo_nbeta': psivars.get('N BETA ELECTRONS', None)
-    })
+    output.update(
+        {
+            "calcinfo_nbasis": psivars.get("N BASIS", None),
+            "calcinfo_nmo": psivars.get("N MO", None),
+            "calcinfo_natom": psivars.get("N ATOMS", None),
+            "calcinfo_nalpha": psivars.get("N ALPHA ELECTRONS", None),
+            "calcinfo_nbeta": psivars.get("N BETA ELECTRONS", None),
+        }
+    )
 
     # Get the "canonical" properties
-    output['return_energy'] = psivars['CURRENT ENERGY']
-    output['nuclear_repulsion_energy'] = psivars['NUCLEAR REPULSION ENERGY']
+    output["return_energy"] = psivars["CURRENT ENERGY"]
+    output["nuclear_repulsion_energy"] = psivars["NUCLEAR REPULSION ENERGY"]
 
     # Get the SCF properties
-    output['scf_total_energy'] = psivars.get('HF TOTAL ENERGY', None)
-    output['scf_one_electron_energy'] = psivars.get('ONE-ELECTRON ENERGY', None)
-    output['scf_two_electron_energy'] = psivars.get('ONE-ELECTRON ENERGY', None)
+    output["scf_total_energy"] = psivars.get("HF TOTAL ENERGY", None)
+    output["scf_one_electron_energy"] = psivars.get("ONE-ELECTRON ENERGY", None)
+    output["scf_two_electron_energy"] = psivars.get("ONE-ELECTRON ENERGY", None)
 
     # Get the MP2 properties
-    output['mp2_total_correlation_energy'] = psivars.get('MP2 CORRELATION ENERGY', None)
-    output['mp2_total_energy'] = psivars.get('MP2 TOTAL ENERGY', None)
-    output['mp2_same_spin_correlation_energy'] = psivars.get('MP2 SAME-SPIN CORRELATION ENERGY', None)
-    output['mp2_opposite_spin_correlation_energy'] = psivars.get('MP2 OPPOSITE-SPIN CORRELATION ENERGY', None)
+    output["mp2_total_correlation_energy"] = psivars.get("MP2 CORRELATION ENERGY", None)
+    output["mp2_total_energy"] = psivars.get("MP2 TOTAL ENERGY", None)
+    output["mp2_same_spin_correlation_energy"] = psivars.get("MP2 SAME-SPIN CORRELATION ENERGY", None)
+    output["mp2_opposite_spin_correlation_energy"] = psivars.get("MP2 OPPOSITE-SPIN CORRELATION ENERGY", None)
     return AtomicResultProperties(**output)
 
 
diff --git a/qcengine/programs/nwchem/runner.py b/qcengine/programs/nwchem/runner.py
@@ -73,8 +73,7 @@ def get_version(self) -> str:
         command.append("v.nw")
 
         if which_prog not in self.version_cache:
-            success, output = execute(command, {"v.nw": ""},
-                                      scratch_directory=config.scratch_directory)
+            success, output = execute(command, {"v.nw": ""}, scratch_directory=config.scratch_directory)
 
             if success:
                 for line in output["stdout"].splitlines():
diff --git a/qcengine/programs/qchem.py b/qcengine/programs/qchem.py
@@ -374,7 +374,11 @@ def parse_logfile(self, outfiles: Dict[str, str]) -> AtomicResult:
                     jobtype = keywords.pop("jobtype")
                 else:
                     jobtype = "sp"
-                _jobtype_to_driver = {"sp": "energy", "force": "gradient", "freq": "hessian"}  # optimization intentionally not supported
+                _jobtype_to_driver = {
+                    "sp": "energy",
+                    "force": "gradient",
+                    "freq": "hessian",
+                }  # optimization intentionally not supported
                 try:
                     input_dict["driver"] = _jobtype_to_driver[jobtype]
                 except KeyError:
diff --git a/qcengine/tests/test_config.py b/qcengine/tests/test_config.py
@@ -85,7 +85,7 @@ def opt_state_basic():
                 "jobs_per_node": 1,
                 "mpiexec_command": "mpirun -n {total_ranks} -N {ranks_per_node}",
                 "ncores": 24,
-                "memory": 240
+                "memory": 240,
             },
             {
                 "name": "default",
@@ -168,24 +168,42 @@ def test_config_local_nnodes(opt_state_basic):
     # Give a warning that mentions that mpirun is needed if you define a multi-node task
     with pytest.raises(ValueError) as exc:
         qcng.config.get_config(hostname="something", local_options={"nnodes": 10})
-    assert 'https://qcengine.readthedocs.io/en/stable/environment.html' in str(exc.value)
+    assert "https://qcengine.readthedocs.io/en/stable/environment.html" in str(exc.value)
 
     # Test with an MPI run command
-    local_options = {"nnodes": 4,
-                     "mpiexec_command": "mpirun -n {total_ranks} -N {ranks_per_node} --cpus-per-slot {cores_per_rank}"}
+    local_options = {
+        "nnodes": 4,
+        "mpiexec_command": "mpirun -n {total_ranks} -N {ranks_per_node} --cpus-per-slot {cores_per_rank}",
+    }
     config = qcng.config.get_config(hostname="something", local_options=local_options)
     assert config.use_mpiexec
-    assert config.mpiexec_command.startswith('mpirun')
-    assert create_mpi_invocation('hello_world', config) == ['mpirun', '-n', '20', '-N', '5', '--cpus-per-slot', '1',
-                                                            'hello_world']
+    assert config.mpiexec_command.startswith("mpirun")
+    assert create_mpi_invocation("hello_world", config) == [
+        "mpirun",
+        "-n",
+        "20",
+        "-N",
+        "5",
+        "--cpus-per-slot",
+        "1",
+        "hello_world",
+    ]
 
     # Change the number of cores per rank
     local_options["cores_per_rank"] = 2
-    config = qcng.config.get_config(hostname='something', local_options=local_options)
+    config = qcng.config.get_config(hostname="something", local_options=local_options)
     assert config.use_mpiexec
-    assert config.mpiexec_command.startswith('mpirun')
-    assert create_mpi_invocation('hello_world', config) == ['mpirun', '-n', '20', '-N', '2', '--cpus-per-slot', '2',
-                                                            'hello_world']
+    assert config.mpiexec_command.startswith("mpirun")
+    assert create_mpi_invocation("hello_world", config) == [
+        "mpirun",
+        "-n",
+        "20",
+        "-N",
+        "2",
+        "--cpus-per-slot",
+        "2",
+        "hello_world",
+    ]
 
 
 def test_config_validation(opt_state_basic):
@@ -204,7 +222,7 @@ def test_batch_node(opt_state_basic):
     assert config.ncores == 24
     assert config.nnodes == 1
 
-    config = qcng.config.get_config(hostname="bn1", local_options={'nnodes': 2})
+    config = qcng.config.get_config(hostname="bn1", local_options={"nnodes": 2})
     assert config.use_mpiexec
     assert config.ncores == 24
     assert config.nnodes == 2
@@ -214,9 +232,8 @@ def test_mpirun_command_errors():
     # Checks for ranks_per_node
     with pytest.raises(ValueError) as exc:
         NodeDescriptor(name="something", hostname_pattern="*", mpiexec_command="mpirun -n {total_ranks}")
-    assert 'must explicitly state' in str(exc.value)
+    assert "must explicitly state" in str(exc.value)
 
     with pytest.raises(ValueError) as exc:
         NodeDescriptor(name="something", hostname_pattern="*", mpiexec_command="mpirun -N {ranks_per_node}")
-    assert 'must contain either' in str(exc.value)
-
+    assert "must contain either" in str(exc.value)
diff --git a/qcengine/tests/test_utils.py b/qcengine/tests/test_utils.py
@@ -79,13 +79,13 @@ def test_disk_files():
 
 def test_popen_tee_output(capsys):
     # Test without passing
-    with util.popen(['echo', 'hello']) as proc:
-        proc['proc'].wait()
-    assert proc['stdout'].strip() == 'hello'
+    with util.popen(["echo", "hello"]) as proc:
+        proc["proc"].wait()
+    assert proc["stdout"].strip() == "hello"
 
     # Test with passing
-    with util.popen(['echo', 'hello'], pass_output_forward=True) as proc:
-        proc['proc'].wait()
-    assert proc['stdout'] == 'hello\n'
+    with util.popen(["echo", "hello"], pass_output_forward=True) as proc:
+        proc["proc"].wait()
+    assert proc["stdout"] == "hello\n"
     captured = capsys.readouterr()
-    assert captured.out == 'hello\n'
+    assert captured.out == "hello\n"
diff --git a/qcengine/util.py b/qcengine/util.py
@@ -44,7 +44,7 @@ def create_mpi_invocation(executable: str, task_config: TaskConfig) -> List[str]
         nnodes=task_config.nnodes,
         ranks_per_node=task_config.ncores // task_config.cores_per_rank,
         total_ranks=task_config.nnodes * task_config.ncores,
-        cores_per_rank=task_config.cores_per_rank
+        cores_per_rank=task_config.cores_per_rank,
     )
     command = mpirun_str.split()
 
@@ -218,8 +218,12 @@ def terminate_process(proc: Any, timeout: int = 15) -> None:
 
 
 @contextmanager
-def popen(args: List[str], append_prefix: bool = False, popen_kwargs: Optional[Dict[str, Any]] = None,
-          pass_output_forward: bool = False) -> Dict[str, Any]:
+def popen(
+    args: List[str],
+    append_prefix: bool = False,
+    popen_kwargs: Optional[Dict[str, Any]] = None,
+    pass_output_forward: bool = False,
+) -> Dict[str, Any]:
     """
     Opens a background task
 
@@ -287,10 +291,11 @@ def popen(args: List[str], append_prefix: bool = False, popen_kwargs: Optional[D
     #  from the buffers to ensure that they do not fill.
     #
     def read_from_buffer(buffer: BinaryIO, storage: io.BytesIO, sysio: TextIO):
-        for r in iter(partial(buffer.read, 1024), b''):
+        for r in iter(partial(buffer.read, 1024), b""):
             storage.write(r)
             if pass_output_forward:
                 sysio.write(r.decode())
+
     stdout_reader = Thread(target=read_from_buffer, args=(ret["proc"].stdout, stdout, sys.stdout))
     stdout_reader.start()
     stderr_reader = Thread(target=read_from_buffer, args=(ret["proc"].stderr, stderr, sys.stderr))

Original file line number	Diff line number	Diff line change
`@@ -170,8 +170,7 @@ def muster_modelchem(method: str, derint: int, use_tce: bool) -> Tuple[str, Dict`
`170`	`170`
`171`	`171`	`elif method == "tce":`
`172`	`172`	`raise InputError(`
`173`		`- f"Do not specify TCE as a method. Instead specify the desired method "`
`174`		`- f'as a keyword and "qc_module=True".'`
	`173`	`+ f"Do not specify TCE as a method. Instead specify the desired method " f'as a keyword and "qc_module=True".'`
`175`	`174`	`)`
`176`	`175`
`177`	`176`	`elif method in _xc_functionals:`