mandos.search.pubchem.drugbank_ddi_search.DrugbankDdiSearch._guess_efficacy() - Code Metrics - Inspection of "feat: much better entries and logging" - dmyersturnbull/mandos - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( cdf0f7...3de8e8 )

by Douglas

created 2021-04-03 02:06 UTC

DrugbankDdiSearch._guess_efficacy() A

↳ Parent: mandos.search.pubchem.drugbank_ddi_search

Complexity

Conditions

Size

Total Lines	8
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	8
nop	2
dl	0
loc	8
rs	10
c	0
b	0
f	0

import re

from dataclasses import dataclass
from typing import Sequence, Optional

from mandos.search.pubchem import PubchemHit, PubchemSearch


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

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

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


class DrugbankDdiSearch(PubchemSearch[DrugbankDdiHit]):

    """"""

    @property
    def data_source(self) -> str:

        return "DrugBank"

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

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

            kind = self._guess_type(dd.description)
            up_or_down = self._guess_up_down(dd.description)
            spec = None
            if kind == "risk":
                spec = self._guess_adverse(dd.description)
            elif kind == "activity":
                spec = self._guess_activity(dd.description)
            elif kind == "PK":
                spec = self._guess_pk(dd.description)
            elif kind == "efficacy":
                spec = self._guess_efficacy(dd.description)
            hits.append(
                DrugbankDdiHit(
                    record_id=None,
                    origin_inchikey=inchikey,
                    matched_inchikey=data.names_and_identifiers.inchikey,
                    compound_id=str(data.cid),
                    compound_name=data.name,
                    predicate="has DDI with",
                    object_id=dd.drug_drugbank_id,
                    object_name=dd.drug_drugbank_id,
                    search_key=self.key,
                    search_class=self.search_class,
                    data_source=self.data_source,
                    type=kind,
                    effect_target=spec,
                    change=up_or_down,
                    description=dd.description,
                )
            )
        return hits

    def _guess_up_down(self, desc: str) -> str:
class Foo:
    def some_method(self, x, y):
        return x + y;
        if "increase" in desc:

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

    def _guess_efficacy(self, desc: str) -> Optional[str]:
class Foo:
    def some_method(self, x, y):
        return x + y;
        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]:
class Foo:
    def some_method(self, x, y):
        return x + y;
        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]:
class Foo:
    def some_method(self, x, y):
        return x + y;
        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]:
class Foo:
    def some_method(self, x, y):
        return x + y;
        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:
class Foo:
    def some_method(self, x, y):
        return x + y;
        for k, v in {

            "serum concentration": "PK",

            "metabolism": "PK",

            "absorption": "PK",

            "excretion": "PK",

            "risk": "risk",

            "severity": "risk",

            "adverse": "risk",

            "activities": "activity",

            "activity": "activity",

            "efficacy": "efficacy",

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


__all__ = ["DrugbankDdiHit", "DrugbankDdiSearch"]


1		import re
		0 ignored issues – show introduced 2021-03-24 04:52 UTC by Report Bug Copy Issue Report Missing module docstring Loading history...
2		from dataclasses import dataclass
3		from typing import Sequence, Optional
4
5		from mandos.search.pubchem import PubchemHit, PubchemSearch
6
7
8		@dataclass(frozen=True, order=True, repr=True)
		0 ignored issues – show Documentation introduced 2021-03-24 04:52 UTC by Report Bug Copy Issue Report Empty class docstring Loading history...
9		class DrugbankDdiHit(PubchemHit):
10		""""""
11
12		type: str
13		effect_target: Optional[str]
14		change: Optional[str]
15		description: str
16
17
18		class DrugbankDdiSearch(PubchemSearch[DrugbankDdiHit]):
		0 ignored issues – show Documentation introduced 2021-03-24 04:52 UTC by Report Bug Copy Issue Report Empty class docstring Loading history...
19		""""""
20
21		@property
22		def data_source(self) -> str:
		0 ignored issues – show introduced 2021-03-24 04:52 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
23		return "DrugBank"
24
25		def find(self, inchikey: str) -> Sequence[DrugbankDdiHit]:
		0 ignored issues – show introduced 2021-03-24 04:52 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
26		data = self.api.fetch_data(inchikey)
27		hits = []
28		for dd in data.biomolecular_interactions_and_pathways.drugbank_ddis:
		0 ignored issues – show Coding Style Naming introduced 2021-04-03 02:07 UTC by Report Bug Copy Issue Report 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) This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history...
29		kind = self._guess_type(dd.description)
30		up_or_down = self._guess_up_down(dd.description)
31		spec = None
32		if kind == "risk":
33		spec = self._guess_adverse(dd.description)
34		elif kind == "activity":
35		spec = self._guess_activity(dd.description)
36		elif kind == "PK":
37		spec = self._guess_pk(dd.description)
38		elif kind == "efficacy":
39		spec = self._guess_efficacy(dd.description)
40		hits.append(
41		DrugbankDdiHit(
42		record_id=None,
43		origin_inchikey=inchikey,
44		matched_inchikey=data.names_and_identifiers.inchikey,
45		compound_id=str(data.cid),
46		compound_name=data.name,
47		predicate="has DDI with",
48		object_id=dd.drug_drugbank_id,
49		object_name=dd.drug_drugbank_id,
50		search_key=self.key,
51		search_class=self.search_class,
52		data_source=self.data_source,
53		type=kind,
54		effect_target=spec,
55		change=up_or_down,
56		description=dd.description,
57		)
58		)
59		return hits
60
61		def _guess_up_down(self, desc: str) -> str:
		0 ignored issues – show Coding Style introduced 2021-04-03 02:07 UTC by Report Bug Copy Issue Report This method could be written as a function/class method. If a method does not access any attributes of the class, it could also be implemented as a function or static method. This can help improve readability. For example class Foo: def some_method(self, x, y): return x + y; could be written as class Foo: @classmethod def some_method(cls, x, y): return x + y; Loading history...
62		if "increase" in desc:
		0 ignored issues – show unused-code introduced 2021-04-03 02:07 UTC by Report Bug Copy Issue Report Unnecessary "elif" after "return" Loading history...
63		return "increase"
64		elif "decrease" in desc:
65		return "decrease"
66		return "unknown"
67
68		def _guess_efficacy(self, desc: str) -> Optional[str]:
		0 ignored issues – show Coding Style introduced 2021-04-03 02:07 UTC by Report Bug Copy Issue Report This method could be written as a function/class method. If a method does not access any attributes of the class, it could also be implemented as a function or static method. This can help improve readability. For example class Foo: def some_method(self, x, y): return x + y; could be written as class Foo: @classmethod def some_method(cls, x, y): return x + y; Loading history...
69		match = re.compile("efficacy of (.+)").search(desc)
70		if match is None or match.group(1) is None:
71		return None
72		split = match.group(1).split(" can")
73		if len(split) != 2:
74		return None
75		return split[0].strip()
76
77	View Code Duplication	def _guess_activity(self, desc: str) -> Optional[str]:
		0 ignored issues – show Duplication introduced 2021-04-03 02:07 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history... Coding Style introduced 2021-04-03 02:07 UTC by Report Bug Copy Issue Report This method could be written as a function/class method. If a method does not access any attributes of the class, it could also be implemented as a function or static method. This can help improve readability. For example class Foo: def some_method(self, x, y): return x + y; could be written as class Foo: @classmethod def some_method(cls, x, y): return x + y; Loading history...
78		match = re.compile("may increase the (.+)").search(desc)
79		if match is None or match.group(1) is None:
80		match = re.compile("may decrease the (.+)").search(desc)
81		if match is None or match.group(1) is None:
82		return None
83		split = re.compile("activities").split(match.group(1))
84		if len(split) != 2:
85		return None
86		return split[0].strip()
87
88	View Code Duplication	def _guess_adverse(self, desc: str) -> Optional[str]:
		0 ignored issues – show Coding Style introduced 2021-04-03 02:07 UTC by Report Bug Copy Issue Report This method could be written as a function/class method. If a method does not access any attributes of the class, it could also be implemented as a function or static method. This can help improve readability. For example class Foo: def some_method(self, x, y): return x + y; could be written as class Foo: @classmethod def some_method(cls, x, y): return x + y; Loading history... Duplication introduced 2021-04-03 02:07 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
89		match = re.compile(" risk or severity of (.+)").search(desc)
90		if match is None or match.group(1) is None:
91		match = re.compile(" risk of (.+)").search(desc)
92		if match is None or match.group(1) is None:
93		return None
94		split = re.compile(" (?:can)\|(?:may) be").split(match.group(1))
95		if len(split) != 2:
96		return None
97		return split[0].strip()
98
99		def _guess_pk(self, desc: str) -> Optional[str]:
		0 ignored issues – show Coding Style introduced 2021-04-03 02:07 UTC by Report Bug Copy Issue Report This method could be written as a function/class method. If a method does not access any attributes of the class, it could also be implemented as a function or static method. This can help improve readability. For example class Foo: def some_method(self, x, y): return x + y; could be written as class Foo: @classmethod def some_method(cls, x, y): return x + y; Loading history...
100		match = re.compile("^The (.+)").search(desc)
101		if match is not None and match.group(1) is not None:
102		split = re.compile("can be").split(match.group(1))
103		if len(split) == 2:
104		return split[0].strip()
105		# try another way
106		match = re.compile("may increase the (.+)").search(desc)
107		if match is None or match.group(1) is None:
108		match = re.compile("may decrease the (.+)").search(desc)
109		if match is None or match.group(1) is None:
110		return None
111		split = re.compile("which").split(match.group(1))
112		if len(split) != 2:
113		return None
114		return split[0].strip()
115
116		def _guess_type(self, desc: str) -> str:
		0 ignored issues – show Coding Style introduced 2021-04-03 02:07 UTC by Report Bug Copy Issue Report This method could be written as a function/class method. If a method does not access any attributes of the class, it could also be implemented as a function or static method. This can help improve readability. For example class Foo: def some_method(self, x, y): return x + y; could be written as class Foo: @classmethod def some_method(cls, x, y): return x + y; Loading history...
117		for k, v in {
		0 ignored issues – show Coding Style Naming introduced 2021-04-03 02:07 UTC by Report Bug Copy Issue Report 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) This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history...
118		"serum concentration": "PK",
		0 ignored issues – show Coding Style introduced 2021-04-03 02:07 UTC by Report Bug Copy Issue Report Wrong hanging indentation before block (add 4 spaces). Loading history...
119		"metabolism": "PK",
		0 ignored issues – show Coding Style introduced 2021-04-03 02:07 UTC by Report Bug Copy Issue Report Wrong hanging indentation before block (add 4 spaces). Loading history...
120		"absorption": "PK",
		0 ignored issues – show Coding Style introduced 2021-04-03 02:07 UTC by Report Bug Copy Issue Report Wrong hanging indentation before block (add 4 spaces). Loading history...
121		"excretion": "PK",
		0 ignored issues – show Coding Style introduced 2021-04-03 02:07 UTC by Report Bug Copy Issue Report Wrong hanging indentation before block (add 4 spaces). Loading history...
122		"risk": "risk",
		0 ignored issues – show Coding Style introduced 2021-04-03 02:07 UTC by Report Bug Copy Issue Report Wrong hanging indentation before block (add 4 spaces). Loading history...
123		"severity": "risk",
		0 ignored issues – show Coding Style introduced 2021-04-03 02:07 UTC by Report Bug Copy Issue Report Wrong hanging indentation before block (add 4 spaces). Loading history...
124		"adverse": "risk",
		0 ignored issues – show Coding Style introduced 2021-04-03 02:07 UTC by Report Bug Copy Issue Report Wrong hanging indentation before block (add 4 spaces). Loading history...
125		"activities": "activity",
		0 ignored issues – show Coding Style introduced 2021-04-03 02:07 UTC by Report Bug Copy Issue Report Wrong hanging indentation before block (add 4 spaces). Loading history...
126		"activity": "activity",
		0 ignored issues – show Coding Style introduced 2021-04-03 02:07 UTC by Report Bug Copy Issue Report Wrong hanging indentation before block (add 4 spaces). Loading history...
127		"efficacy": "efficacy",
		0 ignored issues – show Coding Style introduced 2021-04-03 02:07 UTC by Report Bug Copy Issue Report Wrong hanging indentation before block (add 4 spaces). Loading history...
128		}.items():
129		if k in desc:
130		return v
131		return "unknown"
132
133
134		__all__ = ["DrugbankDdiHit", "DrugbankDdiSearch"]
135

dmyersturnbull / mandos

Push — main ( cdf0f7...3de8e8 )

DrugbankDdiSearch._guess_efficacy() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like