mandos.search.pubchem.cooccurrence_search

Complexity

Total Complexity

15

Size/Duplication

Total Lines	131
Duplicated Lines	0 %

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	DiseaseCoOccurrenceSearch.cooccurrence_type()	0	3	1
A	CoOccurrenceSearch.cooccurrence_type()	0	3	1
A	ChemicalCoOccurrenceSearch._predicate()	0	2	1
A	CoOccurrenceSearch.data_source()	0	3	1
A	DiseaseCoOccurrenceSearch._predicate()	0	2	1
A	CoOccurrenceSearch._predicate()	0	2	1
A	CoOccurrenceSearch.find()	0	24	1
A	GeneCoOccurrenceSearch._predicate()	0	2	1
A	ChemicalCoOccurrenceSearch.cooccurrence_type()	0	3	1
A	ChemicalCoOccurrenceSearch._query()	0	2	1
A	CoOccurrenceSearch.__init__()	0	4	1
A	GeneCoOccurrenceSearch.cooccurrence_type()	0	3	1
A	GeneCoOccurrenceSearch._query()	0	2	1
A	CoOccurrenceSearch._query()	0	2	1
A	DiseaseCoOccurrenceSearch._query()	0	2	1

import abc

Missing module docstring

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)

Missing class docstring

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


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

Empty class docstring

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


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

Empty class docstring

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


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

Empty class docstring

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


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

Class name "H" doesn't conform to PascalCase naming style ('[^\\W\\da-z][^\\W_]+$' pattern)

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

Empty class docstring

    """"""

    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:

Missing function or method docstring

        raise NotImplementedError()

    @property
    def data_source(self) -> str:

Missing function or method docstring

        return "PubChem"

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

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

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

Missing function or method docstring

        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]):

Missing class docstring

    @classmethod
    def cooccurrence_type(cls) -> CoOccurrenceType:

Missing function or method docstring

        return CoOccurrenceType.gene

    def _predicate(self) -> str:

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

        return "gene co-occurrence"

    def _query(self, data: PubchemData):

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

        return data.literature.gene_cooccurrences


class ChemicalCoOccurrenceSearch(CoOccurrenceSearch[ChemicalCoOccurrenceHit]):

Missing class docstring

    @classmethod
    def cooccurrence_type(cls) -> CoOccurrenceType:

Missing function or method docstring

        return CoOccurrenceType.chemical

    def _predicate(self) -> str:

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

        return "chemical co-occurrence"

    def _query(self, data: PubchemData):

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

        return data.literature.chemical_cooccurrences


class DiseaseCoOccurrenceSearch(CoOccurrenceSearch[DiseaseCoOccurrenceHit]):

Missing class docstring

    @classmethod
    def cooccurrence_type(cls) -> CoOccurrenceType:

Missing function or method docstring

        return CoOccurrenceType.disease

    def _predicate(self) -> str:

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

        return "disease co-occurrence"

    def _query(self, data: PubchemData):

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

        return data.literature.disease_cooccurrences


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