ChemAxonStandardizer

Complexity

Total Complexity

24

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	1

7 Methods

Rating	Name	Duplication	Size	Complexity
B	_transform_file()	0	15	5
A	_transform_mol()	0	3	1
A	__init__()	0	9	2
A	_transform_mols()	0	7	2
A	_transform_smis()	0	6	2
D	_transform_ser()	0	23	8
B	transform()	0	25	4

#! /usr/bin/env python

There seems to be a cyclic import (skchem.core.atom -> skchem.core.base).

There seems to be a cyclic import (skchem.core -> skchem.core.mol).

There seems to be a cyclic import (skchem -> skchem.descriptors -> skchem.descriptors.physicochemical -> skchem.descriptors.fingerprints).

There seems to be a cyclic import (skchem -> skchem.descriptors -> skchem.descriptors.fingerprints).

There seems to be a cyclic import (skchem.core -> skchem.core.bond).

There seems to be a cyclic import (skchem -> skchem.cross_validation -> skchem.cross_validation.similarity_threshold -> skchem.descriptors -> skchem.descriptors.physicochemical -> skchem.descriptors.fingerprints).

There seems to be a cyclic import (skchem -> skchem.target_prediction -> skchem.target_prediction.PIDGIN -> skchem.descriptors -> skchem.descriptors.physicochemical -> skchem.descriptors.fingerprints).

#
# Copyright (C) 2016 Rich Lewis <rl403@cam.ac.uk>
# License: 3-clause BSD

"""
## skchem.standardizers.chemaxon

Module wrapping ChemAxon Standardizer.  Must have standardizer installed and
license activated.
"""

import os
import re
from tempfile import NamedTemporaryFile
import subprocess
import logging

logger = logging.getLogger(__name__)

The name logger does not conform to the constant naming conventions ((([A-Z_][A-Z0-9_]*)|(__.*__))$).

import numpy as np

The import numpy could not be resolved.

Unused numpy imported as np

import pandas as pd

The import pandas could not be resolved.

from .. import core
from .. import io

# ideally we will programatically build this file, but for now just use it.
DEFAULT_CONFIG = os.path.join(os.path.dirname(__file__), 'default_config.xml')

class ChemAxonStandardizer(object):

    """ Object wrapping the ChemAxon Standardizer, for standardizing molecules.

    Args:
        config_path (str):
            The path of the config_file. If None, use the default one.
    """
    def __init__(self, config_path=None, warn_on_fail=True, error_on_fail=False,
                    keep_failed=False):

Wrong continued indentation.
keep_failed=False):
| ^

        if not config_path:
            config_path = DEFAULT_CONFIG
        self.config_path = config_path
        self.keep_failed = keep_failed
        self.error_on_fail = error_on_fail
        self.warn_on_fail = warn_on_fail

    def transform(self, obj):

        """ Standardize compounds.

        Args:
            obj (str, skchem.Mol, pd.Series or pd.DataFrame):
                The object to standardize as either smiles as a string, Mol, or
                a series or dataframe of these. The object to standardize.

        Returns:
            skchem.Mol or pd.Series or pd.DataFrame:
                The standardized molecule, or molecules as a series or
                dataframe.
        """

        if isinstance(obj, core.Mol):
            return self._transform_mol(obj)
        elif isinstance(obj, pd.Series):
            return self._transform_ser(obj)
        elif isinstance(obj, pd.DataFrame):
            res = self._transform_ser(obj.structure)
            return res.to_frame(name='structure').join(obj.drop('structure', axis=1))

        else:
            raise NotImplementedError

    def _transform_mol(self, mol):
        mol = pd.DataFrame([mol], index=[mol.name], columns=['structure'])
        return self.transform(mol).structure.iloc[0]

    def _transform_mols(self, X, by='sdf'):

The name X does not conform to the argument naming conventions ([a-z_][a-z0-9_]{2,30}$).

The name by does not conform to the argument naming conventions ([a-z_][a-z0-9_]{2,30}$).

        with NamedTemporaryFile() as f_in, NamedTemporaryFile() as f_out:
            getattr(io, 'write_' + by)(X, f_in.name)
            errs = self._transform_file(f_in.name, f_out.name)
            out = io.read_sdf(f_out.name).structure
        return out, errs

    def _transform_smis(self, X):

The name X does not conform to the argument naming conventions ([a-z_][a-z0-9_]{2,30}$).

        with NamedTemporaryFile() as f_in, NamedTemporaryFile() as f_out:
            X.to_csv(f_in.name, header=None, index=None)
            errs = self._transform_file(f_in.name, f_out.name)
            out = io.read_sdf(f_out.name).structure
        return out, errs

    def _transform_file(self, f_in, f_out):
        args = ['standardize', f_in,
                         '-c', self.config_path,

Wrong continued indentation.
'-c', self.config_path,
| ^

                         '-f', 'sdf',

Wrong continued indentation.
'-f', 'sdf',
| ^

                         '-o', f_out,

Wrong continued indentation.
'-o', f_out,
| ^

                         '--ignore-error']

Wrong continued indentation.
'--ignore-error']
| ^

        logger.debug('Running %s', ' '.join(args))
        sub = subprocess.Popen(args, stderr=subprocess.PIPE)
        errs = sub.stderr.read().decode('ascii')
        if len(errs):
            logger.debug('stderr from Standardizer: \n%s', errs)
            errs = errs.strip().split('\n')
            errs = [re.findall('No. ([0-9]+):', err) for err in errs]
            errs = [int(err[0]) - 1 for err in errs if len(err)]
        return errs

    def _transform_ser(self, X, y=None):

The name X does not conform to the argument naming conventions ([a-z_][a-z0-9_]{2,30}$).

The name y does not conform to the argument naming conventions ([a-z_][a-z0-9_]{2,30}$).

The argument y seems to be unused.

        # TODO: try using different serializations

TODO and FIXME comments should generally be avoided.

        if isinstance(X.iloc[0], core.Mol):
            out, errs = self._transform_mols(X)
        elif isinstance(X.iloc[0], str):
            out, errs = self._transform_smis(X)
        if errs:
            out.index = X.index.delete(errs)
            for err in errs:
                err = X.index[err]
                if self.error_on_fail:
                    raise ValueError('{} failed to standardize'.format(err))
                if self.warn_on_fail:
                    logger.warn('%s failed to standardize', err)
        else:
            out.index = X.index
        if self.keep_failed:
            out_c = X.copy()
            out_c.loc[out.index] = out
            return out_c
        else:
            return out