9002470624

Committed 08 May 2024 01:13PM UTC coverage: 95.468% (-2.2%) from 97.708%

Build # 9002470624

Build Type

Pull #38

travis-ci

Committed by

web-flow

Commit Message

Merge cb1c721db into 2308e2409

Pull Request Pull Request #38: init draft aromatic

Run Details

230 of 248 branches covered (92.74%)

Branch coverage included in aggregate %.

39 of 41 new or added lines in 3 files covered. (95.12%)

7 existing lines in 2 files now uncovered.

423 of 436 relevant lines covered (97.02%)

3.88 hits per line

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

95.45

/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 .smiles_helper import (add_explicit_hydrogens, remove_explicit_hydrogens,
                            parse_atom, fill_valence, mark_aromatic_edges,
                            mark_aromatic_atoms)

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


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:
                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():
            yield TokenType.RING_NUM, int(char)


def read_smiles(smiles, explicit_hydrogen=False, zero_order_bonds=True, 
                reinterpret_aromatic=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.

    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
    next_bond = None
    branches = []
    ring_nums = {}
    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:
                    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:
            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:
                    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)
                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:
            LOGGER.warning('E/Z stereochemical information, which is specified by "%s", will be discarded', token)
    if ring_nums:
        raise KeyError('Unmatched ring indices {}'.format(list(ring_nums.keys())))

    if reinterpret_aromatic:
        arom_atoms = [node for node, aromatic in mol.nodes(data='aromatic') if aromatic]
        mark_aromatic_atoms(mol, arom_atoms)
        mark_aromatic_edges(mol)
        for idx, jdx in mol.edges:
            if ((not mol.nodes[idx].get('aromatic', False) or
                    not mol.nodes[jdx].get('aromatic', False))
                    and mol.edges[idx, jdx].get('order', 1) == 1.5):
                mol.edges[idx, jdx]['order'] = 1
    else:
        mark_aromatic_edges(mol)

    fill_valence(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	"""	4✔
17	Exposes functionality needed for parsing SMILES strings.
18	"""
19
20	import enum	4✔
21	import logging	4✔
22
23	import networkx as nx	4✔
24
25	from .smiles_helper import (add_explicit_hydrogens, remove_explicit_hydrogens,	4✔
26	parse_atom, fill_valence, mark_aromatic_edges,
27	mark_aromatic_atoms)
28
29	LOGGER = logging.getLogger(__name__)	4✔
30
31	@enum.unique	4✔
32	class TokenType(enum.Enum):	4✔
33	"""Possible SMILES token types"""
34	ATOM = 1	4✔
35	BOND_TYPE = 2	4✔
36	BRANCH_START = 3	4✔
37	BRANCH_END = 4	4✔
38	RING_NUM = 5	4✔
39	EZSTEREO = 6	4✔
40
41
42	def _tokenize(smiles):	4✔
43	"""
44	Iterates over a SMILES string, yielding tokens.
45
46	Parameters
47	----------
48	smiles : iterable
49	The SMILES string to iterate over
50
51	Yields
52	------
53	tuple(TokenType, str)
54	A tuple describing the type of token and the associated data
55	"""
56	organic_subset = 'B C N O P S F Cl Br I * b c n o s p'.split()	4✔
57	smiles = iter(smiles)	4✔
58	token = ''	4✔
59	peek = None	4✔
60	while True:	2✔
61	char = peek if peek else next(smiles, '')	4✔
62	peek = None	4✔
63	if not char:	4✔
64	break	4✔
65	if char == '[':	4✔
66	token = char	4✔
67	for char in smiles:	4!
68	token += char	4✔
69	if char == ']':	4✔
70	break	4✔
71	yield TokenType.ATOM, token	4✔
72	elif char in organic_subset:	4✔
73	peek = next(smiles, '')	4✔
74	if char + peek in organic_subset:	4✔
75	yield TokenType.ATOM, char + peek	4✔
76	peek = None	4✔
77	else:
78	yield TokenType.ATOM, char	4✔
79	elif char in '-=#$:.':	4✔
80	yield TokenType.BOND_TYPE, char	4✔
81	elif char == '(':	4✔
82	yield TokenType.BRANCH_START, '('	4✔
83	elif char == ')':	4✔
84	yield TokenType.BRANCH_END, ')'	4✔
85	elif char == '%':	4✔
86	# If smiles is too short this will raise a ValueError, which is
87	# (slightly) prettier than a StopIteration.
88	yield TokenType.RING_NUM, int(next(smiles, '') + next(smiles, ''))	4✔
89	elif char in '/\\':	4✔
90	yield TokenType.EZSTEREO, char	4✔
91	elif char.isdigit():	4!
92	yield TokenType.RING_NUM, int(char)	4✔
93
94
95	def read_smiles(smiles, explicit_hydrogen=False, zero_order_bonds=True,	4✔
96	reinterpret_aromatic=True):
97	"""
98	Parses a SMILES string.
99
100	Parameters
101	----------
102	smiles : iterable
103	The SMILES string to parse. Should conform to the OpenSMILES
104	specification.
105	explicit_hydrogen : bool
106	Whether hydrogens should be explicit nodes in the output graph, or be
107	implicit in 'hcount' attributes.
108	zero_order_bonds : bool
109	Whether zero-order bonds (".") should be added as edges with an order of
110	0.
111	reinterpret_aromatic : bool
112	Whether aromaticity should be determined from the created molecule,
113	instead of taken from the SMILES string.
114
115	Returns
116	-------
117	nx.Graph
118	A graph describing a molecule. Nodes will have an 'element', 'aromatic'
119	and a 'charge', and if `explicit_hydrogen` is False a 'hcount'.
120	Depending on the input, they will also have 'isotope' and 'class'
121	information.
122	Edges will have an 'order'.
123	"""
124	bond_to_order = {'-': 1, '=': 2, '#': 3, '$': 4, ':': 1.5, '.': 0}	4✔
125	mol = nx.Graph()	4✔
126	anchor = None	4✔
127	idx = 0	4✔
128	default_bond = 1	4✔
129	next_bond = None	4✔
130	branches = []	4✔
131	ring_nums = {}	4✔
132	for tokentype, token in _tokenize(smiles):	4✔
133	if tokentype == TokenType.ATOM:	4✔
134	mol.add_node(idx, **parse_atom(token))	4✔
135	if anchor is not None:	4✔
136	if next_bond is None:	4✔
137	next_bond = default_bond	4✔
138	if next_bond or zero_order_bonds:	4✔
139	mol.add_edge(anchor, idx, order=next_bond)	4✔
140	next_bond = None	4✔
141	anchor = idx	4✔
142	idx += 1	4✔
143	elif tokentype == TokenType.BRANCH_START:	4✔
144	branches.append(anchor)	4✔
145	elif tokentype == TokenType.BRANCH_END:	4✔
146	anchor = branches.pop()	4✔
147	elif tokentype == TokenType.BOND_TYPE:	4✔
148	if next_bond is not None:	4!
149	raise ValueError('Previous bond (order {}) not used. '	×
150	'Overwritten by "{}"'.format(next_bond, token))
151	next_bond = bond_to_order[token]	4✔
152	elif tokentype == TokenType.RING_NUM:	4✔
153	if token in ring_nums:	4✔
154	jdx, order = ring_nums[token]	4✔
155	if next_bond is None and order is None:	4✔
156	next_bond = default_bond	4✔
157	elif order is None: # Note that the check is needed,	4✔
158	next_bond = next_bond # But this could be pass.	4✔
159	elif next_bond is None:	4✔
160	next_bond = order	4✔
161	elif next_bond != order: # Both are not None	4✔
162	raise ValueError('Conflicting bond orders for ring '	4✔
163	'between indices {}'.format(token))
164	# idx is the index of the next atom we're adding. So: -1.
165	if mol.has_edge(idx-1, jdx):	4✔
166	raise ValueError('Edge specified by marker {} already '	4✔
167	'exists'.format(token))
168	if idx-1 == jdx:	4✔
169	raise ValueError('Marker {} specifies a bond between an '	4✔
170	'atom and itself'.format(token))
171	if next_bond or zero_order_bonds:	4!
172	mol.add_edge(idx - 1, jdx, order=next_bond)	4✔
173	next_bond = None	4✔
174	del ring_nums[token]	4✔
175	else:
176	if idx == 0:	4✔
177	raise ValueError("Can't have a marker ({}) before an atom"	4✔
178	"".format(token))
179	# idx is the index of the next atom we're adding. So: -1.
180	ring_nums[token] = (idx - 1, next_bond)	4✔
181	next_bond = None	4✔
182	elif tokentype == TokenType.EZSTEREO:	4!
183	LOGGER.warning('E/Z stereochemical information, which is specified by "%s", will be discarded', token)	4✔
184	if ring_nums:	4✔
185	raise KeyError('Unmatched ring indices {}'.format(list(ring_nums.keys())))	4✔
186
187	if reinterpret_aromatic:	4✔
188	arom_atoms = [node for node, aromatic in mol.nodes(data='aromatic') if aromatic]	4✔
189	mark_aromatic_atoms(mol, arom_atoms)	4✔
190	mark_aromatic_edges(mol)	4✔
191	for idx, jdx in mol.edges:	4✔
192	if ((not mol.nodes[idx].get('aromatic', False) or	4!
193	not mol.nodes[jdx].get('aromatic', False))
194	and mol.edges[idx, jdx].get('order', 1) == 1.5):
UNCOV 195	mol.edges[idx, jdx]['order'] = 1	×
196	else:
197	mark_aromatic_edges(mol)	4✔
198
199	fill_valence(mol)	4✔
200
201	if explicit_hydrogen:	4✔
202	add_explicit_hydrogens(mol)	4✔
203	else:
204	remove_explicit_hydrogens(mol)	4✔
205	return mol	4✔

pckroon / pysmiles / 9002470624

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