def test_create_csv() -> None:
"""Test :func:`dataCAT.create_database.create_csv`."""
dtype1 = {'hdf5 index': int, 'formula': str, 'settings': str, 'opt': bool}
dtype2 = {'hdf5 index': int, 'settings': str, 'opt': bool}
filename1 = create_csv(PATH, 'ligand')
filename2 = create_csv(PATH, 'qd')
assertion.eq(filename1, LIGAND_PATH)
assertion.eq(filename2, QD_PATH)
df1 = pd.read_csv(LIGAND_PATH,
index_col=[0, 1],
header=[0, 1],
dtype=dtype1)
df2 = pd.read_csv(QD_PATH,
index_col=[0, 1, 2, 3],
header=[0, 1],
dtype=dtype2)
assertion.eq(df1.shape, (1, 4))
assertion.eq(df2.shape, (1, 5))
assertion.eq(df1.index.names, ['smiles', 'anchor'])
assertion.eq(df2.index.names,
['core', 'core anchor', 'ligand smiles', 'ligand anchor'])
assertion.eq(df1.columns.names, ['index', 'sub index'])
assertion.eq(df2.columns.names, ['index', 'sub index'])
assertion.contains(df1.index, ('-', '-'))
assertion.contains(df2.index, ('-', '-', '-', '-'))
np.testing.assert_array_equal(
df1.values, np.array([[-1, 'str', False, 'str']], dtype=object))
np.testing.assert_array_equal(
df2.values, np.array([[-1, -1, False, 'str', 'str']], dtype=object))
assertion.assert_(create_csv, PATH, 'bob', exception=ValueError)
def test_cp2k_singlepoint_mock(mocker: MockFixture):
"""Mock a call to CP2K."""
# single point calculation
s = fill_cp2k_defaults(templates.singlepoint)
# print orbitals
s.specific.cp2k.force_eval.dft.print.mo.filename = (
PATH / "orbitals.out").as_posix()
s.specific.cp2k.force_eval.dft.print.mo.mo_index_range = "7 46"
s.specific.cp2k.force_eval.dft.scf.added_mos = 20
# Construct a result objects
job = cp2k(s, ETHYLENE)
jobname = "cp2k_job"
run_mocked = mock_runner(mocker, jobname)
rs = run_mocked(job)
# electronic energy
assertion.isfinite(rs.energy)
# Molecular orbitals
orbs = rs.orbitals
assertion.assert_(np.isfinite, orbs.eigenvectors,
post_process=np.all) # eigenvalues
assertion.shape_eq(orbs.eigenvectors, (46, 40))
def test_setattr() -> None:
"""Test :class:`~nanoutils.SetAttr`."""
assertion.is_(OBJ.obj, _Test)
assertion.eq(OBJ.name, 'a')
assertion.is_(OBJ.value, False)
assertion.is_(OBJ.attr, _Test.a)
try:
OBJ.attr = False
assertion.is_(OBJ.attr, False)
finally:
OBJ.attr = True
assertion.contains(repr(OBJ), SetAttr.__name__)
assertion.contains(repr(OBJ), object.__repr__(OBJ.obj))
assertion.contains(repr(OBJ), reprlib.repr(OBJ.value))
assertion.contains(repr(OBJ), 'a')
obj2 = SetAttr(_Test, 'a', False)
obj3 = SetAttr(_Test, 'a', True)
assertion.eq(OBJ, obj2)
assertion.ne(OBJ, obj3)
assertion.ne(OBJ, 0)
assertion.assert_(OBJ.__reduce__, exception=TypeError)
assertion.is_(copy.copy(OBJ), OBJ)
assertion.is_(copy.deepcopy(OBJ), OBJ)
assertion.truth(hash(OBJ))
assertion.eq(hash(OBJ), OBJ._hash)
with OBJ:
assertion.is_(_Test.a, False)
assertion.is_(_Test.a, True)
def test_init() -> None:
"""Test :meth:`PDBContainer.__init__`."""
atoms = [(True, 1, 'Cad', 'LIG', 'A', 1, -5.231, 0.808, -0.649, 1, 0, 'C',
0, 0)]
bonds = [(1, 2, 1)]
assertion.assert_(PDBContainer, atoms, bonds, 1, 1)
index = range(1)
assertion.assert_(PDBContainer, atoms, bonds, 1, 1, index)
def test_combine_sigma() -> None:
"""Test :func:`FOX.functions.lj_uff.combine_sigma`."""
ref = np.load(PATH / 'uff_sigma.npy')
sigma = np.array([
combine_sigma(at1, at2) for at1, at2 in combinations(UFF_DF.index, r=2)
])
np.testing.assert_allclose(sigma, ref)
assertion.assert_(combine_sigma, 'a', 'b', exception=ValueError)
def test_charge_tolerance() -> None:
"""Test ``param.validation.charge_tolerance``."""
file = PATH / 'armc_ref.yaml'
with open(file, 'r') as f:
dct = yaml.load(f.read(), Loader=UniqueLoader)
dct = dct.copy()
dct['param']['charge']['Cd'] = 2
assertion.assert_(dict_to_armc, dct, exception=ValueError)
dct['param']['validation']['charge_tolerance'] = 'inf'
assertion.assert_(dict_to_armc, dct)
def test_param_sorting() -> None:
"""Tests for :func:`FOX.armc.sanitization._sort_atoms`"""
df1 = DF.copy()
df1.loc[6, "atoms"] = "Se Cd"
df1.loc[13, "atoms"] = "Se O_1"
_sort_atoms(df1)
np.testing.assert_array_equal(df1, DF)
df2 = DF.copy()
df2.loc[4, "atoms"] = "Se Cd"
df2.loc[5, "atoms"] = "Cd Se"
df2.loc[6, "atoms"] = "Se Cd"
assertion.assert_(_sort_atoms, df2, exception=ValueError)
def test_get_sphinx_domain() -> None:
"""Tests for :func:`~assertionlib.functions.get_sphinx_domain`."""
v1 = get_sphinx_domain(int)
v2 = get_sphinx_domain(list.count)
v3 = get_sphinx_domain(OrderedDict)
v4 = get_sphinx_domain(OrderedDict.keys)
v5 = get_sphinx_domain(isinstance)
assertion.eq(v1, ':class:`int<python:int>`')
assertion.eq(v2, ':meth:`list.count()<python:list.count>`')
assertion.eq(v3, ':class:`~collections.OrderedDict`')
assertion.eq(v4, ':meth:`~collections.OrderedDict.keys`')
assertion.eq(v5, ':func:`isinstance()<python:isinstance>`')
assertion.assert_(get_sphinx_domain, 1, exception=TypeError)
def test_cp2k_md():
"""Test :mod:`FOX.examples.cp2k_md`."""
file = join(PATH, 'armc.yaml')
with open(file, 'r') as f:
dct = yaml.load(f.read(), Loader=yaml.SafeLoader)
armc, job_kwarg = dict_to_armc(dct)
assertion.isinstance(armc, ARMC)
validate_mapping(armc, key_type=tuple, value_type=np.ndarray)
assertion.eq(armc._data, {})
assertion.eq(armc.hdf5_file,
os.path.abspath('tests/test_files/MM_MD_workdir/armc.hdf5'))
assertion.eq(armc.iter_len, 50000)
assertion.is_(armc.keep_files, False)
assertion.isinstance(armc.logger, Logger)
for mol in armc.molecule:
assertion.isinstance(mol, MultiMolecule)
assertion.shape_eq(mol, (4905, 227, 3))
assertion.eq(mol.dtype, float)
iterator = (i for v in armc.package_manager.values() for i in v)
for job_dict in iterator:
assertion.isinstance(job_dict['settings'], QmSettings)
np.testing.assert_allclose(np.array(job_dict['molecule']),
armc.molecule[0][0])
assertion.is_(job_dict['type'], cp2k_mm)
assertion.isinstance(armc.pes['rdf.0'], functools.partial)
assertion.eq(armc.pes['rdf.0'].keywords,
{'atom_subset': ['Cd', 'Se', 'O']})
assertion.eq(armc.pes['rdf.0'].args, (MultiMolecule.init_rdf, ))
phi_ref = PhiUpdater(a_target=0.25, gamma=2.0, phi=1.0, func=np.add)
assertion.eq(armc.phi, phi_ref)
assertion.eq(armc.sub_iter_len, 100)
for i in job_kwarg['psf']:
assertion.isinstance(i, PSFContainer)
assertion.eq(job_kwarg['folder'], 'MM_MD_workdir')
assertion.assert_(str.endswith, job_kwarg['path'],
join('tests', 'test_files'))
assertion.assert_(str.endswith, job_kwarg['logfile'],
join('tests', 'test_files', 'MM_MD_workdir', 'armc.log'))
def test_get_key_path() -> None:
"""Tests for :func:`_get_key_path`."""
# Pass a string with a valid key path alias
assertion.eq(_get_key_path('bond'), CP2K_KEYS_ALIAS['bond'])
assertion.eq(_get_key_path('lennard-jones'),
CP2K_KEYS_ALIAS['lennard-jones'])
assertion.eq(_get_key_path('genpot14'), CP2K_KEYS_ALIAS['genpot14'])
# Directly pass a key path
ref = ('specific', 'cp2k', 'a', 'b', 'c')
assertion.eq(_get_key_path(('a', 'b', 'c')), ref)
assertion.eq(_get_key_path(('specific', 'cp2k', 'a', 'b', 'c')), ref)
assertion.eq(_get_key_path(('input', 'a', 'b', 'c')), ref)
# Don't know these keys
assertion.assert_(_get_key_path, 'bob', exception=KeyError)
assertion.assert_(_get_key_path, 5, exception=KeyError)
def test_degree_of_separation():
"""Test :func:`degree_of_separation`."""
ref1 = np.load(PATH / 'degree_of_separation.npy')
ref2 = ref1.copy()
ref2[ref1 > 1] = np.inf
mat1 = degree_of_separation(MOL)
mat2 = degree_of_separation(MOL, bond_mat=MOL.bond_matrix())
mat3 = degree_of_separation(MOL, limit=1)
np.testing.assert_array_equal(mat1, ref1)
np.testing.assert_array_equal(mat2, ref1)
np.testing.assert_array_equal(mat3, ref2)
mol = MOL.copy()
mol.delete_all_bonds()
assertion.assert_(degree_of_separation, mol, exception=MoleculeError)
def test_prm_to_df() -> None:
"""Tests for :func:`prm_to_df`."""
s = Settings()
s.lennard_jones = {
'param': ('epsilon', 'sigma'),
'unit': ('kcalmol', 'angstrom'),
'Cs': (1, 1),
'Cd': (2, 2),
'O': (3, 3),
'H': (4, 4)
}
ref = {
'param': {
'epsilon': 'epsilon',
'sigma': 'sigma'
},
'unit': {
'epsilon': 'kcalmol',
'sigma': 'angstrom'
},
'Cs': {
'epsilon': 1.0,
'sigma': 1.0
},
'Cd': {
'epsilon': 2.0,
'sigma': 2.0
},
'O': {
'epsilon': 3.0,
'sigma': 3.0
},
'H': {
'epsilon': 4.0,
'sigma': 4.0
}
}
prm_to_df(s)
assertion.eq(s['lennard_jones'].to_dict(), ref)
# The 'param' key is missing
s2 = {'lennard-jones': {'Cs': (1, 2)}}
assertion.assert_(prm_to_df, s2, exception=KeyError)
def test_file_to_context() -> None:
"""Tests for :func:`file_to_context`."""
path_like = PATH_MOLECULES / 'mol.psf'
file_like = StringIO(PSF_STR)
cm1 = file_to_context(path_like)
cm2 = file_to_context(file_like)
assertion.isinstance(cm1, AbstractContextManager)
assertion.isinstance(cm2, AbstractContextManager)
assertion.isinstance(cm1.__enter__(), TextIOBase)
assertion.isinstance(cm2.__enter__(), TextIOBase)
sequence = range(10)
assertion.assert_(file_to_context, sequence, require_iterator=False)
assertion.assert_(file_to_context, sequence, require_iterator=True, exception=TypeError)
assertion.assert_(file_to_context, None, exception=TypeError)
assertion.assert_(file_to_context, [1, 2], exception=TypeError)
assertion.assert_(file_to_context, 5.0, exception=TypeError)
def test_identify_surface() -> None:
"""Tests for :func:`nanoCAT.bde.guess_core_dist.guess_core_core_dist`."""
idx_superset = np.array([i for i, atom in enumerate(MOL) if atom.symbol == 'Cd'])
xyz = np.array(MOL)[idx_superset]
idx_subset = idx_superset[identify_surface(xyz)]
ref = [3, 4, 5, 6, 13, 14, 16, 23, 26, 32, 33, 34, 36, 41, 46, 48, 53, 54, 55, 56, 57, 58, 62,
63, 65, 68, 69, 74, 77, 79, 80, 82, 83, 86, 92, 93, 94, 95, 96, 99, 101, 105, 106, 111,
112, 113, 118, 119, 120, 126, 128, 129, 135, 138, 143, 144, 146, 147, 153, 155, 156, 157,
158, 159, 160, 161, 162, 163, 167, 168, 170, 171, 172, 173, 174, 175, 176, 177, 179, 181,
183, 186, 187, 188, 190, 191, 192, 193, 196, 199, 200, 201, 205, 206, 210, 212, 217, 221,
226, 227, 228, 229, 234, 235, 237, 238, 239, 240, 241, 242, 243, 244, 247, 250, 252, 253,
254, 255, 258, 260, 263, 264, 265, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277,
283, 285, 288, 289, 290, 291, 294, 295, 297, 300, 301, 302, 303, 305, 306, 307, 308, 309,
311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 325, 327, 328, 330, 331,
333, 335, 337, 338, 340, 348, 349, 353, 354, 355, 356, 357, 358, 359]
np.testing.assert_array_equal(idx_subset, ref)
assertion.assert_(identify_surface, MOL, max_dist=1, exception=ValueError)
def test_get_importable() -> None:
"""Tests for :func:`nanoutils.get_importable`."""
class Test:
split = True
assertion.is_(get_importable('builtins.dict'), dict)
assertion.is_(get_importable('builtins.dict', validate=isclass), dict)
assertion.assert_(get_importable, None, exception=TypeError)
assertion.assert_(get_importable, Test, exception=TypeError)
assertion.assert_(get_importable, 'builtins.len', validate=isclass, exception=RuntimeError)
assertion.assert_(get_importable, 'builtins.len', validate=partial(isclass),
exception=RuntimeError)
def test_armc(name: str) -> None:
"""Test :class:`ARMC` and :class:`ARMCPT`."""
file = PATH / name
with open(file, 'r') as f:
dct = yaml.load(f.read(), Loader=UniqueLoader)
armc, job_kwargs = dict_to_armc(dct)
if name == 'armc_ref.yaml':
REF = ARMC_REF
armc.package_manager.hook = iter(load_results(ARMC_REF, n=1))
else:
iterator = _get_phi_iter()
def swap_phi(*args: Any, **kwargs: Any) -> List[Tuple[int, int]]:
return next(iterator)
REF = ARMCPT_REF
armc.swap_phi = swap_phi
armc.package_manager.hook = iter(load_results(ARMCPT_REF, n=3))
hdf5_ref = REF / 'armc.hdf5'
hdf5 = PATH / job_kwargs['folder'] / 'armc.hdf5'
run_armc(armc, restart=False, **job_kwargs)
assertion.assert_(next, armc.package_manager.hook, exception=StopIteration)
with h5py.File(hdf5, 'r') as f1, h5py.File(hdf5_ref, 'r') as f2:
compare_hdf5(f1, f2, skip={'/param', '/aux_error_mod'})
assertion.shape_eq(f1['param'], f2['param'])
assertion.shape_eq(f1['aux_error_mod'], f2['aux_error_mod'])
assertion.eq(f1['param'].dtype, f2['param'].dtype)
assertion.eq(f1['aux_error_mod'].dtype, f2['aux_error_mod'].dtype)
# Validate that the non-charges are updated independently of each other
with h5py.File(hdf5, 'r') as f1:
_index = f1['param'].attrs['index'][0] != b"charge"
index = np.nonzero(_index)[0]
param = f1['param'][..., index]
grad = param[:, 1:] - param[:, :-1]
grad[grad < 1e-8] = 0
assertion.le(np.count_nonzero(grad, axis=-1), 2, post_process=np.all)
def test_get_pairs_closest() -> None:
"""Tests for :meth:`MolDissociater.get_pairs_closest`."""
dissociate = MolDissociater(MOL, CORE_IDX, ligand_count=2)
pair1 = dissociate.get_pairs_closest(LIG_IDX, n_pairs=1)
pair2 = dissociate.get_pairs_closest(LIG_IDX, n_pairs=2)
pair3 = dissociate.get_pairs_closest(LIG_IDX, n_pairs=3)
dissociate.ligand_count = 4
pair4 = dissociate.get_pairs_closest(LIG_IDX, n_pairs=1)
pair5 = dissociate.get_pairs_closest(LIG_IDX, n_pairs=2)
pair6 = dissociate.get_pairs_closest(LIG_IDX, n_pairs=3)
assertion.assert_(dissociate.get_pairs_closest,
LIG_IDX,
0,
exception=ValueError)
pairs = (pair1, pair2, pair3, pair4, pair5, pair6)
for i, pair in enumerate(pairs, 1):
ref = np.load(PATH / f'get_pairs_closest_{i}.npy')
np.testing.assert_array_equal(pair, ref)
def test_get_pairs_distance() -> None:
"""Tests for :meth:`MolDissociater.get_pairs_distance`."""
dissociate = MolDissociater(MOL, CORE_IDX, ligand_count=2)
pair1 = dissociate.get_pairs_distance(LIG_IDX, max_dist=5.0)
pair2 = dissociate.get_pairs_distance(LIG_IDX, max_dist=7.5)
dissociate.ligand_count = 4
pair3 = dissociate.get_pairs_distance(LIG_IDX, max_dist=7.5)
pair4 = dissociate.get_pairs_distance(LIG_IDX, max_dist=10.0)
assertion.assert_(dissociate.get_pairs_distance,
LIG_IDX,
0,
exception=ValueError)
assertion.assert_(dissociate.get_pairs_distance,
LIG_IDX,
1.0,
exception=MoleculeError)
dissociate.ligand_count = 99
assertion.assert_(dissociate.get_pairs_distance,
LIG_IDX,
5.0,
exception=MoleculeError)
pairs = (pair1, pair2, pair3, pair4)
for i, pair in enumerate(pairs, 1):
ref = np.load(PATH / f'get_pairs_distance_{i}.npy')
np.testing.assert_array_equal(pair, ref)
def test_split_dict() -> None:
"""Test :func:`nanoutils.split_dict`."""
dct1 = {1: 1, 2: 2, 3: 3, 4: 4, 5: 5}
dct2 = dct1.copy()
dct3 = dct1.copy()
dct4 = dct1.copy()
dct5 = dct1.copy()
dct6 = dct1.copy()
dct7 = dct1.copy()
dct8 = dct1.copy()
ref1 = {1: 1, 2: 2}
ref2 = {3: 3, 4: 4, 5: 5}
split_dict(dct1, keep_keys=[1, 2])
split_dict(dct2, keep_keys={1, 2})
split_dict(dct3, keep_keys=iter({1, 2}))
split_dict(dct4, keep_keys=[1, 2], preserve_order=True)
assertion.eq(dct1, ref1)
assertion.eq(dct2, ref1)
assertion.eq(dct3, ref1)
assertion.eq(dct4, ref1)
if sys.version_info[1] > 6:
assertion.eq(list(dct4.keys()), [1, 2])
split_dict(dct5, disgard_keys=[1, 2])
split_dict(dct6, disgard_keys={1, 2})
split_dict(dct7, disgard_keys=iter({1, 2}))
split_dict(dct8, disgard_keys=[1, 2], preserve_order=True)
assertion.eq(dct5, ref2)
assertion.eq(dct6, ref2)
assertion.eq(dct7, ref2)
assertion.eq(dct8, ref2)
if sys.version_info[1] > 6:
assertion.eq(list(dct8.keys()), [3, 4, 5])
assertion.assert_(split_dict, {}, exception=TypeError)
assertion.assert_(split_dict, {}, keep_keys=[], disgard_keys=[], exception=TypeError)
def test_armc_restart(name: str) -> None:
"""Test the restart functionality of :class:`ARMC` and :class:`ARMCPT`."""
file = PATH / name
with open(file, 'r') as f:
dct = yaml.load(f.read(), Loader=UniqueLoader)
sub_iter = 5
super_iter = 8
i = 2 + (super_iter * 10 + sub_iter)
armc, job_kwargs = dict_to_armc(dct)
if name == 'armc_ref.yaml':
REF = ARMC_REF
armc.package_manager.hook = iter(load_results(ARMC_REF, n=1)[i:])
else:
iterator = _get_phi_iter()
def swap_phi(*args: Any, **kwargs: Any) -> List[Tuple[int, int]]:
return next(iterator)
REF = ARMCPT_REF
armc.swap_phi = swap_phi
armc.package_manager.hook = iter(load_results(ARMCPT_REF, n=3)[i:])
_prepare_restart(REF, PATH / job_kwargs['folder'], super_iter, sub_iter)
hdf5_ref = REF / 'armc.hdf5'
hdf5 = PATH / job_kwargs['folder'] / 'armc.hdf5'
run_armc(armc, restart=True, **job_kwargs)
assertion.assert_(next, armc.package_manager.hook, exception=StopIteration)
with h5py.File(hdf5, 'r') as f1, h5py.File(hdf5_ref, 'r') as f2:
compare_hdf5(f1, f2, skip={'/param', '/aux_error_mod'})
assertion.shape_eq(f1['param'], f2['param'])
assertion.shape_eq(f1['aux_error_mod'], f2['aux_error_mod'])
assertion.eq(f1['param'].dtype, f2['param'].dtype)
assertion.eq(f1['aux_error_mod'].dtype, f2['aux_error_mod'].dtype)
def test_get_exc_message() -> None:
"""Test :meth:`AssertionManager._get_exc_message`."""
ex = TypeError("object of type 'int' has no len()")
func1 = len
args = (1,)
str1: str = assertion._get_exc_message(ex, func1, *args, invert=False, output=None) # type: ignore[attr-defined] # noqa: E501
str2: str = assertion._get_exc_message(ex, func1, *args, invert=True, output=None) # type: ignore[attr-defined] # noqa: E501
ref1 = """output = len(obj); assert output
exception: TypeError = "object of type 'int' has no len()"
output: NoneType = None
obj: int = 1"""
ref2 = """output = not len(obj); assert output
exception: TypeError = "object of type 'int' has no len()"
output: NoneType = None
obj: int = 1"""
assertion.eq(str1, ref1)
assertion.eq(str2, ref2)
func2: Callable = assertion._get_exc_message # type: ignore[attr-defined]
assertion.assert_(func2, ex, 1, exception=TypeError)
func3 = partial(len)
str3 = assertion._get_exc_message(ex, func3) # type: ignore[attr-defined]
assertion.contains(str3, 'functools.partial(<built-in function len>)')
class Func():
def __call__(self): pass
str4: str = assertion._get_exc_message(ex, Func()) # type: ignore[attr-defined]
assertion.contains(str4, 'output = func(); assert output')
def test_version_info() -> None:
"""Tests for :func:`nanoutils.VersionInfo`."""
tup1 = VersionInfo(0, 1, 2)
tup2 = VersionInfo.from_str('0.1.2')
assertion.eq(tup1, (0, 1, 2))
assertion.eq(tup2, (0, 1, 2))
assertion.eq(tup1.micro, tup1.patch)
assertion.assert_(VersionInfo.from_str, b'0.1.2', exception=TypeError)
assertion.assert_(VersionInfo.from_str, '0.1.2a', exception=ValueError)
assertion.assert_(VersionInfo.from_str, '0.1.2.3.4', exception=ValueError)
assertion.isinstance(version_info, VersionInfo)
def test_validate_unit() -> None:
"""Tests for :func:`_validate_unit`."""
columns = ['1', '2']
# Valid inputs
unit_iter1 = ['a', 'b']
unit_iter2 = repeat('a')
assertion.assert_(_validate_unit, unit_iter1, columns, invert=True)
assertion.assert_(_validate_unit, unit_iter2, columns, invert=True)
# *unit_iter3* is too short; should raise a LengthError
unit_iter3 = ['a']
assertion.assert_(_validate_unit,
unit_iter3,
columns,
exception=LengthError)
def test_allow_non_existent() -> None:
"""Test ``param.validation.allow_non_existent``."""
file = PATH / 'armc_ref.yaml'
with open(file, 'r') as f:
dct = yaml.load(f.read(), Loader=UniqueLoader)
# Test `param.validation.allow_non_existent`
dct['param']['charge']['Cl'] = -1
assertion.assert_(dict_to_armc, dct, exception=RuntimeError)
del dct['psf']
del dct['param']['charge']['constraints'][0]
assertion.assert_(dict_to_armc, dct, exception=RuntimeError)
with warnings.catch_warnings():
warnings.simplefilter("ignore", RuntimeWarning)
dct['param']['validation']['allow_non_existent'] = True
dct['param']['validation']['charge_tolerance'] = 'inf'
assertion.assert_(dict_to_armc, dct)
def test_enforce_constraints() -> None:
"""Test ``param.validation.enforce_constraints``."""
file = PATH / 'armc_ref.yaml'
with open(file, 'r') as f:
dct = yaml.load(f.read(), Loader=UniqueLoader)
dct['param']['validation']['enforce_constraints'] = True
dct['param']['validation']['charge_tolerance'] = 'inf'
dct['param']['charge']['CG2O3'] = 10
assertion.assert_(dict_to_armc, dct, exception=RuntimeError)
dct['param']['charge']['CG2O3'] = -10
assertion.assert_(dict_to_armc, dct, exception=RuntimeError)
dct['param']['charge']['CG2O3'] = 0.4524
dct['param']['charge']['Cd'] = 2
assertion.assert_(dict_to_armc, dct, exception=RuntimeError)
with pytest.warns(RuntimeWarning):
dct['param']['validation']['enforce_constraints'] = False
_ = dict_to_armc(dct)
def test_sparse_bond_matrix():
"""Test :func:`sparse_bond_matrix`."""
ref1 = np.load(PATH / 'sparse_bond_matrix.npy')
ref2 = ref1.astype(int)
ref3 = ref1.astype(bool)
mat1 = sparse_bond_matrix(MOL, dtype=float)
mat2 = sparse_bond_matrix(MOL, dtype=int)
mat3 = sparse_bond_matrix(MOL)
np.testing.assert_array_equal(mat1.toarray(), ref1)
np.testing.assert_array_equal(mat2.toarray(), ref2)
np.testing.assert_array_equal(mat3.toarray(), ref3)
sparse_type_tup = (bsr_matrix, coo_matrix, csr_matrix, csc_matrix,
dia_matrix, dok_matrix, lil_matrix)
with warnings.catch_warnings():
warnings.simplefilter('ignore',
category=np.VisibleDeprecationWarning())
for sparse_type in sparse_type_tup:
mat_n = sparse_bond_matrix(MOL, sparse_type=sparse_type)
np.testing.assert_array_equal(mat_n.toarray(), ref3)
assertion.assert_(sparse_bond_matrix,
MOL,
dtype='bob',
exception=TypeError)
assertion.assert_(sparse_bond_matrix,
MOL,
sparse_type='bob',
exception=TypeError)
assertion.assert_(sparse_bond_matrix,
MOL,
sparse_type=int,
exception=TypeError)
def test_none_exception() -> None:
"""Test :class:`_NoneException`."""
assertion.assert_(_NoneException, exception=TypeError)
assertion.issubclass(_NoneException, Exception, invert=True)
def test_coordination_number() -> None:
"""Tests for :func:`nanoCAT.recipes.coordination_number`."""
out_inner = coordination_number(MOL, shell='inner')
out_outer = coordination_number(MOL, shell='outer', d_outer=5.2)
ref_inner = {
'Cd': {
3: [
30, 31, 34, 35, 36, 46, 47, 52, 53, 54, 57, 58, 59, 60, 63, 64,
65, 67, 69, 70, 71, 75, 78, 79
],
4: [
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 32, 33,
37, 38, 39, 40, 41, 42, 43, 44, 45, 48, 49, 50, 51, 55, 56, 61,
62, 66, 68, 72, 73, 74, 76, 77, 80, 81
]
},
'Se': {
3: [
82, 84, 87, 88, 90, 91, 92, 95, 96, 97, 99, 100, 101, 102, 103,
106, 107, 108, 118, 119, 120, 121, 122, 123
],
4: [
17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 83, 85, 86,
89, 93, 94, 98, 104, 105, 109, 110, 111, 112, 113, 114, 115,
116, 117
]
},
'Cl': {
2: [
124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
148, 149
]
}
}
ref_outer = {
'Cd': {
6: [33, 59, 65, 66],
7: [5, 6, 8, 13, 39, 77],
8: [
30, 31, 32, 34, 35, 36, 46, 47, 52, 53, 54, 57, 58, 60, 63, 64,
67, 69, 70, 71, 75, 78, 79, 81
],
9: [4, 11, 40, 41, 48, 49, 50, 51, 55, 73, 76, 80],
10: [7, 10, 12, 15, 42, 44, 45, 56],
11: [2, 16, 43, 68],
12: [1, 3, 9, 14, 37, 38, 61, 62, 72, 74]
},
'Se': {
6: [102, 121],
7: [84, 87, 97, 99, 103, 106, 108, 118],
8: [88, 90, 91, 92, 95, 96, 100, 101, 107, 119, 120, 122],
9: [82, 104, 115, 123],
10: [98, 109, 110],
11: [86, 105],
12: [20, 22, 27, 28, 83, 113, 114],
13: [18, 19, 24, 26, 85, 117],
14: [17, 21, 25, 29, 89, 93, 94, 111, 112, 116],
16: [23]
},
'Cl': {
7: [124, 128],
9: [127, 132, 133, 136, 144, 148],
10: [
125, 126, 129, 130, 131, 134, 135, 137, 138, 139, 140, 141,
142, 143, 145, 146, 147, 149
]
}
}
np.testing.assert_equal(out_inner, ref_inner)
np.testing.assert_equal(out_outer, ref_outer)
assertion.assert_(coordination_number,
MOL,
shell='bob',
exception=ValueError)
assertion.assert_(coordination_number,
MOL,
shell='outer',
d_outer=None,
exception=TypeError)
def test_map_psf_atoms() -> None:
"""Tests for :func:`map_psf_atoms`."""
ref = {
'C331': 'C',
'C321': 'C',
'C2O3': 'C',
'O2D2': 'O',
'HGA2': 'H',
'HGA3': 'H'
}
path_like = PATH_MOLECULES / 'mol.psf'
file_like = StringIO(PSF_STR)
assertion.eq(map_psf_atoms(path_like), ref)
assertion.eq(map_psf_atoms(file_like), ref)
# Incorrect input types
assertion.assert_(map_psf_atoms, None, exception=TypeError)
assertion.assert_(map_psf_atoms, {1: 1}, exception=TypeError)
assertion.assert_(map_psf_atoms, 'bob.psf', exception=FileNotFoundError)
# Incorrect mode (bytes)
file_bytes = BytesIO(PSF_STR.encode())
assertion.assert_(map_psf_atoms,
file_bytes,
mode='rb',
exception=TypeError)
# The !NATOM will now be missing
file_wrong1 = StringIO(PSF_STR[24:])
assertion.assert_(map_psf_atoms, file_wrong1, exception=ValueError)
# Rows [5:] will now be missing
file_wrong2 = StringIO('\n'.join(i[:25] for i in PSF_STR.splitlines()))
assertion.assert_(map_psf_atoms, file_wrong2, exception=ValueError)
def test_construct_df() -> None:
"""Tests for :func:`_construct_df`."""
dict1 = {'Cs': (1, 1), 'Cd': (2, 2), 'O': (3, 3), 'H': (4, 4)}
dict2 = {'Cs': 1, 'Cd': 2, 'O': 3, 'H': 4}
dict3 = {'Cs': 1, 'Cd': 2, 'O': (3, 3), 'H': (4, 4)}
dict4 = {k: set(v) for k, v in dict1.items()}
c1 = ['a', 'b']
c2 = 'a'
ref1 = np.array([v for v in dict1.values()], dtype=str).astype(object)
ref2 = np.array([v for v in dict2.values()],
dtype=str).astype(object)[..., None]
np.testing.assert_array_equal(_construct_df(c1, dict1), ref1)
np.testing.assert_array_equal(_construct_df(c2, dict2), ref2)
# No mixing of scalars and sequences allowed
assertion.assert_(_construct_df, c1, dict2, exception=TypeError)
assertion.assert_(_construct_df, c2, dict1, exception=TypeError)
assertion.assert_(_construct_df, c1, dict3, exception=TypeError)
assertion.assert_(_construct_df, c1, dict3, exception=TypeError)
# The dict values are now either too long or too short
assertion.assert_(_construct_df, [c2], dict1, exception=LengthError)
assertion.assert_(_construct_df, [c2, c2, c2],
dict1,
exception=LengthError)
# Collections (e.g. a set) are not allowed as dictionary values; requires a proper Sequence
assertion.assert_(_construct_df, c1, dict4, exception=TypeError)
