def _cumulene_chains(rgr):
atm_hyb_dct = resonance_dominant_atom_hybridizations(rgr)
sp1_atm_keys = dict_.keys_by_value(atm_hyb_dct, lambda x: x == 1)
sp2_atm_keys = dict_.keys_by_value(atm_hyb_dct, lambda x: x == 2)
atm_ngb_keys_dct = _atom_neighbor_keys(rgr)
def _cumulene_chain(chain):
ret = None
atm_key = chain[-1]
next_atm_keys = atm_ngb_keys_dct[atm_key] - {chain[-2]}
if next_atm_keys:
assert len(next_atm_keys) == 1
next_atm_key, = next_atm_keys
if next_atm_key in sp1_atm_keys:
chain.append(next_atm_key)
ret = _cumulene_chain(chain)
elif next_atm_key in sp2_atm_keys:
chain.append(next_atm_key)
ret = chain
return ret
cum_chains = []
for atm_key in sp2_atm_keys:
sp1_atm_ngb_keys = atm_ngb_keys_dct[atm_key] & sp1_atm_keys
chains = [[atm_key, atm_ngb_key] for atm_ngb_key in sp1_atm_ngb_keys]
for chain in chains:
cum_chain = _cumulene_chain(chain)
if cum_chain is not None:
cum_chains.append(cum_chain)
cum_chains = tuple(map(tuple, cum_chains))
return cum_chains
def stereogenic_bond_keys(xgr):
""" (unassigned) stereogenic bonds in this graph
"""
xgr = _without_bond_orders(xgr)
xgr = _explicit(xgr) # for simplicity, add the explicit hydrogens back in
bnd_keys = dict_.keys_by_value(_resonance_dominant_bond_orders(xgr),
lambda x: 2 in x)
# make sure both ends are sp^2 (excludes cumulenes)
atm_hyb_dct = _resonance_dominant_atom_hybridizations(xgr)
sp2_atm_keys = dict_.keys_by_value(atm_hyb_dct, lambda x: x == 2)
bnd_keys = frozenset(
{bnd_key
for bnd_key in bnd_keys if bnd_key <= sp2_atm_keys})
bnd_keys -= bond_stereo_keys(xgr)
bnd_keys -= functools.reduce( # remove double bonds in small rings
frozenset.union, filter(lambda x: len(x) < 8, _rings_bond_keys(xgr)),
frozenset())
atm_ngb_keys_dct = _atom_neighbor_keys(xgr)
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(
xgr, atm_key, atm_ngb_keys[0]) == stereo_priority_vector(
xgr, 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 explicit_hydrogen_keys(xgr):
""" explicit hydrogen keys (H types: explicit, implicit, backbone)
"""
hyd_keys = dict_.keys_by_value(atom_symbols(xgr), lambda x: x == 'H')
atm_ngb_keys_dct = atom_neighbor_keys(xgr)
def _is_backbone(hyd_key):
return all(ngb_key in hyd_keys and hyd_key < ngb_key
for ngb_key in atm_ngb_keys_dct[hyd_key])
exp_hyd_keys = frozenset(fmit.filterfalse(_is_backbone, hyd_keys))
return exp_hyd_keys
def stereogenic_atom_keys(gra):
""" (unassigned) stereogenic atoms in this graph
"""
gra = without_bond_orders(gra)
gra = explicit(gra) # for simplicity, add the explicit hydrogens back in
atm_keys = dict_.keys_by_value(atom_bond_valences(gra), lambda x: x == 4)
atm_keys -= atom_stereo_keys(gra)
atm_ngb_keys_dct = atom_neighbor_keys(gra)
def _is_stereogenic(atm_key):
atm_ngb_keys = list(atm_ngb_keys_dct[atm_key])
pri_vecs = [stereo_priority_vector(gra, atm_key, atm_ngb_key)
for atm_ngb_key in atm_ngb_keys]
return not any(pv1 == pv2
for pv1, pv2 in itertools.combinations(pri_vecs, r=2))
ste_gen_atm_keys = frozenset(filter(_is_stereogenic, atm_keys))
return ste_gen_atm_keys
def bond_stereo_keys(sgr):
""" keys to bond stereo-centers
"""
bnd_ste_keys = dict_.keys_by_value(bond_stereo_parities(sgr),
lambda x: x in [True, False])
return bnd_ste_keys
def atom_stereo_keys(sgr):
""" keys to atom stereo-centers
"""
atm_ste_keys = dict_.keys_by_value(atom_stereo_parities(sgr),
lambda x: x in [True, False])
return atm_ste_keys
def unsaturated_atom_keys(xgr):
""" keys of unsaturated (radical or pi-bonded) atoms
"""
atm_unsat_vlc_dct = atom_unsaturated_valences(xgr, bond_order=False)
unsat_atm_keys = frozenset(dict_.keys_by_value(atm_unsat_vlc_dct, bool))
return unsat_atm_keys
def dummy_bond_keys(xgr):
""" dummy bond (order=0) keys
"""
return frozenset(dict_.keys_by_value(bond_orders(xgr), lambda x: x == 0))
