PhysPropConverter

Complexity

Total Complexity

25

Size/Duplication

Total Lines	107
Duplicated Lines	0 %

Test Coverage

Coverage

15.48%

Importance

Changes	1
Bugs	0	Features	1

11 Methods

Rating	Name	Duplication	Size	Complexity
A	drop_inconsistencies()	0	6	2
A	process_targets()	0	10	1
A	process_sdf()	0	7	2
A	process_mp()	0	2	1
A	process_bp()	0	2	1
B	__init__()	0	26	1
A	process_logP()	0	3	1
A	process_logS()	0	5	1
A	process_txt()	0	8	2
C	fix_temp()	0	19	10
A	extract()	0	7	3

#! /usr/bin/env python

This module should have a docstring.

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

import os
import zipfile
import logging
LOGGER = logging.getLogger(__name__)

import pandas as pd

The import pandas could not be resolved.

import numpy as np

The import numpy could not be resolved.

from ... import io
from .base import Converter, contiguous_order

from ...cross_validation import SimThresholdSplit

TXT_COLUMNS = [l.lower() for l in """CAS
Formula
Mol_Weight
Chemical_Name
WS
WS_temp
WS_type
WS_reference
LogP
LogP_temp
LogP_type
LogP_reference
VP
VP_temp
VP_type
VP_reference
DC_pKa
DC_temp
DC_type
DC_reference
henry_law Constant
HL_temp
HL_type
HL_reference
OH
OH_temp
OH_type
OH_reference
BP_pressure
MP
BP
FP""".split('\n')]

class PhysPropConverter(Converter):

This class should have a docstring.

    def __init__(self, directory, output_directory, output_filename='physprop.h5'):

The __init__ method of the super-class Converter is not called.

This function exceeds the maximum number of variables (16/15).

        output_path = os.path.join(output_directory, output_filename)

        sdf, txt = self.extract(directory)
        mols, data = self.process_sdf(sdf), self.process_txt(txt)

        LOGGER.debug('Compounds with data extracted: %s', len(data))

        data = mols.to_frame().join(data)
        data = self.drop_inconsistencies(data)

        y = self.process_targets(data)

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

        LOGGER.debug('Compounds with experimental: %s', len(y))

        data = data.ix[y.index]
        data.columns.name = 'targets'
        ms, y = data.structure, data.drop('structure', axis=1)

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

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

        cv = SimThresholdSplit(min_threshold=0.6, block_width=4000, n_jobs=-1).fit(ms)

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

        train, valid, test = cv.split((70, 15, 15))

        (ms, y, train, valid, test) = contiguous_order((ms, y, train, valid, test), (train, valid, test))

This line is too long as per the coding-style (105/100).

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

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

        splits = (('train', train), ('valid', valid), ('test', test))

        self.run(ms, y, output_path=output_path, splits=splits)

    def extract(self, directory):

This method should have a docstring.

This method could be written as a function/class method.

        LOGGER.info('Extracting from %s', directory)
        with zipfile.ZipFile(os.path.join(directory, 'phys_sdf.zip')) as f:

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

            sdf = f.extract('PhysProp.sdf')
        with zipfile.ZipFile(os.path.join(directory, 'phys_txt.zip')) as f:

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

            txt = f.extract('PhysProp.txt')
        return sdf, txt

    def process_sdf(self, path):

This method should have a docstring.

This method could be written as a function/class method.

        LOGGER.info('Processing sdf at %s', path)
        mols = io.read_sdf(path, read_props=False).structure
        mols.index = mols.apply(lambda m: m.GetProp('CAS'))
        mols.index.name = 'cas'
        LOGGER.debug('Structures extracted: %s', len(mols))
        return mols

    def process_txt(self, path):

This method should have a docstring.

This method could be written as a function/class method.

        LOGGER.info('Processing txt at %s', path)
        data = pd.read_table(path, header=None, engine='python').iloc[:, :32]
        data.columns = TXT_COLUMNS
        data_types = data.columns[[s.endswith('_type') for s in data.columns]]
        data[data_types] = data[data_types].fillna('NAN')
        data = data.set_index('cas')
        return data

    def drop_inconsistencies(self, data):

This method should have a docstring.

This method could be written as a function/class method.

        LOGGER.info('Dropping inconsistent data...')
        formula = data.structure.apply(lambda m: m.to_formula())
        LOGGER.info('Inconsistent compounds: %s', (formula != data.formula).sum())
        data = data[formula == data.formula]
        return data

    def process_targets(self, data):

This method should have a docstring.

        LOGGER.info('Dropping estimated data...')
        data = pd.concat([self.process_logS(data),
                          self.process_logP(data),
                          self.process_mp(data),
                          self.process_bp(data)], axis=1)
        LOGGER.info('Dropped compounds: %s', data.isnull().all(axis=1).sum())
        data = data[data.notnull().any(axis=1)]
        LOGGER.debug('Compounds with experimental activities: %s', len(data))
        return data

    def process_logS(self, data):

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

This method should have a docstring.

This method could be written as a function/class method.

        cleaned = pd.DataFrame(index=data.index)

The variable cleaned seems to be unused.

        S = 0.001 * data.ws / data.mol_weight

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

        logS = np.log10(S)

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

        return logS[data.ws_type == 'EXP']

    def process_logP(self, data):

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

This method should have a docstring.

This method could be written as a function/class method.

        logP = data.logp[data.logp_type == 'EXP']

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

        return logP[logP > -10]

    def process_mp(self, data):

This method should have a docstring.

        return data.mp.apply(self.fix_temp)

    def process_bp(self, data):

This method should have a docstring.

        return data.bp.apply(self.fix_temp)

    @staticmethod
    def fix_temp(s, mean_range=5):

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

This method should have a docstring.

        try:
            return float(s)
        except ValueError:
            if '<' in s or '>' in s:
                return np.nan
            s = s.strip(' dec')
            s = s.strip(' sub')
            if '-' in s and mean_range:
                rng = [float(n) for n in s.split('-')]
                if len(rng) > 2:
                    return np.nan
                if np.abs(rng[1] - rng[0]) < mean_range:
                    return (rng[0] + rng[1])/2
            try:
                return float(s)
            except ValueError:
                return np.nan



if __name__ == '__main__':
    logging.basicConfig(level=logging.INFO)
    LOGGER.info('Converting PhysProp Dataset...')
    PhysPropConverter.convert()