12140431916

Committed 03 Dec 2024 01:14PM UTC coverage: 96.125% (-1.5%) from 97.583%

Build # 12140431916

Build Type

Pull #51

travis-ci

Committed by

web-flow

Commit Message

Merge 80625d934 into 1071fbf78

Pull Request Pull Request #51: Ez multi

Run Details

390 of 407 branches covered (95.82%)

Branch coverage included in aggregate %.

35 of 37 new or added lines in 2 files covered. (94.59%)

10 existing lines in 3 files now uncovered.

627 of 651 relevant lines covered (96.31%)

0.96 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.72

/pysmiles/read_smiles.py

# -*- coding: utf-8 -*-
# Copyright 2018 Peter C Kroon

# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""
Exposes functionality needed for parsing SMILES strings.
"""

import enum
import logging

import networkx as nx

from . import PTE
from .smiles_helper import (add_explicit_hydrogens, remove_explicit_hydrogens,
                            parse_atom, fill_valence, bonds_missing, format_atom,
                            correct_aromatic_rings,
                            _mark_chiral_atoms, annotate_ez_isomers)
from .write_smiles import write_smiles_component

LOGGER = logging.getLogger(__name__)


@enum.unique
class TokenType(enum.Enum):
    """Possible SMILES token types"""
    ATOM = 1
    BOND_TYPE = 2
    BRANCH_START = 3
    BRANCH_END = 4
    RING_NUM = 5
    EZSTEREO = 6
    CHIRAL = 7


def _tokenize(smiles):
    """
    Iterates over a SMILES string, yielding tokens.

    Parameters
    ----------
    smiles : iterable
        The SMILES string to iterate over

    Yields
    ------
    tuple(TokenType, str)
        A tuple describing the type of token and the associated data
    """
    organic_subset = 'B C N O P S F Cl Br I * b c n o s p'.split()
    smiles = iter(smiles)
    token = ''
    peek = None
    while True:
        char = peek if peek else next(smiles, '')
        peek = None
        if not char:
            break
        if char == '[':
            token = char
            for char in smiles:  # pragma: no branch
                token += char
                if char == ']':
                    break
            yield TokenType.ATOM, token
        elif char in organic_subset:
            peek = next(smiles, '')
            if char + peek in organic_subset:
                yield TokenType.ATOM, char + peek
                peek = None
            else:
                yield TokenType.ATOM, char
        elif char in '-=#$:.':
            yield TokenType.BOND_TYPE, char
        elif char == '(':
            yield TokenType.BRANCH_START, '('
        elif char == ')':
            yield TokenType.BRANCH_END, ')'
        elif char == '%':
            # If smiles is too short this will raise a ValueError, which is
            # (slightly) prettier than a StopIteration.
            yield TokenType.RING_NUM, int(next(smiles, '') + next(smiles, ''))
        elif char in '/\\':
            yield TokenType.EZSTEREO, char
        elif char.isdigit():  # pragma: no branch
            yield TokenType.RING_NUM, int(char)


def read_smiles(smiles, explicit_hydrogen=False, zero_order_bonds=True, 
                reinterpret_aromatic=True, strict=True):
    """
    Parses a SMILES string.

    Parameters
    ----------
    smiles : iterable
        The SMILES string to parse. Should conform to the OpenSMILES
        specification.
    explicit_hydrogen : bool
        Whether hydrogens should be explicit nodes in the output graph, or be
        implicit in 'hcount' attributes.
    zero_order_bonds : bool
        Whether zero-order bonds (".") should be added as edges with an order of
        0.
    reinterpret_aromatic : bool
        Whether aromaticity should be determined from the created molecule,
        instead of taken from the SMILES string.
    strict : bool
        Whether to be more strict in accepting what is a valid SMILES string and
        what is not.

    Returns
    -------
    nx.Graph
        A graph describing a molecule. Nodes will have an 'element', 'aromatic'
        and a 'charge', and if `explicit_hydrogen` is False a 'hcount'.
        Depending on the input, they will also have 'isotope' and 'class'
        information.
        Edges will have an 'order'.
    """
    bond_to_order = {'-': 1, '=': 2, '#': 3, '$': 4, ':': 1.5, '.': 0}
    mol = nx.Graph()
    anchor = None
    idx = 0
    default_bond = 1
    default_aromatic_bond = 1.5
    next_bond = None
    branches = []
    ring_nums = {}
    current_ez = None
    prev_token = None
    prev_type = None
    ez_isomer_atoms = {}
    for tokentype, token in _tokenize(smiles):
        if tokentype == TokenType.ATOM:
            mol.add_node(idx, **parse_atom(token))
            if anchor is not None:
                if next_bond is None:
                    if mol.nodes[anchor].get('aromatic') and mol.nodes[idx].get('aromatic'):
                        next_bond = default_aromatic_bond
                    else:
                        next_bond = default_bond
                if next_bond or zero_order_bonds:
                    mol.add_edge(anchor, idx, order=next_bond)
                next_bond = None
            anchor = idx
            idx += 1
        elif tokentype == TokenType.BRANCH_START:
            if anchor is None:
                raise SyntaxError('You cannot start a branch before an anchor.')
            branches.append(anchor)
        elif tokentype == TokenType.BRANCH_END:
            anchor = branches.pop()
        elif tokentype == TokenType.BOND_TYPE:
            if next_bond is not None:
                raise ValueError('Previous bond (order {}) not used. '
                                 'Overwritten by "{}"'.format(next_bond, token))
            next_bond = bond_to_order[token]
        elif tokentype == TokenType.RING_NUM:
            if token in ring_nums:
                jdx, order = ring_nums[token]
                if next_bond is None and order is None:
                    if mol.nodes[idx-1].get('aromatic') and mol.nodes[jdx].get('aromatic'):
                        next_bond = default_aromatic_bond
                    else:
                        next_bond = default_bond
                elif order is None:  # Note that the check is needed,
                    next_bond = next_bond  # But this could be pass.
                elif next_bond is None:
                    next_bond = order
                elif next_bond != order:  # Both are not None
                    raise ValueError('Conflicting bond orders for ring '
                                     'between indices {}'.format(token))
                # idx is the index of the *next* atom we're adding. So: -1.
                if mol.has_edge(idx-1, jdx):
                    raise ValueError('Edge specified by marker {} already '
                                     'exists'.format(token))
                if idx-1 == jdx:
                    raise ValueError('Marker {} specifies a bond between an '
                                     'atom and itself'.format(token))
                if next_bond or zero_order_bonds:
                    mol.add_edge(idx - 1, jdx, order=next_bond)
                    # we need to keep track of ring bonds here for the
                    # chirality assignment
                    if mol.nodes[idx-1].get('rs_isomer', False):
                        mol.nodes[idx-1]['rs_isomer'][1].append(jdx)
                    if mol.nodes[jdx].get('rs_isomer', False):
                        mol.nodes[jdx]['rs_isomer'][1].append(idx-1)

                next_bond = None
                del ring_nums[token]
            else:
                if idx == 0:
                    raise ValueError("Can't have a marker ({}) before an atom"
                                     "".format(token))
                # idx is the index of the *next* atom we're adding. So: -1.
                ring_nums[token] = (idx - 1, next_bond)
                next_bond = None
        elif tokentype == TokenType.EZSTEREO:  # pragma: no branch
            ez_isomer_atoms[anchor] = token
            ez_isomer_atoms[idx] = token

        prev_token = token
        prev_type = tokentype
    if ring_nums and strict:
        raise KeyError('Unmatched ring indices {}'.format(list(ring_nums.keys())))

    if current_ez and strict:
        raise ValueError('There is an unmatched stereochemical token.')

    if reinterpret_aromatic:
        correct_aromatic_rings(mol, strict=strict)

    # This is a bit of an overreach, we should only add implicit hydrogens to
    # atoms in the organic subset. However, all non-organic atoms already have
    # a hcount, so all is well.
    fill_valence(mol)

    for node in mol:
        element = mol.nodes[node].get('element', '*')
        if element != '*' and element not in PTE:
            msg = f'Unknown element {element}'
            if strict:
                raise KeyError(msg)
            else:
                LOGGER.warning(msg)
        elif element != '*' and bonds_missing(mol, node):
            debug_smiles = write_smiles_component(nx.ego_graph(mol, node))
            msg = (f'Node {node} ({format_atom(mol, node)}) has non-standard'
                   f' valence: ...{debug_smiles}...')
            if strict:
                raise KeyError(msg)
            else:
                LOGGER.warning(msg)

    # post-processing of E/Z isomerism
    annotate_ez_isomers(mol, ez_isomer_atoms)
    # post-processing of chiral atoms
    _mark_chiral_atoms(mol)

    if explicit_hydrogen:
        add_explicit_hydrogens(mol)
    else:
        remove_explicit_hydrogens(mol)

    return mol

1	# -- coding: utf-8 --
2	# Copyright 2018 Peter C Kroon
3
4	# Licensed under the Apache License, Version 2.0 (the "License");
5	# you may not use this file except in compliance with the License.
6	# You may obtain a copy of the License at
7	#
8	# http://www.apache.org/licenses/LICENSE-2.0
9	#
10	# Unless required by applicable law or agreed to in writing, software
11	# distributed under the License is distributed on an "AS IS" BASIS,
12	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	# See the License for the specific language governing permissions and
14	# limitations under the License.
15
16	"""
17	Exposes functionality needed for parsing SMILES strings.
18	"""
19
20	import enum	1✔
21	import logging	1✔
22
23	import networkx as nx	1✔
24
25	from . import PTE	1✔
26	from .smiles_helper import (add_explicit_hydrogens, remove_explicit_hydrogens,	1✔
27	parse_atom, fill_valence, bonds_missing, format_atom,
28	correct_aromatic_rings,
29	_mark_chiral_atoms, annotate_ez_isomers)
30	from .write_smiles import write_smiles_component	1✔
31
32	LOGGER = logging.getLogger(__name__)	1✔
33
34
35	@enum.unique	1✔
36	class TokenType(enum.Enum):	1✔
37	"""Possible SMILES token types"""
38	ATOM = 1	1✔
39	BOND_TYPE = 2	1✔
40	BRANCH_START = 3	1✔
41	BRANCH_END = 4	1✔
42	RING_NUM = 5	1✔
43	EZSTEREO = 6	1✔
44	CHIRAL = 7	1✔
45
46
47	def _tokenize(smiles):	1✔
48	"""
49	Iterates over a SMILES string, yielding tokens.
50
51	Parameters
52	----------
53	smiles : iterable
54	The SMILES string to iterate over
55
56	Yields
57	------
58	tuple(TokenType, str)
59	A tuple describing the type of token and the associated data
60	"""
61	organic_subset = 'B C N O P S F Cl Br I * b c n o s p'.split()	1✔
62	smiles = iter(smiles)	1✔
63	token = ''	1✔
64	peek = None	1✔
65	while True:
66	char = peek if peek else next(smiles, '')	1✔
67	peek = None	1✔
68	if not char:	1✔
69	break	1✔
70	if char == '[':	1✔
71	token = char	1✔
72	for char in smiles: # pragma: no branch	1✔
73	token += char	1✔
74	if char == ']':	1✔
75	break	1✔
76	yield TokenType.ATOM, token	1✔
77	elif char in organic_subset:	1✔
78	peek = next(smiles, '')	1✔
79	if char + peek in organic_subset:	1✔
80	yield TokenType.ATOM, char + peek	1✔
81	peek = None	1✔
82	else:
83	yield TokenType.ATOM, char	1✔
84	elif char in '-=#$:.':	1✔
85	yield TokenType.BOND_TYPE, char	1✔
86	elif char == '(':	1✔
87	yield TokenType.BRANCH_START, '('	1✔
88	elif char == ')':	1✔
89	yield TokenType.BRANCH_END, ')'	1✔
90	elif char == '%':	1✔
91	# If smiles is too short this will raise a ValueError, which is
92	# (slightly) prettier than a StopIteration.
93	yield TokenType.RING_NUM, int(next(smiles, '') + next(smiles, ''))	1✔
94	elif char in '/\\':	1✔
95	yield TokenType.EZSTEREO, char	1✔
96	elif char.isdigit(): # pragma: no branch	1✔
97	yield TokenType.RING_NUM, int(char)	1✔
98
99
100	def read_smiles(smiles, explicit_hydrogen=False, zero_order_bonds=True,	1✔
101	reinterpret_aromatic=True, strict=True):
102	"""
103	Parses a SMILES string.
104
105	Parameters
106	----------
107	smiles : iterable
108	The SMILES string to parse. Should conform to the OpenSMILES
109	specification.
110	explicit_hydrogen : bool
111	Whether hydrogens should be explicit nodes in the output graph, or be
112	implicit in 'hcount' attributes.
113	zero_order_bonds : bool
114	Whether zero-order bonds (".") should be added as edges with an order of
115	0.
116	reinterpret_aromatic : bool
117	Whether aromaticity should be determined from the created molecule,
118	instead of taken from the SMILES string.
119	strict : bool
120	Whether to be more strict in accepting what is a valid SMILES string and
121	what is not.
122
123	Returns
124	-------
125	nx.Graph
126	A graph describing a molecule. Nodes will have an 'element', 'aromatic'
127	and a 'charge', and if `explicit_hydrogen` is False a 'hcount'.
128	Depending on the input, they will also have 'isotope' and 'class'
129	information.
130	Edges will have an 'order'.
131	"""
132	bond_to_order = {'-': 1, '=': 2, '#': 3, '$': 4, ':': 1.5, '.': 0}	1✔
133	mol = nx.Graph()	1✔
134	anchor = None	1✔
135	idx = 0	1✔
136	default_bond = 1	1✔
137	default_aromatic_bond = 1.5	1✔
138	next_bond = None	1✔
139	branches = []	1✔
140	ring_nums = {}	1✔
141	current_ez = None	1✔
142	prev_token = None	1✔
143	prev_type = None	1✔
144	ez_isomer_atoms = {}	1✔
145	for tokentype, token in _tokenize(smiles):	1✔
146	if tokentype == TokenType.ATOM:	1✔
147	mol.add_node(idx, **parse_atom(token))	1✔
148	if anchor is not None:	1✔
149	if next_bond is None:	1✔
150	if mol.nodes[anchor].get('aromatic') and mol.nodes[idx].get('aromatic'):	1✔
151	next_bond = default_aromatic_bond	1✔
152	else:
153	next_bond = default_bond	1✔
154	if next_bond or zero_order_bonds:	1✔
155	mol.add_edge(anchor, idx, order=next_bond)	1✔
156	next_bond = None	1✔
157	anchor = idx	1✔
158	idx += 1	1✔
159	elif tokentype == TokenType.BRANCH_START:	1✔
160	if anchor is None:	1!
NEW 161	raise SyntaxError('You cannot start a branch before an anchor.')	×
162	branches.append(anchor)	1✔
163	elif tokentype == TokenType.BRANCH_END:	1✔
164	anchor = branches.pop()	1✔
165	elif tokentype == TokenType.BOND_TYPE:	1✔
166	if next_bond is not None:	1✔
167	raise ValueError('Previous bond (order {}) not used. '	1✔
168	'Overwritten by "{}"'.format(next_bond, token))
169	next_bond = bond_to_order[token]	1✔
170	elif tokentype == TokenType.RING_NUM:	1✔
171	if token in ring_nums:	1✔
172	jdx, order = ring_nums[token]	1✔
173	if next_bond is None and order is None:	1✔
174	if mol.nodes[idx-1].get('aromatic') and mol.nodes[jdx].get('aromatic'):	1✔
175	next_bond = default_aromatic_bond	1✔
176	else:
177	next_bond = default_bond	1✔
178	elif order is None: # Note that the check is needed,	1✔
179	next_bond = next_bond # But this could be pass.	1✔
180	elif next_bond is None:	1✔
181	next_bond = order	1✔
182	elif next_bond != order: # Both are not None	1✔
183	raise ValueError('Conflicting bond orders for ring '	1✔
184	'between indices {}'.format(token))
185	# idx is the index of the next atom we're adding. So: -1.
186	if mol.has_edge(idx-1, jdx):	1✔
187	raise ValueError('Edge specified by marker {} already '	1✔
188	'exists'.format(token))
189	if idx-1 == jdx:	1✔
190	raise ValueError('Marker {} specifies a bond between an '	1✔
191	'atom and itself'.format(token))
192	if next_bond or zero_order_bonds:	1!
193	mol.add_edge(idx - 1, jdx, order=next_bond)	1✔
194	# we need to keep track of ring bonds here for the
195	# chirality assignment
196	if mol.nodes[idx-1].get('rs_isomer', False):	1✔
197	mol.nodes[idx-1]['rs_isomer'][1].append(jdx)	1✔
198	if mol.nodes[jdx].get('rs_isomer', False):	1✔
199	mol.nodes[jdx]['rs_isomer'][1].append(idx-1)	1✔
200
201	next_bond = None	1✔
202	del ring_nums[token]	1✔
203	else:
204	if idx == 0:	1✔
205	raise ValueError("Can't have a marker ({}) before an atom"	1✔
206	"".format(token))
207	# idx is the index of the next atom we're adding. So: -1.
208	ring_nums[token] = (idx - 1, next_bond)	1✔
209	next_bond = None	1✔
210	elif tokentype == TokenType.EZSTEREO: # pragma: no branch	1✔
211	ez_isomer_atoms[anchor] = token	1✔
212	ez_isomer_atoms[idx] = token	1✔
213
214	prev_token = token	1✔
215	prev_type = tokentype	1✔
216	if ring_nums and strict:	1✔
217	raise KeyError('Unmatched ring indices {}'.format(list(ring_nums.keys())))	1✔
218
219	if current_ez and strict:	1!
UNCOV 220	raise ValueError('There is an unmatched stereochemical token.')	×
221
222	if reinterpret_aromatic:	1✔
223	correct_aromatic_rings(mol, strict=strict)	1✔
224
225	# This is a bit of an overreach, we should only add implicit hydrogens to
226	# atoms in the organic subset. However, all non-organic atoms already have
227	# a hcount, so all is well.
228	fill_valence(mol)	1✔
229
230	for node in mol:	1✔
231	element = mol.nodes[node].get('element', '*')	1✔
232	if element != '*' and element not in PTE:	1✔
233	msg = f'Unknown element {element}'	1✔
234	if strict:	1!
235	raise KeyError(msg)	1✔
236	else:
237	LOGGER.warning(msg)	×
238	elif element != '*' and bonds_missing(mol, node):	1!
239	debug_smiles = write_smiles_component(nx.ego_graph(mol, node))	×
240	msg = (f'Node {node} ({format_atom(mol, node)}) has non-standard'	×
241	f' valence: ...{debug_smiles}...')
242	if strict:	×
243	raise KeyError(msg)	×
244	else:
245	LOGGER.warning(msg)	×
246
247	# post-processing of E/Z isomerism
248	annotate_ez_isomers(mol, ez_isomer_atoms)	1✔
249	# post-processing of chiral atoms
250	_mark_chiral_atoms(mol)	1✔
251
252	if explicit_hydrogen:	1✔
253	add_explicit_hydrogens(mol)	1✔
254	else:
255	remove_explicit_hydrogens(mol)	1✔
256
257	return mol	1✔

pckroon / pysmiles / 12140431916

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous