def test_compute_gradient(program, model, keywords): if not has_program(program): pytest.skip("Program '{}' not found.".format(program)) molecule = _get_molecule(program) inp = AtomicInput(molecule=molecule, driver="gradient", model=model, extras={"mytag": "something"}, keywords=keywords) if program in ["adcc", "mrchem"]: with pytest.raises(qcng.exceptions.InputError) as e: qcng.compute(inp, program, raise_error=True) assert "Driver gradient not implemented" in str(e.value) else: ret = qcng.compute(inp, program, raise_error=True) assert ret.success is True assert isinstance(ret.return_result, np.ndarray) assert len(ret.return_result.shape) == 2 assert ret.return_result.shape[1] == 3 assert "mytag" in ret.extras, ret.extras
def test_local_options_memory_gib(program, model, keywords, memory_trickery, request): """Ensure memory handling implemented in harness (if applicable). For available harnesses, run minimal calc at specific total node memory, both through runtime config alone and with clashing (and non-QCEngine-like) keyword spec. Check memory quantity shows up in ``TaskConfig``. For ``managed-memory``-active harnesses, check that memory registers in output. New Harness Instructions ------------------------ * Make sure minimal calc is in _canonical_methods above. * If ``managed_memory=True`` in harness, add regex to ``stdout_ref`` below to check that memory is specifiable. * If this test doesn't work, implement or adjust ``config.memory`` in your harness. """ if not has_program(program): pytest.skip(f"Program '{program}' not found.") harness = qcng.get_program(program) molecule = _get_molecule(program, model["method"]) addl_keywords = memory_trickery.get(program, memory_trickery) use_keywords = {**keywords, **addl_keywords} # << Config config = qcng.config.get_config( hostname="something", task_config={ "ncores": 1, "nnodes": 1, "memory": 1.555, }, ) # << Run inp = AtomicInput(molecule=molecule, driver="energy", model=model, keywords=use_keywords) ret = qcng.compute(inp, program, raise_error=True, local_options=config.dict()) pprint.pprint(ret.dict(), width=200) assert ret.success is True # << Reference stdout_ref = { # 1.555 GiB = 208708567 quad-words "cfour": "Allocated 1592 MB of main memory", "gamess": "208000000 WORDS OF MEMORY AVAILABLE", "nwchem": r"total = 2087085\d\d doubles = 1592.3 Mbytes", # doubles is quad-words. Mbytes is MiB "psi4": "1592 MiB Core", } # << Test assert config.ncores == 1 assert pytest.approx(config.memory, 0.1) == 1.555 if harness._defaults["managed_memory"] is True: assert re.search(stdout_ref[program], ret.stdout), f"Memory pattern not found: {stdout_ref[program]}"
def test_compute_bad_models(program, model): if not testing.has_program(program): pytest.skip("Program '{}' not found.".format(program)) inp = ResultInput(molecule=qcng.get_molecule("hydrogen"), driver="energy", model=model) with pytest.raises(ValueError) as exc: ret = qcng.compute(inp, program, raise_error=True)
def test_compute_gradient(program, model): if not testing.has_program(program): pytest.skip("Program '{}' not found.".format(program)) inp = ResultInput(molecule=qcng.get_molecule("hydrogen"), driver="gradient", model=model) ret = qcng.compute(inp, program, raise_error=True) assert ret.success is True assert isinstance(ret.return_result, list)
def test_local_options_ncores(program, model, keywords, ncores): """Ensure multithreading implemented in harness (if applicable) or multithreaded runs don't break harness (if inapplicable). For available harnesses, run minimal calc with single and multiple cores; check ncores count shows up in ``TaskConfig``. For ``thread_parallel``-active harnesses, check ncores count registers in output. New Harness Instructions ------------------------ * Make sure minimal calc is in _canonical_methods above. * If ``thread_parallel=True`` in harness, add regex to ``stdout_ref`` below to check ncores the program sees. * If this test doesn't work, implement or adjust ``config.ncores`` in your harness. """ if not has_program(program): pytest.skip(f"Program '{program}' not found.") harness = qcng.get_program(program) molecule = _get_molecule(program, model["method"]) # << Config config = qcng.config.get_config( hostname="something", task_config={ "ncores": ncores, "nnodes": 1, }, ) # << Run inp = AtomicInput(molecule=molecule, driver="energy", model=model, keywords=keywords) ret = qcng.compute(inp, program, raise_error=True, local_options=config.dict()) pprint.pprint(ret.dict(), width=200) assert ret.success is True # << Reference stdout_ref = { "cfour": rf"Running with {ncores} threads/proc", "gamess": rf"MEMDDI DISTRIBUTED OVER\s+{ncores} PROCESSORS", # "gamess": rf"PARALLEL VERSION RUNNING ON\s+{ncores} PROCESSORS IN\s+1 NODES", # no line for serial # nwchem is node_parallel only "psi4": rf"Threads:\s+{ncores}", } # << Test assert config.ncores == ncores assert config.nnodes == 1 if harness._defaults["thread_parallel"] is True: assert re.search(stdout_ref[program], ret.stdout), f"Thread pattern not found: {stdout_ref[program]}"
def test_compute_bad_models(program, model): if not has_program(program): pytest.skip("Program '{}' not found.".format(program)) adriver = model.pop("driver", "energy") amodel = model inp = AtomicInput(molecule=qcng.get_molecule("hydrogen"), driver=adriver, model=amodel) with pytest.raises(qcng.exceptions.InputError) as exc: ret = qcng.compute(inp, program, raise_error=True)
def test_compute_energy(program, model, keywords): if not has_program(program): pytest.skip(f"Program '{program}' not found.") molecule = _get_molecule(program) inp = AtomicInput(molecule=molecule, driver="energy", model=model, keywords=keywords) ret = qcng.compute(inp, program, raise_error=True) assert ret.success is True assert isinstance(ret.return_result, float)
def test_compute_energy_qcsk_basis(program, model, keywords): if not has_program(program): pytest.skip("Program '{}' not found.".format(program)) molecule = _get_molecule(program) inp = AtomicInput(molecule=molecule, driver="energy", model=model, keywords=keywords) with pytest.raises(qcng.exceptions.InputError) as e: qcng.compute(inp, program, raise_error=True) assert "QCSchema BasisSet for model.basis not implemented" in str(e.value)
def test_compute_energy(program, model): if not has_program(program): pytest.skip("Program '{}' not found.".format(program)) inp = AtomicInput(molecule=qcng.get_molecule("hydrogen"), driver="energy", model=model) ret = qcng.compute(inp, program, raise_error=True) assert ret.success is True assert isinstance(ret.return_result, float)
def test_compute_gradient(program, model): if not has_program(program): pytest.skip("Program '{}' not found.".format(program)) molecule = _get_molecule(program) inp = AtomicInput(molecule=molecule, driver="gradient", model=model, extras={"mytag": "something"}) ret = qcng.compute(inp, program, raise_error=True) assert ret.success is True assert isinstance(ret.return_result, np.ndarray) assert len(ret.return_result.shape) == 2 assert ret.return_result.shape[1] == 3 assert "mytag" in ret.extras, ret.extras
def test_optimization_submissions(fractal_compute_server, specification): """Test submitting an Optimization dataset to a snowflake server.""" client = FractalClient(fractal_compute_server) qc_spec, driver = specification program = qc_spec["program"] if not has_program(program): pytest.skip(f"Program '{program}' not found.") molecules = Molecule.from_file(get_data("butane_conformers.pdb"), "pdb") factory = OptimizationDatasetFactory(driver=driver) factory.add_qc_spec(**qc_spec, spec_name="default", spec_description="test", overwrite=True) dataset = factory.create_dataset( dataset_name=f"Test optimizations info {program}, {driver}", molecules=molecules[:2], description="Test optimization dataset", tagline="Testing optimization datasets", ) with pytest.raises(DatasetInputError): dataset.submit(client=client, await_result=False) # now add a mock url so we can submit the data dataset.metadata.long_description_url = "https://test.org" # now submit again dataset.submit(client=client, await_result=False) fractal_compute_server.await_results() # make sure of the results are complete ds = client.get_collection("OptimizationDataset", dataset.dataset_name) # check the metadata meta = Metadata(**ds.data.metadata) assert meta == dataset.metadata # check the provenance assert dataset.provenance == ds.data.provenance # check the qc spec for qc_spec in dataset.qc_specifications.values(): spec = ds.data.specs[qc_spec.spec_name] assert spec.description == qc_spec.spec_description assert spec.qc_spec.driver == dataset.driver assert spec.qc_spec.method == qc_spec.method assert spec.qc_spec.basis == qc_spec.basis assert spec.qc_spec.program == qc_spec.program # check the keywords keywords = client.query_keywords(spec.qc_spec.keywords)[0] assert keywords.values["maxiter"] == dataset.maxiter assert keywords.values["scf_properties"] == dataset.scf_properties # query the dataset ds.query(qc_spec.spec_name) for index in ds.df.index: record = ds.df.loc[index].default assert record.status.value == "COMPLETE" assert record.error is None assert len(record.trajectory) > 1 # if we used psi4 make sure the properties were captured if program == "psi4": result = record.get_trajectory()[0] assert "CURRENT DIPOLE X" in result.extras["qcvars"].keys() assert "SCF QUADRUPOLE XX" in result.extras["qcvars"].keys()
def test_basic_submissions_single_pcm_spec(fractal_compute_server): """Test submitting a basic dataset to a snowflake server with pcm water in the specification.""" client = FractalClient(fractal_compute_server) program = "psi4" if not has_program(program): pytest.skip(f"Program '{program}' not found.") molecules = Molecule.from_file(get_data("butane_conformers.pdb"), "pdb") factory = BasicDatasetFactory(driver="energy") factory.add_qc_spec(method="hf", basis="sto-3g", program=program, spec_name="default", spec_description="testing the single points with pcm", implicit_solvent=PCMSettings(units="au", medium_Solvent="water"), overwrite=True) # only use one molecule due to the time it takes to run with pcm dataset = factory.create_dataset( dataset_name=f"Test single points with pcm water", molecules=molecules[0], description="Test basics dataset with pcm water", tagline="Testing single point datasets with pcm water", ) with pytest.raises(DatasetInputError): dataset.submit(client=client, await_result=False) # now add a mock url so we can submit the data dataset.metadata.long_description_url = "https://test.org" # now submit again dataset.submit(client=client, await_result=False) fractal_compute_server.await_results() # make sure of the results are complete ds = client.get_collection("Dataset", dataset.dataset_name) # check the metadata meta = Metadata(**ds.data.metadata) assert meta == dataset.metadata assert ds.data.description == dataset.description assert ds.data.tagline == dataset.dataset_tagline assert ds.data.tags == dataset.dataset_tags # check the provenance assert dataset.provenance == ds.data.provenance # check the qc spec assert ds.data.default_driver == dataset.driver # get the last ran spec for specification in ds.data.history: driver, program, method, basis, spec_name = specification spec = dataset.qc_specifications[spec_name] assert driver == dataset.driver assert program == spec.program assert method == spec.method assert basis == spec.basis break else: raise RuntimeError( f"The requested compute was not found in the history {ds.data.history}" ) for spec in dataset.qc_specifications.values(): query = ds.get_records( method=spec.method, basis=spec.basis, program=spec.program, ) for index in query.index: result = query.loc[index].record assert result.status.value.upper() == "COMPLETE" assert result.error is None assert result.return_result is not None # make sure the PCM result was captured assert result.extras["qcvars"]["PCM POLARIZATION ENERGY"] < 0
def test_protocol_native(program, model, keywords, native): """Ensure native_files protocol implemented in harness. For harnesses, run minimal gradient calc with different protocol settings; check expected native/DSL files show up in ``AtomicResult``. New Harness Instructions ------------------------ * Make sure minimal calc is in _canonical_methods above. This uses gradient for more files. * Add regex to ``input_ref`` & ``all_ref`` below to check content of input and any other file. * If this test doesn't work, implement or adjust ``native_files`` in your harness. """ if not has_program(program): pytest.skip(f"Program '{program}' not found.") harness = qcng.get_program(program) molecule = _get_molecule(program, model["method"]) # << Config protocols = { "native_files": native, } config = qcng.config.get_config( hostname="something", local_options={ "ncores": 1, "nnodes": 1, }, ) # << Run inp = AtomicInput(molecule=molecule, driver="gradient", model=model, keywords=keywords, protocols=protocols) ret = qcng.compute(inp, program, raise_error=True, local_options=config.dict()) pprint.pprint(ret.dict(), width=200) assert ret.success is True # << Reference input_ref = { "cfour": rf"\*CFOUR\(BASIS=6-31G", "dftd3": rf"1.000000 1.261000 1.703000", "gamess": rf"\$basis gbasis=n31 ngauss=6 \$end", "gcp": rf"level HF3C", "mctc-gcp": rf"level DFT/SV", "mp2d": rf"--TT_a1=0.944 --TT_a2=0.48", "nwchem": rf"H library 6-31G", "psi4": rf'"driver": "gradient",', } all_ref = { "cfour": ("GRD", rf"1.0+\s+0.0+\s+0.0+\s+0.03"), "dftd3": ("dftd3_geometry.xyz", rf"H\s+0.0+\s+0.0+\s+0.34"), "gamess": ("gamess.dat", rf"CLOSED SHELL ORBITALS --- GENERATED AT"), "gcp": ("gcp_geometry.xyz", rf"H\s+0.0+\s+0.0+\s+0.34"), "mctc-gcp": ("gcp_geometry.xyz", rf"H\s+0.0+\s+0.0+\s+0.34"), "mp2d": ("mp2d_geometry", rf"H\s+0.0+\s+0.0+\s+0.34"), "nwchem": ("nwchem.grad", rf"0.0, 0.0, 0.03"), "psi4": ("psi4.grad", rf"1.0+\s+(-?)0.0+\s+(-?)0.0+\s+0.03"), } # << Test if native == "none": assert ret.native_files is None elif native == "input": assert list(ret.native_files.keys()) == ["input"] if ret.native_files: assert "stdout" not in ret.native_files, f"Stdout found in native_files -- clean up the harness" assert "stderr" not in ret.native_files, f"Stderr found in native_files -- clean up the harness" assert "outfiles" not in ret.extras, f"Outfiles found in extras -- clean up the harness" if native in ["input", "all"]: assert re.search( input_ref[program], ret.native_files["input"] ), f"Input file pattern not found: {input_ref[program]}" if native == "all" and program != "psi4": # allow psi4 once native_files PR merged fl, snip = all_ref[program] assert re.search(snip, ret.native_files[fl] ), f"Ancillary file pattern not found in {fl}: {snip}"
def test_local_options_scratch(program, model, keywords): """Ensure scratch handling implemented in harness (if applicable). For available harnesses, run minimal calc at specific scratch directory name (randomly generated during test) and skip scratch clean-up. Check scratch settings show up in ``TaskConfig``. For ``scratch``-active harnesses, check that an expected file is written to and left behind in scratch directory. Check any scratch-related printing in output. New Harness Instructions ------------------------ * Make sure minimal calc is in _canonical_methods above. * If ``scratch=True`` in harness, add single file (preferrably output) glob to ``scratch_sample`` below to check that program scratch is directable. * If ``scratch=True`` in harness, if scratch directory mentioned in output, add regex to ``stdout_ref`` below to check that program scratch is directable. Otherwise, add an always-passing regex. * If this test doesn't work, implement or adjust ``config.scratch_directory`` and ``config.scratch_messy`` in your harness. """ if not has_program(program): pytest.skip(f"Program '{program}' not found.") harness = qcng.get_program(program) molecule = _get_molecule(program, model["method"]) # << Config scratch_directory = tempfile.mkdtemp(suffix="_" + program) config = qcng.config.get_config( hostname="something", local_options={ "scratch_directory": scratch_directory, "scratch_messy": True, }, ) # << Run inp = AtomicInput(molecule=molecule, driver="energy", model=model, keywords=keywords) ret = qcng.compute(inp, program, raise_error=True, local_options=config.dict()) pprint.pprint(ret.dict(), width=200) assert ret.success is True # << Reference stdout_ref = { "cfour": "University of Florida", # freebie "dftd3": "Grimme", # freebie "gamess": "IOWA STATE UNIVERSITY", # freebie "gcp": "Grimme", # freebie "mctc-gcp": "Grimme", # freebie "mp2d": "Beran", # freebie "nwchem": "E. Apra", # freebie "psi4": rf"Scratch directory: {scratch_directory}/tmp\w+_psi_scratch/", } # a scratch file (preferrably output) expected after job if scratch not cleaned up scratch_sample = { "cfour": "*/NEWFOCK", "dftd3": "*/dftd3_geometry.xyz", # no outfiles "gamess": "*/gamess.dat", "gcp": "*/gcp_geometry.xyz", # no outfiles "mctc-gcp": "*/gcp_geometry.xyz", # no outfiles "mp2d": "*/mp2d_geometry", # no outfiles "nwchem": "*/nwchem.db", "psi4": "*/psi.*.35", } # << Test assert config.scratch_directory.endswith(program) if harness._defaults["scratch"] is True: sample_file = list( Path(scratch_directory).glob(scratch_sample[program])) assert len( sample_file ) == 1, f"Scratch sample not found: {scratch_sample[program]} in {scratch_directory}" assert re.search( stdout_ref[program], ret.stdout), f"Scratch pattern not found: {stdout_ref[program]}"
def test_torsiondrive_submissions(fractal_compute_server, specification): """ Test submitting a torsiondrive dataset and computing it. """ client = FractalClient(fractal_compute_server) qc_spec, driver = specification program = qc_spec["program"] if not has_program(program): pytest.skip(f"Program '{program}' not found.") molecules = Molecule.from_smiles("CO") factory = TorsiondriveDatasetFactory(driver=driver) factory.add_qc_spec(**qc_spec, spec_name="default", spec_description="test", overwrite=True) dataset = factory.create_dataset( dataset_name=f"Test torsiondrives info {program}, {driver}", molecules=molecules, description="Test torsiondrive dataset", tagline="Testing torsiondrive datasets", ) with pytest.raises(DatasetInputError): dataset.submit(client=client, await_result=False) # now add a mock url so we can submit the data dataset.metadata.long_description_url = "https://test.org" # now submit again dataset.submit(client=client, await_result=False) fractal_compute_server.await_services(max_iter=50) # make sure of the results are complete ds = client.get_collection("TorsionDriveDataset", dataset.dataset_name) # check the metadata meta = Metadata(**ds.data.metadata) assert meta == dataset.metadata # check the provenance assert dataset.provenance == ds.data.provenance # check the qc spec for qc_spec in dataset.qc_specifications.values(): spec = ds.data.specs[qc_spec.spec_name] assert spec.description == qc_spec.spec_description assert spec.qc_spec.driver == dataset.driver assert spec.qc_spec.method == qc_spec.method assert spec.qc_spec.basis == qc_spec.basis assert spec.qc_spec.program == qc_spec.program # check the keywords keywords = client.query_keywords(spec.qc_spec.keywords)[0] assert keywords.values["maxiter"] == dataset.maxiter assert keywords.values["scf_properties"] == dataset.scf_properties # query the dataset ds.query(qc_spec.spec_name) for index in ds.df.index: record = ds.df.loc[index].default # this will take some time so make sure it is running with no error assert record.status.value == "COMPLETE", print(record.dict()) assert record.error is None assert len(record.final_energy_dict) == 24
def test_optimization_submissions_with_pcm(fractal_compute_server): """Test submitting an Optimization dataset to a snowflake server with PCM.""" client = FractalClient(fractal_compute_server) program = "psi4" if not has_program(program): pytest.skip(f"Program '{program}' not found.") # use a single small molecule due to the extra time PCM takes molecules = Molecule.from_smiles("C") factory = OptimizationDatasetFactory(driver="gradient") factory.add_qc_spec(method="hf", basis="sto-3g", program=program, spec_name="default", spec_description="test", implicit_solvent=PCMSettings(units="au", medium_Solvent="water"), overwrite=True) dataset = factory.create_dataset( dataset_name=f"Test optimizations info with pcm water", molecules=molecules, description="Test optimization dataset", tagline="Testing optimization datasets", ) with pytest.raises(DatasetInputError): dataset.submit(client=client, await_result=False) # now add a mock url so we can submit the data dataset.metadata.long_description_url = "https://test.org" # now submit again dataset.submit(client=client, await_result=False) fractal_compute_server.await_results() # make sure of the results are complete ds = client.get_collection("OptimizationDataset", dataset.dataset_name) # check the metadata meta = Metadata(**ds.data.metadata) assert meta == dataset.metadata # check the provenance assert dataset.provenance == ds.data.provenance # check the qc spec for qc_spec in dataset.qc_specifications.values(): spec = ds.data.specs[qc_spec.spec_name] assert spec.description == qc_spec.spec_description assert spec.qc_spec.driver == dataset.driver assert spec.qc_spec.method == qc_spec.method assert spec.qc_spec.basis == qc_spec.basis assert spec.qc_spec.program == qc_spec.program # check the keywords keywords = client.query_keywords(spec.qc_spec.keywords)[0] assert keywords.values["maxiter"] == dataset.maxiter assert keywords.values["scf_properties"] == dataset.scf_properties # query the dataset ds.query(qc_spec.spec_name) for index in ds.df.index: record = ds.df.loc[index].default assert record.status.value == "COMPLETE" assert record.error is None assert len(record.trajectory) > 1 result = record.get_trajectory()[0] assert "CURRENT DIPOLE X" in result.extras["qcvars"].keys() assert "SCF QUADRUPOLE XX" in result.extras["qcvars"].keys() # make sure the PCM result was captured assert result.extras["qcvars"]["PCM POLARIZATION ENERGY"] < 0
def test_basic_submissions_single_spec(fractal_compute_server, specification): """Test submitting a basic dataset to a snowflake server.""" client = FractalClient(fractal_compute_server) qc_spec, driver = specification program = qc_spec["program"] if not has_program(program): pytest.skip(f"Program '{program}' not found.") molecules = Molecule.from_file(get_data("butane_conformers.pdb"), "pdb") factory = BasicDatasetFactory(driver=driver) factory.add_qc_spec(**qc_spec, spec_name="default", spec_description="testing the single points", overwrite=True) dataset = factory.create_dataset( dataset_name=f"Test single points info {program}, {driver}", molecules=molecules, description="Test basics dataset", tagline="Testing single point datasets", ) with pytest.raises(DatasetInputError): dataset.submit(client=client, await_result=False) # now add a mock url so we can submit the data dataset.metadata.long_description_url = "https://test.org" # now submit again dataset.submit(client=client, await_result=False) fractal_compute_server.await_results() # make sure of the results are complete ds = client.get_collection("Dataset", dataset.dataset_name) # check the metadata meta = Metadata(**ds.data.metadata) assert meta == dataset.metadata assert ds.data.description == dataset.description assert ds.data.tagline == dataset.dataset_tagline assert ds.data.tags == dataset.dataset_tags # check the provenance assert dataset.provenance == ds.data.provenance # check the qc spec assert ds.data.default_driver == dataset.driver # get the last ran spec for specification in ds.data.history: driver, program, method, basis, spec_name = specification spec = dataset.qc_specifications[spec_name] assert driver == dataset.driver assert program == spec.program assert method == spec.method assert basis == spec.basis break else: raise RuntimeError( f"The requested compute was not found in the history {ds.data.history}" ) for spec in dataset.qc_specifications.values(): query = ds.get_records( method=spec.method, basis=spec.basis, program=spec.program, ) for index in query.index: result = query.loc[index].record assert result.status.value.upper() == "COMPLETE" assert result.error is None assert result.return_result is not None
def test_basic_submissions_wavefunction(fractal_compute_server): """ Test submitting a basic dataset with a wavefunction protocol and make sure it is executed. """ # only a psi4 test if not has_program("psi4"): pytest.skip(f"Program psi4 not found.") client = FractalClient(fractal_compute_server) molecules = Molecule.from_file(get_data("butane_conformers.pdb"), "pdb") factory = BasicDatasetFactory(driver="energy") factory.clear_qcspecs() factory.add_qc_spec(method="hf", basis="sto-6g", program="psi4", spec_name="default", spec_description="wavefunction spec", store_wavefunction="orbitals_and_eigenvalues") dataset = factory.create_dataset( dataset_name=f"Test single points with wavefunction", molecules=molecules, description="Test basics dataset", tagline="Testing single point datasets with wavefunction", ) # now add a mock url so we can submit the data dataset.metadata.long_description_url = "https://test.org" # submit the dataset # now submit again dataset.submit(client=client, await_result=False) fractal_compute_server.await_results() # make sure of the results are complete ds = client.get_collection("Dataset", dataset.dataset_name) # check the metadata meta = Metadata(**ds.data.metadata) assert meta == dataset.metadata assert ds.data.description == dataset.description assert ds.data.tagline == dataset.dataset_tagline assert ds.data.tags == dataset.dataset_tags # check the provenance assert dataset.provenance == ds.data.provenance # check the qc spec assert ds.data.default_driver == dataset.driver # get the last ran spec for specification in ds.data.history: driver, program, method, basis, spec_name = specification spec = dataset.qc_specifications[spec_name] assert driver == dataset.driver assert program == spec.program assert method == spec.method assert basis == spec.basis for spec in dataset.qc_specifications.values(): query = ds.get_records( method=spec.method, basis=spec.basis, program=spec.program, ) for index in query.index: result = query.loc[index].record assert result.status.value.upper() == "COMPLETE" assert result.error is None assert result.return_result is not None basis = result.get_wavefunction("basis") assert basis.name.lower() == "sto-6g" orbitals = result.get_wavefunction("orbitals_a") assert orbitals.shape is not None