def nonconserved_bond_stereo_keys(ste_tsg, check=True):
""" Determine bond stereo centers which are not conserved by the reaction.
This includes bonds which are stereogenic for the products but not for the
reactants ("created" stereo centers) and bonds which are stereogenic for
the reactants but not for the products ("destroyed" stereo centers).
:param ste_tsg: The TS graph, with stereo assignments.
:returns: Created and destroyed bond stereo centers, respectively.
:rtype: (frozenset, frozenset)
"""
rcts_gra = reactants_graph(ste_tsg)
prds_gra = products_graph(ste_tsg)
if check:
ste_atm_keys = stereogenic_atom_keys(rcts_gra)
ste_bnd_keys = stereogenic_bond_keys(rcts_gra)
assert not ste_atm_keys, ("Unassigned atom stereo centers: {}".format(
str(ste_atm_keys)))
assert not ste_bnd_keys, ("Unassigned bond stereo centers: {}".format(
str(ste_bnd_keys)))
keys1 = bond_stereo_keys(rcts_gra)
keys2 = stereogenic_bond_keys(prds_gra, assigned=True)
cre_ste_bnd_keys = frozenset(keys2 - keys1)
des_ste_bnd_keys = frozenset(keys1 - keys2)
return cre_ste_bnd_keys, des_ste_bnd_keys
def atoms_stereo_sorted_neighbor_atom_keys(sgr):
""" Obtain neighbor atom keys for all stereo atoms, sorted by stereo
priority.
Includes all stereo atoms and atoms constituting stereo bonds. For stereo
bonds, the neighbors for each atom in the bond exclude the other atom in
the bond.
:param sgr: the graph
:returns: Neighbor atom keys, sorted by stereo priority, keyed by atom.
:rtype: dict
"""
atm_ste_keys = atom_stereo_keys(sgr)
bnd_ste_keys = bond_stereo_keys(sgr)
atm_ngb_keys_dct = atoms_neighbor_atom_keys(sgr)
ste_atm_ngb_keys_dct = {}
for atm_key in atm_ste_keys:
atm_ngb_keys = atm_ngb_keys_dct[atm_key]
ste_atm_ngb_keys_dct[atm_key] = atom_stereo_sorted_neighbor_atom_keys(
sgr, atm_key, atm_ngb_keys)
for bnd_key in bnd_ste_keys:
atm1_key, atm2_key = sorted(bnd_key)
atm1_ngb_keys = atm_ngb_keys_dct[atm1_key] - bnd_key
atm2_ngb_keys = atm_ngb_keys_dct[atm2_key] - bnd_key
ste_atm_ngb_keys_dct[atm1_key] = atom_stereo_sorted_neighbor_atom_keys(
sgr, atm1_key, atm1_ngb_keys)
ste_atm_ngb_keys_dct[atm2_key] = atom_stereo_sorted_neighbor_atom_keys(
sgr, atm2_key, atm2_ngb_keys)
return ste_atm_ngb_keys_dct
def stereogenic_bond_keys(gra, assigned=False):
""" Find stereogenic bonds in this graph.
If the `assigned` flag is set to `False`, only unassigned stereogenic
bonds will be detected.
:param gra: the graph
:param assigned: Include bonds that already have stereo assignments?
:param assigned: bool
:returns: the stereogenic bond keys
:rtype: frozenset
"""
gra = without_bond_orders(gra)
gra = explicit(gra) # for simplicity, add the explicit hydrogens back in
# get candidates: planar bonds
bnd_keys = sp2_bond_keys(gra)
if not assigned:
# remove bonds that already have stereo assignments
bnd_keys -= bond_stereo_keys(gra)
bnd_keys -= functools.reduce( # remove double bonds in small rings
frozenset.union, filter(lambda x: len(x) < 8, rings_bond_keys(gra)),
frozenset())
atm_ngb_keys_dct = atoms_neighbor_atom_keys(gra)
def _is_stereogenic(bnd_key):
atm1_key, atm2_key = bnd_key
def _is_symmetric_on_bond(atm_key, atm_ngb_key):
atm_ngb_keys = list(atm_ngb_keys_dct[atm_key] - {atm_ngb_key})
if not atm_ngb_keys: # C=:O:
ret = True
elif len(atm_ngb_keys) == 1: # C=N:-X
ret = False
else:
assert len(atm_ngb_keys) == 2 # C=C(-X)-Y
ret = (stereo_priority_vector(
gra, atm_key, atm_ngb_keys[0]) == stereo_priority_vector(
gra, atm_key, atm_ngb_keys[1]))
return ret
return not (_is_symmetric_on_bond(atm1_key, atm2_key)
or _is_symmetric_on_bond(atm2_key, atm1_key))
ste_gen_bnd_keys = frozenset(filter(_is_stereogenic, bnd_keys))
return ste_gen_bnd_keys
def to_index_based_stereo(sgr):
""" Convert a graph to index-based stereo assignments, where parities are
defined relative to the ordering of indices rather than the absolute stereo
priority.
:param sgr: a graph with absolute stereo assignments
:returns: a graph with index-based stereo assignments
"""
assert sgr == explicit(sgr), (
f"Not an explicit graph:\n{string(sgr, one_indexed=False)}")
abs_srt_keys_dct = atoms_stereo_sorted_neighbor_atom_keys(sgr)
atm_ste_keys = atom_stereo_keys(sgr)
bnd_ste_keys = bond_stereo_keys(sgr)
abs_atm_ste_par_dct = atom_stereo_parities(sgr)
abs_bnd_ste_par_dct = bond_stereo_parities(sgr)
idx_atm_ste_par_dct = {}
idx_bnd_ste_par_dct = {}
# Determine index-based stereo assignments for atoms
for atm_key in atm_ste_keys:
abs_srt_keys = abs_srt_keys_dct[atm_key]
idx_srt_keys = sorted(abs_srt_keys)
if util.is_even_permutation(idx_srt_keys, abs_srt_keys):
idx_atm_ste_par_dct[atm_key] = abs_atm_ste_par_dct[atm_key]
else:
idx_atm_ste_par_dct[atm_key] = not abs_atm_ste_par_dct[atm_key]
# Determine index-based stereo assignments for bonds
for bnd_key in bnd_ste_keys:
atm1_key, atm2_key = sorted(bnd_key)
atm1_abs_srt_keys = abs_srt_keys_dct[atm1_key]
atm2_abs_srt_keys = abs_srt_keys_dct[atm2_key]
atm1_idx_srt_keys = sorted(atm1_abs_srt_keys)
atm2_idx_srt_keys = sorted(atm2_abs_srt_keys)
if not ((atm1_idx_srt_keys[0] != atm1_abs_srt_keys[0]) ^
(atm2_idx_srt_keys[0] != atm2_abs_srt_keys[0])):
idx_bnd_ste_par_dct[bnd_key] = abs_bnd_ste_par_dct[bnd_key]
else:
idx_bnd_ste_par_dct[bnd_key] = not abs_bnd_ste_par_dct[bnd_key]
sgr = set_atom_stereo_parities(sgr, idx_atm_ste_par_dct)
sgr = set_bond_stereo_parities(sgr, idx_bnd_ste_par_dct)
return sgr
def compatible_reverse_stereomers(ste_tsg):
""" Given a TS graph with stereo assignments, expand all possible reverse
graphs compatble with the forward graph.
:param ste_tsg: The TS graph, with stereo assignments.
:returns: All possible reverse TS graphs.
"""
frm_bnd_keys = forming_bond_keys(ste_tsg)
brk_bnd_keys = breaking_bond_keys(ste_tsg)
_, des_ste_atm_keys = nonconserved_atom_stereo_keys(ste_tsg)
_, des_ste_bnd_keys = nonconserved_bond_stereo_keys(ste_tsg)
cons_atm_keys = sorted(atom_stereo_keys(ste_tsg) - des_ste_atm_keys)
cons_bnd_keys = sorted(bond_stereo_keys(ste_tsg) - des_ste_bnd_keys)
# 1. Determine index-based stereo assignments for conserved stereo centers
idx_tsg = to_index_based_stereo(ste_tsg)
cons_idx_atm_pars = dict_.values_by_key(atom_stereo_parities(idx_tsg),
cons_atm_keys)
cons_idx_bnd_pars = dict_.values_by_key(bond_stereo_parities(idx_tsg),
cons_bnd_keys)
# 2. Determine all possible index-based stereo assignments for the reverse
# reaction.
prds_gra = without_stereo_parities(products_graph(ste_tsg))
prds_sgrs = _stereomers(prds_gra)
prds_idx_sgrs = list(map(_to_index_based_stereo, prds_sgrs))
rev_idx_tsgs_pool = [
graph(p, brk_bnd_keys, frm_bnd_keys) for p in prds_idx_sgrs
]
# 3. Find possibilities which match the assignments for the conserved
# stereo centers.
rev_idx_tsgs = []
for rev_idx_tsg in rev_idx_tsgs_pool:
rev_cons_idx_atm_pars = dict_.values_by_key(
atom_stereo_parities(rev_idx_tsg), cons_atm_keys)
rev_cons_idx_bnd_pars = dict_.values_by_key(
bond_stereo_parities(rev_idx_tsg), cons_bnd_keys)
if (rev_cons_idx_atm_pars == cons_idx_atm_pars
and rev_cons_idx_bnd_pars == cons_idx_bnd_pars):
rev_idx_tsgs.append(rev_idx_tsg)
# 4. Convert the matching reverse graphs back from index-based stereo
# assignments to absolute stereo assignments.
rev_ste_tsgs = list(map(from_index_based_stereo, rev_idx_tsgs))
return rev_ste_tsgs
def _bond_stereo_layer(gra):
""" AMChI bond stereo (b) layer from graph
cis = '-' = False
trans = '+' = True
:param gra: molecular graph
:type gra: automol graph data structure
:returns: the bond stereo layer, without prefix
:rtype: str
"""
# Generate the bond stereo layer string
bnd_keys = sorted(sorted(k, reverse=True) for k in bond_stereo_keys(gra))
bnd_par_dct = bond_stereo_parities(gra)
bnd_pars = list(map(bnd_par_dct.__getitem__, map(frozenset, bnd_keys)))
bnd_sgns = ['+' if p else '-' for p in bnd_pars]
bnd_strs = [f'{i+1}-{j+1}{s}' for (i, j), s in zip(bnd_keys, bnd_sgns)]
bnd_ste_lyr = ','.join(bnd_strs)
return bnd_ste_lyr
def _insert_stereo_hydrogens(gra):
""" Insert hydrogens necessary for bond stereo into an implicit graph.
Hydrogens are given negative keys for proper stereo sorting
"""
bnd_keys = bond_stereo_keys(gra)
nkeys_dct = atoms_neighbor_atom_keys(gra)
nhyd_dct = atom_implicit_hydrogen_valences(gra)
next_key = -max(atom_keys(gra)) - 1
for bnd_key in bnd_keys:
key1, key2 = bnd_key
nkey1s = nkeys_dct[key1] - {key2}
nkey2s = nkeys_dct[key2] - {key1}
for key, nkeys in [(key1, nkey1s), (key2, nkey2s)]:
if not nkeys:
assert nhyd_dct[key] == 1
gra = add_bonded_atom(gra, 'H', key, next_key)
gra = set_atom_implicit_hydrogen_valences(gra, {key: 0})
next_key = next_key - 1
return gra
def from_index_based_stereo(sgr):
""" Convert a graph from index-based stereo assignments back to absolute
stereo assignments, where parities are independent of atom ordering.
:param sgr: a graph with index-based stereo assignments
:returns: a graph with absolute stereo assignments
"""
assert sgr == explicit(sgr), (
f"Not an explicit graph:\n{string(sgr, one_indexed=False)}")
gra = without_stereo_parities(sgr)
if has_stereo(sgr):
atm_keys_pool = atom_stereo_keys(sgr)
bnd_keys_pool = bond_stereo_keys(sgr)
idx_atm_ste_par_dct = atom_stereo_parities(sgr)
idx_bnd_ste_par_dct = bond_stereo_parities(sgr)
atm_ngb_keys_dct = atoms_neighbor_atom_keys(sgr)
atm_keys = set()
bnd_keys = set()
last_gra = None
# Do the assignments iteratively to handle higher-order stereo
while last_gra != gra:
last_gra = gra
abs_atm_ste_par_dct = {}
abs_bnd_ste_par_dct = {}
atm_keys.update(stereogenic_atom_keys(gra) & atm_keys_pool)
bnd_keys.update(stereogenic_bond_keys(gra) & bnd_keys_pool)
# Determine absolute stereo assignments for atoms
for atm_key in atm_keys:
abs_srt_keys = atom_stereo_sorted_neighbor_atom_keys(
gra, atm_key, atm_ngb_keys_dct[atm_key])
idx_srt_keys = sorted(abs_srt_keys)
if util.is_even_permutation(idx_srt_keys, abs_srt_keys):
abs_atm_ste_par_dct[atm_key] = (
idx_atm_ste_par_dct[atm_key])
else:
abs_atm_ste_par_dct[atm_key] = (
not idx_atm_ste_par_dct[atm_key])
# Determine absolute stereo assignments for bonds
for bnd_key in bnd_keys:
atm1_key, atm2_key = sorted(bnd_key)
atm1_abs_srt_keys = atom_stereo_sorted_neighbor_atom_keys(
gra, atm1_key, atm_ngb_keys_dct[atm1_key] - bnd_key)
atm2_abs_srt_keys = atom_stereo_sorted_neighbor_atom_keys(
gra, atm2_key, atm_ngb_keys_dct[atm2_key] - bnd_key)
atm1_idx_srt_keys = sorted(atm1_abs_srt_keys)
atm2_idx_srt_keys = sorted(atm2_abs_srt_keys)
if not ((atm1_idx_srt_keys[0] != atm1_abs_srt_keys[0]) ^
(atm2_idx_srt_keys[0] != atm2_abs_srt_keys[0])):
abs_bnd_ste_par_dct[bnd_key] = (
idx_bnd_ste_par_dct[bnd_key])
else:
abs_bnd_ste_par_dct[bnd_key] = (
not idx_bnd_ste_par_dct[bnd_key])
gra = set_atom_stereo_parities(gra, abs_atm_ste_par_dct)
gra = set_bond_stereo_parities(gra, abs_bnd_ste_par_dct)
atm_ste_keys = atom_stereo_keys(gra)
bnd_ste_keys = bond_stereo_keys(gra)
assert atm_ste_keys == atm_keys_pool, (
"Index-based to absolute stereo conversion failed:\n"
f"{str(atm_ste_keys)} != {str(atm_keys_pool)}")
assert bnd_ste_keys == bnd_keys_pool, (
"Index-based to absolute stereo conversion failed:\n"
f"{str(bnd_ste_keys)} != {str(bnd_keys_pool)}")
return gra