mandos.search.pubchem.cooccurrence_search.GeneCoOccurrenceSearch._predicate() - Code Metrics - Inspection of "feat: full set of commands and corresponding api" - dmyersturnbull/mandos - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 9ff912...d08a4e )

by Douglas

created 2021-03-21 02:05 UTC

GeneCoOccurrenceSearch._predicate() A

↳ Parent: mandos.search.pubchem.cooccurrence_search

Complexity

Conditions

Size

Total Lines	2
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

import abc

from dataclasses import dataclass
from typing import Sequence, TypeVar

from mandos.model.pubchem_api import PubchemApi
from mandos.model.pubchem_support.pubchem_data import PubchemData
from mandos.model.pubchem_support.pubchem_models import CoOccurrenceType
from mandos.search.pubchem import PubchemHit, PubchemSearch


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

class CoOccurrenceHit(PubchemHit, metaclass=abc.ABCMeta):
    score: int
    intersect_count: int
    query_count: int
    neighbor_count: int


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

class DiseaseCoOccurrenceHit(CoOccurrenceHit):
    """"""


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

class GeneCoOccurrenceHit(CoOccurrenceHit):
    """"""


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

class ChemicalCoOccurrenceHit(CoOccurrenceHit):
    """"""


H = TypeVar("H", bound=CoOccurrenceHit, covariant=True)



class CoOccurrenceSearch(PubchemSearch[H], metaclass=abc.ABCMeta):

    """"""

    def __init__(self, key: str, api: PubchemApi, min_score: int, min_articles: int):
        super().__init__(key, api)
        self.min_score = min_score
        self.min_articles = min_articles

    @classmethod
    def cooccurrence_type(cls) -> CoOccurrenceType:

        raise NotImplementedError()

    @property
    def data_source(self) -> str:

        return "PubChem"

    def _predicate(self) -> str:
        raise NotImplementedError()

    def _query(self, data: PubchemData):
        raise NotImplementedError()

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

        data = self.api.fetch_data(inchikey)
        return [
            self.__class__.get_h()(
                record_id=None,
                compound_id=str(data.cid),
                inchikey=data.names_and_identifiers.inchikey,
                compound_name=data.name,
                predicate=self._predicate(),
                object_id=dd.neighbor_id,
                object_name=dd.neighbor_name,
                score=dd.score,
                intersect_count=dd.article_count,
                query_count=dd.query_article_count,
                neighbor_count=dd.neighbor_article_count,
                search_key=self.key,
                search_class=self.search_class,
                data_source=self.data_source,
            )
            for dd in data.literature.gene_cooccurrences
            if (
                dd.score >= self.min_score
                and dd.neighbor_article_count >= self.min_articles
                and dd.query_article_count >= self.min_articles
            )
        ]


class GeneCoOccurrenceSearch(CoOccurrenceSearch[GeneCoOccurrenceHit]):

    @classmethod
    def cooccurrence_type(cls) -> CoOccurrenceType:

        return CoOccurrenceType.gene

    def _predicate(self) -> str:
class Foo:
    def some_method(self, x, y):
        return x + y;
        return "gene co-occurrence"

    def _query(self, data: PubchemData):
class Foo:
    def some_method(self, x, y):
        return x + y;
        return data.literature.gene_cooccurrences


class ChemicalCoOccurrenceSearch(CoOccurrenceSearch[ChemicalCoOccurrenceHit]):

    @classmethod
    def cooccurrence_type(cls) -> CoOccurrenceType:

        return CoOccurrenceType.chemical

    def _predicate(self) -> str:
class Foo:
    def some_method(self, x, y):
        return x + y;
        return "chemical co-occurrence"

    def _query(self, data: PubchemData):
class Foo:
    def some_method(self, x, y):
        return x + y;
        return data.literature.chemical_cooccurrences


class DiseaseCoOccurrenceSearch(CoOccurrenceSearch[DiseaseCoOccurrenceHit]):

    @classmethod
    def cooccurrence_type(cls) -> CoOccurrenceType:

        return CoOccurrenceType.disease

    def _predicate(self) -> str:
class Foo:
    def some_method(self, x, y):
        return x + y;
        return "disease co-occurrence"

    def _query(self, data: PubchemData):
class Foo:
    def some_method(self, x, y):
        return x + y;
        return data.literature.disease_cooccurrences


__all__ = [
    "GeneCoOccurrenceHit",
    "GeneCoOccurrenceSearch",
    "ChemicalCoOccurrenceSearch",
    "ChemicalCoOccurrenceHit",
    "DiseaseCoOccurrenceSearch",
    "DiseaseCoOccurrenceHit",
    "CoOccurrenceSearch",
]


1			import abc
			0 ignored issues – show introduced 2021-03-21 02:08 UTC by Report Bug Copy Issue Report Missing module docstring Loading history...
2			from dataclasses import dataclass
3			from typing import Sequence, TypeVar
4
5			from mandos.model.pubchem_api import PubchemApi
6			from mandos.model.pubchem_support.pubchem_data import PubchemData
7			from mandos.model.pubchem_support.pubchem_models import CoOccurrenceType
8			from mandos.search.pubchem import PubchemHit, PubchemSearch
9
10
11			@dataclass(frozen=True, order=True, repr=True)
			0 ignored issues – show introduced 2021-01-25 23:06 UTC by Report Bug Copy Issue Report Missing class docstring Loading history...
12			class CoOccurrenceHit(PubchemHit, metaclass=abc.ABCMeta):
13			score: int
14			intersect_count: int
15			query_count: int
16			neighbor_count: int
17
18
19			@dataclass(frozen=True, order=True, repr=True)
			0 ignored issues – show Documentation introduced 2021-03-21 02:08 UTC by Report Bug Copy Issue Report Empty class docstring Loading history...
20			class DiseaseCoOccurrenceHit(CoOccurrenceHit):
21			""""""
22
23
24			@dataclass(frozen=True, order=True, repr=True)
			0 ignored issues – show Documentation introduced 2021-03-21 02:08 UTC by Report Bug Copy Issue Report Empty class docstring Loading history...
25			class GeneCoOccurrenceHit(CoOccurrenceHit):
26			""""""
27
28
29			@dataclass(frozen=True, order=True, repr=True)
			0 ignored issues – show Documentation introduced 2021-03-21 02:08 UTC by Report Bug Copy Issue Report Empty class docstring Loading history...
30			class ChemicalCoOccurrenceHit(CoOccurrenceHit):
31			""""""
32
33
34			H = TypeVar("H", bound=CoOccurrenceHit, covariant=True)
			0 ignored issues – show Coding Style Naming introduced 2021-03-21 02:08 UTC by Report Bug Copy Issue Report Class name "H" doesn't conform to PascalCase naming style ('[^\\W\\da-z][^\\W_]+$' 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...
35
36
37			class CoOccurrenceSearch(PubchemSearch[H], metaclass=abc.ABCMeta):
			0 ignored issues – show Documentation introduced 2021-03-21 02:08 UTC by Report Bug Copy Issue Report Empty class docstring Loading history...
38			""""""
39
40			def __init__(self, key: str, api: PubchemApi, min_score: int, min_articles: int):
41			super().__init__(key, api)
42			self.min_score = min_score
43			self.min_articles = min_articles
44
45			@classmethod
46			def cooccurrence_type(cls) -> CoOccurrenceType:
			0 ignored issues – show introduced 2021-03-21 02:08 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
47			raise NotImplementedError()
48
49			@property
50			def data_source(self) -> str:
			0 ignored issues – show introduced 2021-03-21 02:08 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
51			return "PubChem"
52
53			def _predicate(self) -> str:
54			raise NotImplementedError()
55
56			def _query(self, data: PubchemData):
57			raise NotImplementedError()
58
59			def find(self, inchikey: str) -> Sequence[H]:
			0 ignored issues – show introduced 2021-03-21 02:08 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
60			data = self.api.fetch_data(inchikey)
61			return [
62			self.__class__.get_h()(
63			record_id=None,
64			compound_id=str(data.cid),
65			inchikey=data.names_and_identifiers.inchikey,
66			compound_name=data.name,
67			predicate=self._predicate(),
68			object_id=dd.neighbor_id,
69			object_name=dd.neighbor_name,
70			score=dd.score,
71			intersect_count=dd.article_count,
72			query_count=dd.query_article_count,
73			neighbor_count=dd.neighbor_article_count,
74			search_key=self.key,
75			search_class=self.search_class,
76			data_source=self.data_source,
77			)
78			for dd in data.literature.gene_cooccurrences
79			if (
80			dd.score >= self.min_score
81			and dd.neighbor_article_count >= self.min_articles
82			and dd.query_article_count >= self.min_articles
83			)
84			]
85
86
87			class GeneCoOccurrenceSearch(CoOccurrenceSearch[GeneCoOccurrenceHit]):
			0 ignored issues – show introduced 2021-03-21 02:08 UTC by Report Bug Copy Issue Report Missing class docstring Loading history...
88			@classmethod
89			def cooccurrence_type(cls) -> CoOccurrenceType:
			0 ignored issues – show introduced 2021-03-21 02:08 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
90			return CoOccurrenceType.gene
91
92			def _predicate(self) -> str:
			0 ignored issues – show Coding Style introduced 2021-03-21 02:08 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...
93			return "gene co-occurrence"
94
95			def _query(self, data: PubchemData):
			0 ignored issues – show Coding Style introduced 2021-03-21 02:08 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...
96			return data.literature.gene_cooccurrences
97
98
99			class ChemicalCoOccurrenceSearch(CoOccurrenceSearch[ChemicalCoOccurrenceHit]):
			0 ignored issues – show introduced 2021-03-21 02:08 UTC by Report Bug Copy Issue Report Missing class docstring Loading history...
100			@classmethod
101			def cooccurrence_type(cls) -> CoOccurrenceType:
			0 ignored issues – show introduced 2021-03-21 02:08 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
102			return CoOccurrenceType.chemical
103
104			def _predicate(self) -> str:
			0 ignored issues – show Coding Style introduced 2021-03-21 02:08 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...
105			return "chemical co-occurrence"
106
107			def _query(self, data: PubchemData):
			0 ignored issues – show Coding Style introduced 2021-03-21 02:08 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...
108			return data.literature.chemical_cooccurrences
109
110
111			class DiseaseCoOccurrenceSearch(CoOccurrenceSearch[DiseaseCoOccurrenceHit]):
			0 ignored issues – show introduced 2021-03-21 02:08 UTC by Report Bug Copy Issue Report Missing class docstring Loading history...
112			@classmethod
113			def cooccurrence_type(cls) -> CoOccurrenceType:
			0 ignored issues – show introduced 2021-03-21 02:08 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
114			return CoOccurrenceType.disease
115
116			def _predicate(self) -> str:
			0 ignored issues – show Coding Style introduced 2021-03-21 02:08 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			return "disease co-occurrence"
118
119			def _query(self, data: PubchemData):
			0 ignored issues – show Coding Style introduced 2021-03-21 02:08 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...
120			return data.literature.disease_cooccurrences
121
122
123			__all__ = [
124			"GeneCoOccurrenceHit",
125			"GeneCoOccurrenceSearch",
126			"ChemicalCoOccurrenceSearch",
127			"ChemicalCoOccurrenceHit",
128			"DiseaseCoOccurrenceSearch",
129			"DiseaseCoOccurrenceHit",
130			"CoOccurrenceSearch",
131			]
132

dmyersturnbull / mandos

Push — main ( 9ff912...d08a4e )

GeneCoOccurrenceSearch._predicate() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like