mandos.search.pubchem.computed_property_search

Complexity

Total Complexity

6

Size/Duplication

Total Lines	60
Duplicated Lines	0 %

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	ComputedPropertySearch.__init__()	0	5	1
A	ComputedPropertySearch.data_source()	0	3	1
A	ComputedPropertySearch.find()	0	24	3
A	ComputedPropertySearch._standardize_key()	0	2	1

import abc

Missing module docstring

The import abc seems to be unused.

from dataclasses import dataclass
from typing import Sequence, Set, Optional

Unused Optional imported from typing

from pocketutils.tools.common_tools import CommonTools

Unable to import 'pocketutils.tools.common_tools'

Unused CommonTools imported from pocketutils.tools.common_tools

from mandos.model.pubchem_api import PubchemApi
from mandos.model.pubchem_support.pubchem_models import ClinicalTrialsGovUtils

Unused ClinicalTrialsGovUtils imported from mandos.model.pubchem_support.pubchem_models

from mandos.search.pubchem import PubchemHit, PubchemSearch


@dataclass(frozen=True, order=True, repr=True)

Missing class docstring

class ComputedPropertyHit(PubchemHit):
    pass


class ComputedPropertySearch(PubchemSearch[ComputedPropertyHit]):

Empty class docstring

    """"""

    def __init__(self, key: str, api: PubchemApi, descriptors: Set[str], source: str):
        super().__init__(key, api)
        self.api = api
        self.descriptors = descriptors
        self.source = source

    @property
    def data_source(self) -> str:

Missing function or method docstring

        return self.source

    def find(self, inchikey: str) -> Sequence[ComputedPropertyHit]:

Missing function or method docstring

        data = self.api.fetch_data(inchikey)
        results = []
        # we're really not going to have a case where there are two keys --
        # one with different capitalization or punctuation
        descriptors = {self._standardize_key(s) for s in self.descriptors}
        for dd in data.chemical_and_physical_properties.computed:

Variable name "dd" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

            if self._standardize_key(dd.key) in descriptors:
                results.append(
                    ComputedPropertyHit(
                        record_id=None,
                        compound_id=str(data.cid),
                        origin_inchikey=inchikey,
                        matched_inchikey=data.names_and_identifiers.inchikey,
                        compound_name=data.name,
                        predicate="has " + dd.key.lower(),
                        object_id=dd.value,
                        object_name=dd.value,
                        search_key=self.key,
                        search_class=self.search_class,
                        data_source=self.data_source,
                    )
                )
        return results

    def _standardize_key(self, key: str) -> str:

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

        return key.replace(" ", "").replace("-", "").replace("_", "").replace(".", "").lower()


__all__ = ["ComputedPropertyHit", "ComputedPropertySearch"]