def test_int_creation(self):
"""
Test that strings of ints are recreated as ints
"""
obj = recursive_make_object('5', self.class_dictionary)
self.assertEqual(obj, 5)
self.assertEqual(type(obj), int)
def test_float_creation(self):
"""
Test that strings of floats are recreated as floats
"""
obj = recursive_make_object('5.0', self.class_dictionary)
self.assertEqual(obj, 5.0)
self.assertEqual(type(obj), float)
def test_make_object_from_dict(self):
"""
Test that RMGObjects can be recreated from their dictionary representation
"""
created_from_function = recursive_make_object(
self.highly_nest_dictionary, self.class_dictionary)
created_from_object = PseudoRMGObject.__new__(PseudoRMGObject)
created_from_object.make_object(self.highly_nest_dictionary,
self.class_dictionary)
orig_obj = self.highly_nested_object
for obj in (created_from_function, created_from_object):
self.assertEqual(orig_obj.b, obj.b)
self.assertEqual(type(orig_obj.a), type(obj.a))
self.assertEqual(type(orig_obj.a.a), type(obj.a.a))
self.assertTrue(np.array_equal(orig_obj.a.a.b, obj.a.a.b))
self.assertEqual(type(orig_obj.a.a.c), type(obj.a.a.c))
self.assertEqual(orig_obj.a.a.c.c.units, obj.a.a.c.c.units)
self.assertTrue(
np.array_equal(orig_obj.a.a.c.c.value, obj.a.a.c.c.value))
self.assertEqual(type(orig_obj.a.a.c.d), type(obj.a.a.c.d))
self.assertEqual(orig_obj.a.a.c.d.a.units, obj.a.a.c.d.a.units)
self.assertTrue(orig_obj.a.a.c.d.a.value, obj.a.a.c.d.a.value)
self.assertEqual(type(orig_obj.a.a.c.d.b),
type(orig_obj.a.a.c.d.b))
def test_np_array_creation(self):
"""
Test that numpy arrays can be recreated from their dictionary representation
"""
self.assertTrue(
np.array_equal(
recursive_make_object(self.np_dict, self.class_dictionary),
self.np_array))
def test_make_all_but_final_object_from_dict(self):
"""
Test the `make_final_object=False` option for the recursive_make_object function
"""
final_obj_dict = recursive_make_object(self.input_dict,
self.class_dictionary,
make_final_object=False)
self.assertTrue(
np.array_equal(final_obj_dict['a'].b, self.final_obj_dict['a'].b))
def test_hashable_class_key_creation(self):
"""
Test that dictionaries with hashable class instances as keys can be recreated
"""
@dataclass(frozen=True)
class Data:
arg: str
input_dict = {"Data(arg='test')": 'test'}
class_dictionary = {'Data': Data}
key, val = list(
recursive_make_object(input_dict, class_dictionary).items())[0]
self.assertIsInstance(key, Data)
self.assertEqual(key, Data('test'))
self.assertEqual(val, 'test')
from arkane.encorr.reference import ReferenceSpecies, ReferenceDatabase
from arkane.exceptions import BondAdditivityCorrectionError
from arkane.modelchem import LevelOfTheory, CompositeLevelOfTheory
# ######## Database loading ##########
quantum_corrections_path = os.path.join(settings['database.directory'],
'quantum_corrections', 'data.py')
spec = importlib.util.spec_from_file_location("quantum_calculations",
quantum_corrections_path)
data = importlib.util.module_from_spec(spec)
spec.loader.exec_module(data)
# Convert module to dictionary and create level of theory objects from their string representations
data_dict = recursive_make_object(
{k: v
for k, v in vars(data).items() if not k.startswith('__')}, {
'LevelOfTheory': LevelOfTheory,
'CompositeLevelOfTheory': CompositeLevelOfTheory
})
# Assign the data here so that it can be imported
for k, v in data_dict.items():
vars()[k] = v
######################################
# ########## Data classes ############
BOND_SYMBOLS = {1: '-', 2: '=', 3: '#'}
class Molecule(RMGMolecule):
"""Wrapper for RMG Molecule to add ID attribute"""
def __init__(self, *args, mol_id=None, **kwargs):
