Build has been set to done!

pckroon / pysmiles / 195

pending completion

Build # 195

Build Type

cron

travis-ci-com

Committed by

web-flow

Commit Message

Merge pull request #13 from pckroon/logging

Use logging module rather than print for stereo warnings

Run Details

234 of 245 branches covered (95.51%)

Branch coverage included in aggregate %.

6 of 6 new or added lines in 2 files covered. (100.0%)

423 of 426 relevant lines covered (99.3%)

5.96 hits per line

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

96.63

/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 outout graph, or be
        implicit in 'hcount' attributes.
    reinterprit_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())))

    # Time to deal with aromaticity. This is a mess, because it's not super
    # clear what aromaticity information has been provided, and what should be
    # inferred. In addition, to what extend do we want to provide a "sane"
    # molecule, even if this overrides what the SMILES string specifies?
    cycles = nx.cycle_basis(mol)
    ring_idxs = set()
    for cycle in cycles:
        ring_idxs.update(cycle)
    non_ring_idxs = set(mol.nodes) - ring_idxs
    for n_idx in non_ring_idxs:
        if mol.nodes[n_idx].get('aromatic', False):
            raise ValueError("You specified an aromatic atom outside of a"
                             " ring. This is impossible")
    
    mark_aromatic_edges(mol)
    fill_valence(mol)
    if reinterpret_aromatic:
        mark_aromatic_atoms(mol)
        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

    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
21	import logging
22
23	import networkx as nx
24
25	from .smiles_helper import (add_explicit_hydrogens, remove_explicit_hydrogens,
26	parse_atom, fill_valence, mark_aromatic_edges,
27	mark_aromatic_atoms)
28
29	LOGGER = logging.getLogger(__name__)
30
31	@enum.unique	12✔
32	class TokenType(enum.Enum):
33	"""Possible SMILES token types"""
34	ATOM = 1
35	BOND_TYPE = 2
36	BRANCH_START = 3
37	BRANCH_END = 4
38	RING_NUM = 5
39	EZSTEREO = 6
40
41
42	def _tokenize(smiles):
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()
57	smiles = iter(smiles)
58	token = ''
59	peek = None
60	while True:
61	char = peek if peek else next(smiles, '')
62	peek = None
63	if not char:	12✔
64	break
65	if char == '[':	12✔
66	token = char
67	for char in smiles:	6!
68	token += char
69	if char == ']':	12✔
70	break
71	yield TokenType.ATOM, token
72	elif char in organic_subset:	12✔
73	peek = next(smiles, '')
74	if char + peek in organic_subset:	12✔
75	yield TokenType.ATOM, char + peek
76	peek = None
77	else:
78	yield TokenType.ATOM, char
79	elif char in '-=#$:.':	12✔
80	yield TokenType.BOND_TYPE, char
81	elif char == '(':	12✔
82	yield TokenType.BRANCH_START, '('
83	elif char == ')':	12✔
84	yield TokenType.BRANCH_END, ')'
85	elif char == '%':	12✔
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, ''))
89	elif char in '/\\':	12✔
90	yield TokenType.EZSTEREO, char
91	elif char.isdigit():	6!
92	yield TokenType.RING_NUM, int(char)
93
94
95	def read_smiles(smiles, explicit_hydrogen=False, zero_order_bonds=True,
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 outout graph, or be
107	implicit in 'hcount' attributes.
108	reinterprit_aromatic : bool
109	Whether aromaticity should be determined from the created molecule,
110	instead of taken from the SMILES string.
111
112	Returns
113	-------
114	nx.Graph
115	A graph describing a molecule. Nodes will have an 'element', 'aromatic'
116	and a 'charge', and if `explicit_hydrogen` is False a 'hcount'.
117	Depending on the input, they will also have 'isotope' and 'class'
118	information.
119	Edges will have an 'order'.
120	"""
121	bond_to_order = {'-': 1, '=': 2, '#': 3, '$': 4, ':': 1.5, '.': 0}
122	mol = nx.Graph()
123	anchor = None
124	idx = 0
125	default_bond = 1
126	next_bond = None
127	branches = []
128	ring_nums = {}
129	for tokentype, token in _tokenize(smiles):	18✔
130	if tokentype == TokenType.ATOM:	12✔
131	mol.add_node(idx, **parse_atom(token))
132	if anchor is not None:	12✔
133	if next_bond is None:	12✔
134	next_bond = default_bond
135	if next_bond or zero_order_bonds:	6!
136	mol.add_edge(anchor, idx, order=next_bond)
137	next_bond = None
138	anchor = idx
139	idx += 1
140	elif tokentype == TokenType.BRANCH_START:	12✔
141	branches.append(anchor)
142	elif tokentype == TokenType.BRANCH_END:	12✔
143	anchor = branches.pop()
144	elif tokentype == TokenType.BOND_TYPE:	12✔
145	if next_bond is not None:	6!
146	raise ValueError('Previous bond (order {}) not used. '
147	'Overwritten by "{}"'.format(next_bond, token))
148	next_bond = bond_to_order[token]
149	elif tokentype == TokenType.RING_NUM:	12✔
150	if token in ring_nums:	12✔
151	jdx, order = ring_nums[token]
152	if next_bond is None and order is None:	12✔
153	next_bond = default_bond
154	elif order is None: # Note that the check is needed,	12✔
155	next_bond = next_bond # But this could be pass.
156	elif next_bond is None:	12✔
157	next_bond = order
158	elif next_bond != order: # Both are not None	12✔
159	raise ValueError('Conflicting bond orders for ring '
160	'between indices {}'.format(token))
161	# idx is the index of the next atom we're adding. So: -1.
162	if mol.has_edge(idx-1, jdx):	12✔
163	raise ValueError('Edge specified by marker {} already '
164	'exists'.format(token))
165	if idx-1 == jdx:	12✔
166	raise ValueError('Marker {} specifies a bond between an '
167	'atom and itself'.format(token))
168	if next_bond or zero_order_bonds:	6!
169	mol.add_edge(idx - 1, jdx, order=next_bond)
170	next_bond = None
171	del ring_nums[token]
172	else:
173	if idx == 0:	12✔
174	raise ValueError("Can't have a marker ({}) before an atom"
175	"".format(token))
176	# idx is the index of the next atom we're adding. So: -1.
177	ring_nums[token] = (idx - 1, next_bond)
178	next_bond = None
179	elif tokentype == TokenType.EZSTEREO:	6!
180	LOGGER.warning('E/Z stereochemical information, which is specified by "%s", will be discarded', token)
181	if ring_nums:	12✔
182	raise KeyError('Unmatched ring indices {}'.format(list(ring_nums.keys())))
183
184	# Time to deal with aromaticity. This is a mess, because it's not super
185	# clear what aromaticity information has been provided, and what should be
186	# inferred. In addition, to what extend do we want to provide a "sane"
187	# molecule, even if this overrides what the SMILES string specifies?
188	cycles = nx.cycle_basis(mol)
189	ring_idxs = set()
190	for cycle in cycles:	12✔
191	ring_idxs.update(cycle)
192	non_ring_idxs = set(mol.nodes) - ring_idxs
193	for n_idx in non_ring_idxs:	12✔
194	if mol.nodes[n_idx].get('aromatic', False):	12✔
195	raise ValueError("You specified an aromatic atom outside of a"
196	" ring. This is impossible")
197
198	mark_aromatic_edges(mol)
199	fill_valence(mol)
200	if reinterpret_aromatic:	12✔
201	mark_aromatic_atoms(mol)
202	mark_aromatic_edges(mol)
203	for idx, jdx in mol.edges:	12✔
204	if ((not mol.nodes[idx].get('aromatic', False) or	18✔
205	not mol.nodes[jdx].get('aromatic', False))
206	and mol.edges[idx, jdx].get('order', 1) == 1.5):
207	mol.edges[idx, jdx]['order'] = 1
208
209	if explicit_hydrogen:	12✔
210	add_explicit_hydrogens(mol)
211	else:
212	remove_explicit_hydrogens(mol)
213	return mol

pckroon / pysmiles / 195

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