mandos.search.pubchem.drugbank_ddi_search

Complexity

Total Complexity

40

Size/Duplication

Total Lines	154
Duplicated Lines	12.99 %

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	DrugbankDdiSearch._guess_up_down()	0	6	3
B	DrugbankDdiSearch._guess_predicate()	0	24	6
A	DrugbankDdiSearch.find()	0	25	2
A	DrugbankDdiSearch._guess_type()	0	16	3
A	DrugbankDdiSearch.data_source()	0	3	1
B	DrugbankDdiSearch._guess_activity()	10	10	6
C	DrugbankDdiSearch._guess_pk()	0	16	9
A	DrugbankDdiSearch._guess_efficacy()	0	8	4
B	DrugbankDdiSearch._guess_adverse()	10	10	6

import re

Missing module docstring

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

from loguru import logger

Unable to import 'loguru'

from mandos.model import MiscUtils

Unused MiscUtils imported from mandos.model

from mandos.model.apis.pubchem_support.pubchem_models import DrugbankDdi
from mandos.search.pubchem import PubchemHit, PubchemSearch


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

Empty class docstring

class DrugbankDdiHit(PubchemHit):
    """ """

    type: str
    effect_target: Optional[str]
    change: Optional[str]
    description: str


class DrugbankDdiSearch(PubchemSearch[DrugbankDdiHit]):

Empty class docstring

    """ """

    @property
    def data_source(self) -> str:

Missing function or method docstring

        return "DrugBank :: drug/drug interactions"

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

Missing function or method docstring

        data = self.api.fetch_data(inchikey)
        hits = []
        for dd in data.biomolecular_interactions_and_pathways.drugbank_ddis:

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)

            kind = self._guess_type(dd.description)
            up_or_down = self._guess_up_down(dd.description)
            spec, predicate, statement = self._guess_predicate(dd, kind, up_or_down)
            hits.append(
                self._create_hit(
                    inchikey=inchikey,
                    c_id=str(data.cid),
                    c_origin=inchikey,
                    c_matched=data.names_and_identifiers.inchikey,
                    c_name=data.name,
                    predicate=predicate,
                    statement=statement,
                    object_id=dd.drug_drugbank_id,
                    object_name=dd.drug_drugbank_id,
                    type=kind,
                    effect_target=spec,
                    change=up_or_down,
                    description=dd.description,
                )
            )
        return hits

    def _guess_predicate(

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

        self, dd: DrugbankDdi, kind: str, up_or_down: str

Wrong hanging indentation before block (add 4 spaces).

    ) -> Optional[Tuple[str, str, str]]:
        spec, predicate, statement = None, None, None
        if kind == "risk":
            spec = self._guess_adverse(dd.description)
            predicate = f"interaction:{kind}:risk:{up_or_down}:{spec}"
            statement = f"{kind} :: {up_or_down}s risk of {spec} with"
        elif kind == "activity":
            spec = self._guess_activity(dd.description)
            predicate = f"interaction:{kind}:activity:{up_or_down}:{spec}"
            statement = f"{kind} :: {up_or_down}s {spec} activity with"
        elif kind == "PK":
            spec = self._guess_pk(dd.description)
            predicate = f"interaction:{kind}:pk:{up_or_down}:{spec}"
            statement = f"{kind} :: {up_or_down}s {spec} with"
        elif kind == "efficacy":
            spec = self._guess_efficacy(dd.description)
            predicate = f"interaction:{kind}:efficacy:{up_or_down}:{spec}"
            statement = f"{kind} :: {up_or_down}s efficacy of {spec} with"
        if spec is None:
            logger.info(f"Did not extract info from '{dd.description}'")
            return None
        return spec, predicate, statement

    def _guess_up_down(self, desc: str) -> str:

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

        if "increase" in desc:

Unnecessary "elif" after "return"

            return "increase"
        elif "decrease" in desc:
            return "decrease"
        return "change"

    def _guess_efficacy(self, desc: str) -> Optional[str]:

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

        match = re.compile("efficacy of (.+)").search(desc)
        if match is None or match.group(1) is None:
            return None
        split = match.group(1).split(" can")
        if len(split) != 2:
            return None
        return split[0].strip()

    def _guess_activity(self, desc: str) -> Optional[str]:

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

This code seems to be duplicated in your project.

        match = re.compile("may increase the (.+)").search(desc)
        if match is None or match.group(1) is None:
            match = re.compile("may decrease the (.+)").search(desc)
        if match is None or match.group(1) is None:
            return None
        split = re.compile("activities").split(match.group(1))
        if len(split) != 2:
            return None
        return split[0].strip()

    def _guess_adverse(self, desc: str) -> Optional[str]:

This code seems to be duplicated in your project.

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

        match = re.compile(" risk or severity of (.+)").search(desc)
        if match is None or match.group(1) is None:
            match = re.compile(" risk of (.+)").search(desc)
            if match is None or match.group(1) is None:
                return None
        split = re.compile(" (?:can)|(?:may) be").split(match.group(1))
        if len(split) != 2:
            return None
        return split[0].strip()

    def _guess_pk(self, desc: str) -> Optional[str]:

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

        match = re.compile("^The (.+)").search(desc)
        if match is not None and match.group(1) is not None:
            split = re.compile("can be").split(match.group(1))
            if len(split) == 2:
                return split[0].strip()
        # try another way
        match = re.compile("may increase the (.+)").search(desc)
        if match is None or match.group(1) is None:
            match = re.compile("may decrease the (.+)").search(desc)
        if match is None or match.group(1) is None:
            return None
        split = re.compile("which").split(match.group(1))
        if len(split) != 2:
            return None
        return split[0].strip()

    def _guess_type(self, desc: str) -> str:

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

        for k, v in {

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

            "serum concentration": "PK",

Wrong hanging indentation before block (add 4 spaces).

            "metabolism": "PK",

Wrong hanging indentation before block (add 4 spaces).

            "absorption": "PK",

Wrong hanging indentation before block (add 4 spaces).

            "excretion": "PK",

Wrong hanging indentation before block (add 4 spaces).

            "risk": "risk",

Wrong hanging indentation before block (add 4 spaces).

            "severity": "risk",

Wrong hanging indentation before block (add 4 spaces).

            "adverse": "risk",

Wrong hanging indentation before block (add 4 spaces).

            "activities": "activity",

Wrong hanging indentation before block (add 4 spaces).

            "activity": "activity",

Wrong hanging indentation before block (add 4 spaces).

            "efficacy": "efficacy",

Wrong hanging indentation before block (add 4 spaces).

        }.items():
            if k in desc:
                return v
        return "unknown"


__all__ = ["DrugbankDdiHit", "DrugbankDdiSearch"]