num_repeating_units=num_repeating_units,
), )
self.num_new_atoms = num_new_atoms
self.num_new_bonds = num_new_bonds
self.num_building_blocks = {
building_blocks[index]: num
for index, num in num_building_blocks.items()
}
self.building_blocks = building_blocks
@pytest.fixture(
scope='session',
params=(lambda: LinearData(
building_blocks=(
stk.BuildingBlock('BrC#CBr', [stk.BromoFactory()]),
stk.BuildingBlock(
smiles='Br[C+]=NC#CBr',
functional_groups=[stk.BromoFactory()],
),
),
repeating_unit='AB',
num_repeating_units=2,
num_new_atoms=0,
num_new_bonds=3,
num_building_blocks={
0: 2,
1: 2
},
), ),
)
import pytest
import numpy as np
import stk
from ....case_data import CaseData
vertices = stk.cof.vertices
@pytest.fixture(
params=(CaseData(
vertex=vertices._UnaligningVertex(vertex=vertices._CofVertex(
0, (1, 2, 3)), ),
edges=(),
building_block=stk.BuildingBlock(
smiles='[Fe]',
position_matrix=([0, 0, 0], ),
),
position=np.array([1, 2, 3], dtype=np.float64),
alignment_tests={},
functional_group_edges={},
), ), )
def unaligning(request):
return request.param
import stk
import pytest
from ...case_data import CaseData
@pytest.fixture(
scope='session',
params=(
lambda name: CaseData(
molecule=stk.ConstructedMolecule(topology_graph=stk.polymer.Linear(
building_blocks=(
stk.BuildingBlock(
smiles='BrC1=C(Br)[C+]=N1',
functional_groups=[stk.BromoFactory()],
),
stk.BuildingBlock(
smiles='Br[C+]=NC#CBr',
functional_groups=[stk.BromoFactory()],
),
),
repeating_unit='AB',
num_repeating_units=2), ),
smiles='BrC#CN=[C+]C1=C(C#CN=[C+]C2=C(Br)N=[C+]2)N=[C+]1',
name=name,
),
lambda name: CaseData(
molecule=stk.ConstructedMolecule(topology_graph=stk.polymer.Linear(
building_blocks=(
stk.BuildingBlock(
smiles='BrC1=C(Br)[C+]=N1',
import pytest
import stk
from .case_data import CaseData
@pytest.fixture(
params=(lambda: CaseData(
molecule=stk.BuildingBlock('NCCN'),
atoms=(
stk.N(0),
stk.C(1),
stk.C(2),
stk.N(3),
stk.H(4),
stk.H(5),
stk.H(6),
stk.H(7),
stk.H(8),
stk.H(9),
stk.H(10),
stk.H(11),
),
), ), )
def case_data(request) -> CaseData:
"""
A :class:`.CaseData` instance.
"""
return request.param()
import pytest
import stk
from .case_data import CaseData
@pytest.fixture(
params=(CaseData(molecule=stk.BuildingBlock('NCCN'), num_bonds=11), ), )
def case_data(request):
"""
A :class:`.CaseData` instance.
"""
return request.param
def test_update_3():
"""
Test that existing entries are updated.
In this test, your first create one entry with two keys. Then
update the entry with databases, each using 1 different key.
No duplicate entries should be made in the database this way.
"""
database_name = '_test_update_3'
client = pymongo.MongoClient()
client.drop_database(database_name)
jsonizer1 = stk.ConstructedMoleculeJsonizer(key_makers=(
stk.InchiKey(),
stk.Smiles(),
), )
database1 = stk.ConstructedMoleculeMongoDb(
mongo_client=client,
database=database_name,
put_lru_cache_size=0,
get_lru_cache_size=0,
jsonizer=jsonizer1,
)
jsonizer2 = stk.ConstructedMoleculeJsonizer(
key_makers=(stk.InchiKey(), ), )
database2 = stk.ConstructedMoleculeMongoDb(
mongo_client=client,
database=database_name,
put_lru_cache_size=0,
get_lru_cache_size=0,
jsonizer=jsonizer2,
)
jsonizer3 = stk.ConstructedMoleculeJsonizer(key_makers=(stk.Smiles(), ), )
database3 = stk.ConstructedMoleculeMongoDb(
mongo_client=client,
database=database_name,
put_lru_cache_size=0,
get_lru_cache_size=0,
jsonizer=jsonizer3,
)
molecule = stk.BuildingBlock(
smiles='BrCCCBr',
functional_groups=[stk.BromoFactory()],
).with_canonical_atom_ordering()
polymer1 = stk.ConstructedMolecule(
topology_graph=stk.polymer.Linear(
# Use it as a building block twice, to make sure it is
# not repeatedly added to the molecules database.
building_blocks=(molecule, molecule),
repeating_unit='AB',
num_repeating_units=2,
), ).with_canonical_atom_ordering()
json1 = jsonizer1.to_json(polymer1)
database1.put(polymer1)
assert_database_state(
state1=get_database_state(database1),
state2=DatabaseState({
DatabaseEntry(**json1['molecule']):
1,
DatabaseEntry(**to_hashable_matrix(json1['matrix'])):
1,
DatabaseEntry(**json1['buildingBlocks'][0]['molecule']):
1,
DatabaseEntry(**to_hashable_matrix(json=json1['buildingBlocks'][0]['matrix'], )):
1,
DatabaseEntry(**to_hashable_constructed_molecule(json=json1['constructedMolecule'], )):
1,
}),
)
# Should update the entry.
polymer2 = polymer1.with_position_matrix(position_matrix=np.zeros(
(polymer1.get_num_atoms(), 3)), )
json2 = jsonizer2.to_json(polymer2)
json2['matrix'] = dict(json1['matrix'])
json2['matrix']['m'] = jsonizer2.to_json(polymer2)['matrix']['m']
database2.put(polymer2)
assert_database_state(
state1=get_database_state(database1),
state2=DatabaseState({
DatabaseEntry(**json1['molecule']):
1,
DatabaseEntry(**to_hashable_matrix(json2['matrix'])):
1,
DatabaseEntry(**json1['buildingBlocks'][0]['molecule']):
1,
DatabaseEntry(**to_hashable_matrix(json=json1['buildingBlocks'][0]['matrix'], )):
1,
DatabaseEntry(**to_hashable_constructed_molecule(json=json1['constructedMolecule'], )):
1,
}),
)
# Should also update the entry.
polymer3 = polymer1.with_position_matrix(position_matrix=np.zeros(
(polymer1.get_num_atoms(), 3)), )
json3 = jsonizer3.to_json(polymer3)
json3['matrix'] = dict(json1['matrix'])
json3['matrix']['m'] = jsonizer3.to_json(polymer3)['matrix']['m']
database3.put(polymer3)
assert_database_state(
state1=get_database_state(database1),
state2=DatabaseState({
DatabaseEntry(**json1['molecule']):
1,
DatabaseEntry(**to_hashable_matrix(json3['matrix'])):
1,
DatabaseEntry(**json1['buildingBlocks'][0]['molecule']):
1,
DatabaseEntry(**to_hashable_matrix(json=json1['buildingBlocks'][0]['matrix'], )):
1,
DatabaseEntry(**to_hashable_constructed_molecule(json=json1['constructedMolecule'], )):
1,
}),
)
import stk
from ..case_data import CaseData
@pytest.fixture(
scope='session',
params=(lambda: CaseData(
fitness_calculator=stk.PropertyVector(property_functions=(
stk.Molecule.get_num_atoms,
stk.Molecule.get_num_bonds,
stk.Molecule.get_maximum_diameter,
), ),
molecule=stk.BuildingBlock('BrCCBr').with_position_matrix(
position_matrix=np.array([
[0, 0, 0],
[10, 0, 0],
[0, 0, 0],
[0, 0, 0],
[0, 0, 0],
[0, 0, 0],
[0, 0, 0],
[0, 0, 0],
],
dtype=np.float64), ),
fitness_value=(8, 7, 10),
), ),
)
def property_vector(request) -> CaseData:
return request.param()
import pytest
import numpy as np
import stk
from .case_data import CaseData
bb1 = stk.BuildingBlock('[C+2][N+]Br', [stk.BromoFactory()])
bb2 = stk.BuildingBlock('IS[O+]', [stk.IodoFactory()])
@pytest.fixture(
params=(
CaseData(
molecule=stk.BuildingBlock(
smiles='Br[C+2][N+]Cl',
functional_groups=[stk.BromoFactory()],
placer_ids=(0, ),
),
result=stk.BuildingBlock.init(
atoms=(
stk.Cl(0),
stk.Br(1),
stk.C(2, 2),
stk.N(3, 1),
),
bonds=(
stk.Bond(stk.Cl(0), stk.N(3, 1), 1),
stk.Bond(stk.Br(1), stk.C(2, 2), 1),
stk.Bond(stk.C(2, 2), stk.N(3, 1), 1),
),
position_matrix=np.array([
from ..case_data import CaseData
def get_eight_plus_twelve(graph):
return stk.cage.EightPlusTwelve(graph.get_building_blocks())
@pytest.fixture(
scope='session',
params=(lambda: CaseData(
mutator=stk.RandomTopologyGraph(replacement_funcs=(
get_eight_plus_twelve, ), ),
record=stk.MoleculeRecord(topology_graph=stk.cage.FourPlusSix(
building_blocks=(
stk.BuildingBlock(
smiles='BrCCBr',
functional_groups=[stk.BromoFactory()],
),
stk.BuildingBlock(
smiles='BrCC(CBr)CBr',
functional_groups=[stk.BromoFactory()],
),
), ), ),
mutation_record=stk.MutationRecord(
molecule_record=stk.MoleculeRecord(
topology_graph=stk.cage.EightPlusTwelve(building_blocks=(
stk.BuildingBlock(
smiles='BrCCBr',
functional_groups=[stk.BromoFactory()],
),
stk.BuildingBlock(
smiles='BrCC(CBr)CBr',
self.num_new_atoms = num_new_atoms
self.num_new_bonds = num_new_bonds
self.num_building_blocks = {
building_blocks[index]: num
for index, num in num_building_blocks.items()
}
self.building_blocks = building_blocks
@pytest.fixture(
params=(
CofData(
topology_graph=stk.cof.Honeycomb,
building_blocks=(
stk.BuildingBlock(
smiles=('Br[C+]1[C+2][C+](Br)[C+](F)[C+](Br)[C+2]1'),
functional_groups=[stk.BromoFactory()],
),
stk.BuildingBlock(
smiles='Br[C+]=NC#CBr',
functional_groups=[stk.BromoFactory()],
),
),
lattice_size=(2, 2, 1),
vertex_alignments=None,
num_new_atoms=0,
num_new_bonds=20,
num_building_blocks={
0: 8,
1: 12
},
),
import pytest
import stk
from ...case_data import CaseData
@pytest.fixture(
params=(
CaseData(
molecule=stk.ConstructedMolecule(
topology_graph=stk.cof.LinkerlessHoneycomb(
building_blocks=(
stk.BuildingBlock(
smiles=(
'Br[C+]1C2[C+]=NC2(Br)[C+](F)[C+](Br)'
'[C+2]1'
),
functional_groups=[stk.BromoFactory()],
),
),
lattice_size=(2, 2, 1),
),
),
smiles=(
'[H]C12[C+]=NC1(Br)[C+](F)[C+](Br)[C+2][C+]2[C+]1[C+2]'
'[C+]2[C+]3[C+2][C+]([C+]4[C+2][C+](Br)[C+](F)C5(N=[C+'
']C45[H])C45N=[C+]C4([H])[C+]([C+]4[C+2][C+](Br)[C+](F'
')C6(Br)N=[C+]C46[H])[C+2][C+]([C+]4[C+2][C+]([C+]6[C+'
'2][C+](Br)[C+](F)C7(N=[C+]C67[H])C6(N=[C+]C16[H])[C+]'
'2F)C1([H])[C+]=NC1(Br)[C+]4F)[C+]5F)C1([H])[C+]=NC1(B'
'r)[C+]3F'
from ..case_data import CaseData
@pytest.fixture(
params=(
CaseData(
database=stk.ConstructedMoleculeMongoDb(
mongo_client=pymongo.MongoClient(),
database='_stk_test_database_for_testing',
put_lru_cache_size=0,
get_lru_cache_size=0,
),
molecule=stk.ConstructedMolecule(topology_graph=stk.polymer.Linear(
building_blocks=(stk.BuildingBlock(
smiles='BrCCBr',
functional_groups=[stk.BromoFactory()],
), ),
repeating_unit='A',
num_repeating_units=2,
), ),
key={
'InChIKey':
rdkit.MolToInchiKey(rdkit.MolFromSmiles(SMILES='BrCCCCBr')),
},
),
CaseData(
database=stk.ConstructedMoleculeMongoDb(
mongo_client=pymongo.MongoClient(),
database='_stk_test_database_for_testing',
put_lru_cache_size=128,
get_lru_cache_size=128,
import pytest
import stk
from ...case_data import CaseData
@pytest.fixture(
params=(
CaseData(
molecule=stk.ConstructedMolecule(
topology_graph=stk.cof.Square(
building_blocks=(
stk.BuildingBlock(
smiles='BrC1=C(Br)[C+]=N1',
functional_groups=[stk.BromoFactory()],
),
stk.BuildingBlock(
smiles='BrC1=C(Br)C(F)(Br)[C+]1Br',
functional_groups=[stk.BromoFactory()],
),
),
lattice_size=(2, 2, 1),
),
),
smiles=(
'FC1(Br)C2=C(C3=C([C+]=N3)C3(F)C(=C(C4=C(Br)[C+]=N4)[C'
'+]3Br)C3=C([C+]=N3)[C+]3C(C4=C(Br)[C+]=N4)=C(C4=C(Br)'
'[C+]=N4)C3(F)C3=C(N=[C+]3)C3=C(C4=C(Br)[C+]=N4)C(F)(B'
'r)[C+]3C3=C2N=[C+]3)[C+]1Br'
),
),
import pytest
import numpy as np
import stk
from ....case_data import CaseData
@pytest.fixture(
params=(lambda: CaseData(
vertex=stk.host_guest.HostVertex(
id=0,
position=(1, 2, 3),
),
edges=(),
building_block=stk.BuildingBlock('NCCN'),
position=np.array([1, 2, 3], dtype=np.float64),
alignment_tests={},
functional_group_edges={},
), ), )
def host(request) -> CaseData:
return request.param()
import pytest
import stk
from .case_data import CaseData
@pytest.fixture(
params=(
lambda: CaseData(molecule=stk.BuildingBlock('NCCN'), num_bonds=11), ),
)
def case_data(request) -> CaseData:
"""
A :class:`.CaseData` instance.
"""
return request.param()
import pytest
import stk
from ....case_data import CaseData
@pytest.fixture(
params=(CaseData(
molecule=stk.ConstructedMolecule(topology_graph=stk.cage.OnePlusOne(
building_blocks=(stk.BuildingBlock(
smiles=('Br[C+]1[C+2][C+](Br)[C+]2[C+](F)[C+2]'
'C2(Br)[C+2]1'),
functional_groups=[stk.BromoFactory()],
), ), ), ),
smiles=('F[C+]1[C+2]C23[C+2][C+]4[C+2][C+]([C+]12)C12[C+2][C+]'
'(F)[C+]1[C+]3[C+2][C+]4[C+2]2'),
), ), )
def cage_one_plus_one(request):
return request.param
params=(
stk.Bond(stk.C(0), stk.N(1), 1),
),
)
def bond(request):
"""
A :class:`.Bond` instance.
"""
return request.param
@pytest.fixture(
params=(
stk.BuildingBlock('NCCN'),
None,
),
)
def building_block(request):
"""
A valid building block for a :class:`.BondInfo`.
"""
return request.param
@pytest.fixture(
params=(
1,
functional_groups=(),
),
stk.BuildingBlock.init(
atoms=(stk.C(0, 2), stk.H(1), stk.H(2)),
bonds=(
stk.Bond(stk.C(0, 2), stk.H(1), 1),
stk.Bond(stk.C(0, 2), stk.H(2), 1),
),
position_matrix=np.array([
[-0.002271396061231665, 0.034037398527897535, -0.0],
[-1.0494595365731274, -0.017073891221884126, -0.0],
[1.0517309326343591, -0.016963507306017023, 0.0],
]),
functional_groups=(),
),
stk.BuildingBlock('NCCN'),
stk.BuildingBlock(
'C(#Cc1cccc2ccncc21)c1ccc2[nH]c3ccc'
'(C#Cc4cccc5cnccc54)cc3c2c1'
),
stk.BuildingBlock(
'C(#Cc1cccc2cnccc12)c1ccc2[nH]c3ccc'
'(C#Cc4cccc5ccncc45)cc3c2c1'
),
stk.BuildingBlock('N[C+][C+2]N'),
stk.BuildingBlock('NCCN', [stk.PrimaryAminoFactory()]),
stk.ConstructedMolecule(
topology_graph=stk.polymer.Linear(
building_blocks=(
stk.BuildingBlock('BrCCBr', [stk.BromoFactory()]),
stk.BuildingBlock(
def test_update_1():
"""
Test that existing entries are updated.
"""
database_name = '_test_update_1'
client = pymongo.MongoClient()
client.drop_database(database_name)
database = stk.ConstructedMoleculeMongoDb(
mongo_client=client,
database=database_name,
put_lru_cache_size=0,
get_lru_cache_size=0,
)
jsonizer = stk.ConstructedMoleculeJsonizer()
molecule = stk.BuildingBlock(
smiles='BrCCBr',
functional_groups=[stk.BromoFactory()],
).with_canonical_atom_ordering()
polymer = stk.ConstructedMolecule(
topology_graph=stk.polymer.Linear(
# Use it as a building block twice, to make sure it is
# not repeatedly added to the molecules database.
building_blocks=(molecule, molecule),
repeating_unit='AB',
num_repeating_units=2,
), ).with_canonical_atom_ordering()
json = jsonizer.to_json(polymer)
database.put(polymer)
assert_database_state(
state1=get_database_state(database),
state2=DatabaseState({
DatabaseEntry(**json['molecule']):
1,
DatabaseEntry(**to_hashable_matrix(json['matrix'])):
1,
DatabaseEntry(**json['buildingBlocks'][0]['molecule']):
1,
DatabaseEntry(**to_hashable_matrix(json=json['buildingBlocks'][0]['matrix'], )):
1,
DatabaseEntry(**to_hashable_constructed_molecule(json=json['constructedMolecule'], )):
1,
}),
)
polymer2 = polymer.with_position_matrix(position_matrix=np.zeros(
(polymer.get_num_atoms(), 3)), )
json2 = jsonizer.to_json(polymer2)
database.put(polymer2)
assert_database_state(
state1=get_database_state(database),
state2=DatabaseState({
DatabaseEntry(**json['molecule']):
1,
DatabaseEntry(**to_hashable_matrix(json2['matrix'])):
1,
DatabaseEntry(**json['buildingBlocks'][0]['molecule']):
1,
DatabaseEntry(**to_hashable_matrix(json=json['buildingBlocks'][0]['matrix'], )):
1,
DatabaseEntry(**to_hashable_constructed_molecule(json=json['constructedMolecule'], )):
1,
}),
)
import pytest
import stk
from ..case_data import CaseData
topology_graph = stk.polymer.Linear(
building_blocks=(stk.BuildingBlock('BrCCBr', [stk.BromoFactory()]), ),
repeating_unit='A',
num_repeating_units=2,
)
topology_graph = stk.polymer.Linear(
building_blocks=(stk.BuildingBlock('BrCCBr', [stk.BromoFactory()]), ),
repeating_unit='A',
num_repeating_units=2,
)
@pytest.fixture(
params=(CaseData(
fitness_normalizer=stk.ReplaceFitness(
get_replacement=lambda population: min(record.get_fitness_value()
for record in population
if record.get_fitness_value(
) is not None) / 2,
filter=lambda population, record: record.get_fitness_value() is
None,
),
population=(
stk.MoleculeRecord(
topology_graph=topology_graph, ).with_fitness_value(1),
'InChI':
'InChI=1S/C2Br2/c3-1-2-4/q+4',
'InChIKey':
'UWAHASCVLDBPQQ-UHFFFAOYSA-N',
'm': [
[0., 0., 0.],
[1., 0., 0.],
[2., 0., 0.],
[3., 0., 0.],
],
}
},
molecule=stk.BuildingBlock(
smiles='Br[C+2][C+2]Br', ).with_position_matrix(
np.array([
[0., 0., 0.],
[1., 0., 0.],
[2., 0., 0.],
[3., 0., 0.],
])),
),
CaseData(
dejsonizer=stk.ConstructedMoleculeDejsonizer(),
json={
'molecule': {
'a': (
(35, 0),
(6, 2),
(6, 2),
(6, 2),
(6, 2),
(35, 0),
def get_edges(vertex):
vertex2 = stk.Vertex(1, vertex.get_position() + [-1, -1, 0])
yield stk.Edge(id=0,
vertex1=vertex,
vertex2=vertex2,
position=vertex.get_position() + [-1, 0, 0])
yield stk.Edge(id=1,
vertex1=vertex,
vertex2=vertex2,
position=vertex.get_position() + [0, -1, 0])
@pytest.fixture(
params=(stk.BuildingBlock(
smiles='C=NC/C=N/Br',
functional_groups=[
stk.SmartsFunctionalGroupFactory(
smarts='[#6]~[#7X2]~[#35]',
bonders=(1, ),
deleters=(),
),
stk.SmartsFunctionalGroupFactory(
smarts='[#6]~[#7X2]~[#6]',
bonders=(1, ),
deleters=(),
),
],
), ), )
def building_block_2(request):
return request.param
def test_init_from_smiles():
mol0 = stk.BuildingBlock('NCCCN', ['amine'])
# Test that all values are initialized correctly.
assert len(mol0.func_groups) == 2
fg_types = stk.dedupe(fg.fg_type.name for fg in mol0.func_groups)
assert sum(1 for _ in fg_types) == 1
assert len(mol0.atoms) == 15
assert len(mol0.bonds) == 14
atom_count = {
(stk.H, 0): 10,
(stk.N, 0): 2,
(stk.C, 0): 3
}
assert atom_count == Counter(
(a.__class__, a.charge) for a in mol0.atoms
)
expected_bonds = {
frozenset({stk.N, stk.C}): 2,
frozenset({stk.C}): 2,
frozenset({stk.H, stk.N}): 4,
frozenset({stk.H, stk.C}): 6
}
assert expected_bonds == Counter(
frozenset({b.atom1.__class__, b.atom2.__class__})
for b in mol0.bonds
)
# Test that caching is working properly.
mol1 = stk.BuildingBlock('NCCCN', ['amine'])
assert mol0 is not mol1
mol2 = stk.BuildingBlock(
smiles='NCCCN',
functional_groups=['amine'],
use_cache=True
)
mol3 = stk.BuildingBlock(
smiles='NCCCN',
functional_groups=['amine'],
use_cache=True
)
assert mol0 is not mol2 and mol1 is not mol2
assert mol2 is mol3
mol4 = stk.BuildingBlock(
smiles='NCCCN',
functional_groups=['aldehyde'],
use_cache=True
)
assert mol3 is not mol4
# Make sure that charged molecules are handled correctly.
mol5 = stk.BuildingBlock(
smiles='NC[C-]CN',
functional_groups=['amine'],
use_cache=True
)
assert mol5 is not mol0
# Test that all values are initialized correctly.
assert len(mol5.func_groups) == 2
fg_types = stk.dedupe(fg.fg_type.name for fg in mol5.func_groups)
assert sum(1 for _ in fg_types) == 1
assert len(mol5.atoms) == 13
assert len(mol5.bonds) == 12
atom_count = {
(stk.C, 0): 2,
(stk.C, -1): 1,
(stk.N, 0): 2,
(stk.H, 0): 8,
}
assert atom_count == Counter(
(a.__class__, a.charge) for a in mol5.atoms
)
expected_bonds = {
frozenset({stk.N, stk.C}): 2,
frozenset({stk.C}): 2,
frozenset({stk.H, stk.N}): 4,
frozenset({stk.H, stk.C}): 4,
}
assert expected_bonds == Counter(
frozenset({b.atom1.__class__, b.atom2.__class__})
for b in mol5.bonds
)
mol6 = stk.BuildingBlock(
smiles='[N-]CCCN',
functional_groups=['amine'],
use_cache=True
)
assert mol6 is not mol5 and mol6 is not mol0
# Test that all values are initialized correctly.
assert len(mol6.func_groups) == 1
fg_types = stk.dedupe(fg.fg_type.name for fg in mol6.func_groups)
assert sum(1 for _ in fg_types) == 1
assert len(mol6.atoms) == 13
assert len(mol6.bonds) == 12
atom_count = {
(stk.C, 0): 3,
(stk.N, 0): 1,
(stk.N, -1): 1,
(stk.H, 0): 8,
}
assert atom_count == Counter(
(a.__class__, a.charge) for a in mol6.atoms
)
expected_bonds = {
frozenset({stk.N, stk.C}): 2,
frozenset({stk.C}): 2,
frozenset({stk.H, stk.N}): 2,
frozenset({stk.H, stk.C}): 6
}
assert expected_bonds == Counter(
frozenset({b.atom1.__class__, b.atom2.__class__})
for b in mol6.bonds
)
get_database: Callable[[pymongo.MongoClient], stk.ValueMongoDb]
molecule: stk.Molecule
key: object
@pytest.fixture(
params=(
lambda: CaseDataData(
get_database=lambda mongo_client: stk.MoleculeMongoDb(
mongo_client=mongo_client,
database='_stk_test_database_for_testing',
put_lru_cache_size=0,
get_lru_cache_size=0,
),
molecule=stk.BuildingBlock('BrCCBr'),
key=
{'InChIKey': rdkit.MolToInchiKey(rdkit.MolFromSmiles('BrCCBr'))},
),
lambda: CaseDataData(
get_database=lambda mongo_client: stk.MoleculeMongoDb(
mongo_client=mongo_client,
database='_stk_test_database_for_testing',
put_lru_cache_size=0,
get_lru_cache_size=0,
jsonizer=stk.MoleculeJsonizer(key_makers=(stk.MoleculeKeyMaker(
key_name='SMILES',
get_key=lambda molecule: rdkit.MolToSmiles(
molecule.to_rdkit_mol())), ), ),
),
molecule=stk.BuildingBlock('BrBr'),
def get_topology_graph(num_repeating_units):
return stk.polymer.Linear(
building_blocks=(stk.BuildingBlock('BrCCBr', [stk.BromoFactory()]), ),
repeating_unit='A',
num_repeating_units=num_repeating_units,
)
subunit.
"""
subunits = defaultdict(list)
for atom_info in mol.get_atom_infos():
subunits[atom_info.get_building_block_id()].append(
atom_info.get_atom().get_id()
)
return subunits
# Building a cage from the examples on the stk docs.
bb1 = stk.BuildingBlock(
smiles='O=CC(C=O)C=O',
functional_groups=[stk.AldehydeFactory()],
)
bb2 = stk.BuildingBlock(
smiles='O=CC(Cl)(C=O)C=O',
functional_groups=[stk.AldehydeFactory()],
)
bb3 = stk.BuildingBlock('NCCN', [stk.PrimaryAminoFactory()])
bb4 = stk.BuildingBlock.init_from_file(
'some_complex.mol',
functional_groups=[stk.PrimaryAminoFactory()],
)
bb5 = stk.BuildingBlock('NCCCCN', [stk.PrimaryAminoFactory()])
cage = stk.ConstructedMolecule(
topology_graph=stk.cage.FourPlusSix(
# building_blocks is now a dict, which maps building
' 25.8627 15.9486 53.0853 H\n 26.3889 15.0919 51.5516 '
'H\n 28.3774 16.2543 53.6163 H\n 27.887 17.1318 52.075'
'5 H\n 18.2158 0.7674 52.5831 C\n 18.2158 -0.7674 52.5'
'831 C\n 18.8755 1.1784 53.3532 H\n 18.4472 1.1511 51.'
'5703 H\n 17.762 -1.1522 53.518 H\n 19.2283 -1.1662 52'
'.4069 H\n 9.7725 15.3912 52.5831 C\n 8.4433 16.1586 5'
'2.5831 C\n 9.6258 14.315 52.7155 H\n 10.357 15.6362 5'
'1.6749 H\n 7.9667 16.1026 53.582 H\n 7.7801 15.8075 5'
'1.7756 H\n$end\n'),
periodic_info=construction_result.get_periodic_info(),
)
@pytest.fixture(
params=(
lambda: CaseData(
molecule=stk.BuildingBlock('BrCCBr', [stk.BromoFactory()]),
writer=stk.TurbomoleWriter(),
string=('$coord angs\n -1.4238 1.5615 0.3223 Br\n -0.7405 -0.2'
'573 0.128 C\n 0.7148 -0.1157 -0.3383 C\n 1.6267 0.889'
'6 1.0687 Br\n -1.3518 -0.8075 -0.5939 H\n -0.7769 -0.'
'6964 1.144 H\n 0.7695 0.528 -1.2387 H\n 1.1821 -1.102'
'2 -0.4922 H\n$end\n'),
periodic_info=None,
),
_get_cof_case,
), )
def case_data(request) -> CaseData:
return request.param()
import pytest
import stk
from ....case_data import CaseData
metal_atom = stk.BuildingBlock(
smiles='[Fe+2]',
functional_groups=(
stk.SingleAtom(stk.Fe(0, charge=2))
for i in range(6)
),
position_matrix=([0, 0, 0], ),
)
complex_ligand = stk.BuildingBlock(
smiles=(
'[H]C1=NC(C([H])=NC2=C([H])C([H])=C(Br)C([H])=C2[H])=C([H])C'
'([H])=C1[H]'
),
functional_groups=[
stk.SmartsFunctionalGroupFactory(
smarts='[#6]~[#7X2]~[#35]',
bonders=(1, ),
deleters=(),
),
stk.SmartsFunctionalGroupFactory(
smarts='[#6]~[#7X2]~[#6]',
bonders=(1, ),
deleters=(),
),
import pytest
import stk
from ....case_data import CaseData
@pytest.fixture(
scope='session',
params=(lambda name: CaseData(
molecule=stk.ConstructedMolecule(topology_graph=stk.cage.FourPlusSix2(
building_blocks=(
stk.BuildingBlock(
smiles='BrC1=C(Br)[C+]=N1',
functional_groups=[stk.BromoFactory()],
),
stk.BuildingBlock(
smiles=('Br[C+]1[C+2][C+](Br)[C+]2[C+](F)[C+2]'
'C2(Br)[C+2]1'),
functional_groups=[stk.BromoFactory()],
),
), ), ),
smiles=('F[C+]1[C+2]C23[C+2][C+]4[C+2][C+](C5=C(N=[C+]5)C56[C+'
'2][C+]7[C+2][C+](C8=C(N=[C+]8)C89[C+2][C+]([C+2][C+]('
'C%10=C([C+]=N%10)C%10%11[C+2][C+]([C+2][C+](C%12=C2[C'
'+]=N%12)[C+]%10[C+](F)[C+2]%11)C2=C4[C+]=N2)[C+]8[C+]'
'(F)[C+2]9)C2=C7[C+]=N2)[C+]5[C+](F)[C+2]6)[C+]13'),
name=name,
), ),
)
def cage_four_plus_six_2(request) -> CaseData:
return request.param(f'{request.fixturename}{request.param_index}', )
unoptimised_energy:
The energy of the molecule from stk generation.
"""
def __init__(self, molecule, unoptimised_energy):
self.molecule = molecule
self.unoptimised_energy = unoptimised_energy
@pytest.fixture(
scope='session',
params=[
CaseData(
molecule=stk.BuildingBlock('NCCN'),
unoptimised_energy=18.706050515892986,
),
CaseData(
molecule=stk.BuildingBlock(
'C(#Cc1cccc2ccncc21)c1ccc2[nH]c3ccc(C#Cc4cccc5cnccc54)'
'cc3c2c1'),
unoptimised_energy=276.0206611549808,
),
CaseData(
molecule=stk.BuildingBlock('CCCCCC'),
unoptimised_energy=20.722743438967758,
),
CaseData(
molecule=stk.BuildingBlock('c1ccccc1'),
unoptimised_energy=13.516838919531384,
