mandos.model.pubchem_support.pubchem_models

Complexity

Total Complexity

33

Size/Duplication

Total Lines	434
Duplicated Lines	0 %

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	Code.of()	0	9	3
A	ComputedProperty.req_is()	0	4	2
A	Code.type_name()	0	3	1
A	ComputedProperty.as_str()	0	3	1
A	Codes.value()	0	3	1
A	CoOccurrenceType.id_name()	0	9	4
A	CoOccurrenceType.x_name()	0	9	4
A	ClinicalTrialsGovUtils.phase_map()	0	10	1
A	AtcCode.parts()	0	5	1
A	ClinicalTrial.mapped_phase()	0	3	1
A	AtcCode.level()	0	3	1
A	ClinicalTrialsGovUtils.known_statuses()	0	3	1
A	GhsCode.find()	0	11	1
A	ClinicalTrialsGovUtils.status_map()	0	16	1
A	ClinicalTrialsGovUtils.known_phases()	0	3	1
A	ClinicalTrial.mapped_status()	0	3	1
A	ClinicalTrialsGovUtils.resolve_statuses()	0	14	5
A	CoOccurrence.strip_pubs()	0	10	1
A	GhsCode.level()	0	3	1

from __future__ import annotations

Missing module docstring

import enum
import re
from dataclasses import dataclass
from datetime import date
from typing import Union, Optional, FrozenSet, Sequence, Mapping, Set

from pocketutils.core.dot_dict import NestedDotDict

Unable to import 'pocketutils.core.dot_dict'

from mandos.model import MandosResources, CleverEnum

Unused CleverEnum imported from mandos.model

from mandos.model.pubchem_support._nav_fns import Mapx

hazards = {
    d["code"]: d for d in NestedDotDict.read_toml(MandosResources.path("hazards.toml"))["signals"]
}


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

Missing class docstring

class ComputedProperty:
    key: str
    value: Union[int, str, float, bool]
    unit: Optional[str]
    ref: str

    def req_is(self, type_) -> Union[int, str, float, bool]:

Missing function or method docstring

        if not isinstance(self.value, type_):
            raise TypeError(f"{self.key}->{self.value} has {type(self.value)}, not {type_}")
        return self.value

    @property
    def as_str(self) -> str:

Missing function or method docstring

        return f"{self.value} {self.unit}"


class Code(str):

Missing class docstring

    @property
    def type_name(self) -> str:

Missing function or method docstring

        return self.__class__.__name__.lower()

    @classmethod
    def of(cls, value: Union[str, int, float]):

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

Missing function or method docstring

        if isinstance(value, float):
            try:
                value = int(value)
            except ArithmeticError:
                value = str(value)
        value = str(value).strip()
        return cls(value)


class Codes:
    """
    These turn out to be extremely useful for documenting return types.
    For example, ``DrugbankInteraction`` might have a ``gene`` field,
    which can be described as a ``GenecardSymbol`` if known.
    """

    class EcNumber(Code):
        """
        e.g. 'EC:4.6.1.1'
        """

    class GeneId(Code):
        """
        GeneCard, UniProt gene name, etc.
        e.g. 'slc1a2'
        """

    class ClinicaltrialId(Code):
        """
        From clinicaltrials.gov
        """

    class GenericDiseaseCode(Code):
        """
        From clinicaltrials.gov; pure int
        """

    class GenecardSymbol(GeneId):

Empty class docstring

        """"""

    class UniprotId(GeneId):

Empty class docstring

        """"""

    class PubchemCompoundId(Code):
        """
        e.g. 2352
        """

        @property
        def value(self) -> int:

Missing function or method docstring

            return int(self)

    class AtcCode(Code):

Empty class docstring

        """"""

    class PubmedId(Code):

Empty class docstring

        """"""

    class Doi(Code):

Empty class docstring

        """"""

    class MeshCode(Code):

Empty class docstring

        """"""

    class PdbId(Code):

Empty class docstring

        """"""

    class MeshHeading(Code):

Empty class docstring

        """"""

    class MeshSubheading(Code):

Empty class docstring

        """"""

    class DrugbankCompoundId(Code):

Empty class docstring

        """"""

    class DeaSchedule(Code):

Empty class docstring

        """"""

        @property
        def value(self) -> int:

Missing function or method docstring

            return Mapx.roman_to_arabic(1, 5)(self)

    class GhsCode(Code):

Empty class docstring

        """"""


class CoOccurrenceType(enum.Enum):

Missing class docstring

    chemical = enum.auto()
    gene = enum.auto()
    disease = enum.auto()

    @property
    def x_name(self) -> str:

Missing function or method docstring

        if self is CoOccurrenceType.chemical:

Unnecessary "elif" after "return"

            return "ChemicalNeighbor"
        elif self is CoOccurrenceType.gene:
            return "ChemicalGeneSymbolNeighbor"
        elif self is CoOccurrenceType.disease:
            return "ChemicalDiseaseNeighbor"
        raise AssertionError(f"{self} not found!!")

    @property
    def id_name(self) -> str:

Missing function or method docstring

        if self is CoOccurrenceType.chemical:

Unnecessary "elif" after "return"

            return "CID"
        elif self is CoOccurrenceType.gene:
            return "GeneSymbol"
        elif self is CoOccurrenceType.disease:
            return "MeSH"
        raise AssertionError(f"{self} not found!!")


class ClinicalTrialsGovUtils:

Missing class docstring

    @classmethod
    def phase_map(cls) -> Mapping[str, float]:

Missing function or method docstring

        return {
            "Phase 4": 4,
            "Phase 3": 3,
            "Phase 2": 2,
            "Phase 1": 1,
            "Early Phase 1": 1.5,
            "Phase 2/Phase 3": 2.5,
            "N/A": 0,
        }

    @classmethod
    def known_phases(cls) -> Set[float]:

Missing function or method docstring

        return set(cls.phase_map().values())

    @classmethod
    def resolve_statuses(cls, st: str) -> Set[str]:

Missing function or method docstring

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

        found = set()
        for s in st.lower().split(","):

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

            s = s.strip()

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

            if s == "@all":
                match = cls.known_statuses()
            elif s in cls.known_statuses():
                match = {s}
            else:
                raise ValueError(s)
            for m in match:

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

                found.add(m)
        return found

    @classmethod
    def known_statuses(cls) -> Set[str]:

Missing function or method docstring

        return set(cls.status_map().values())

    @classmethod
    def status_map(cls) -> Mapping[str, str]:

Missing function or method docstring

        return {
            "Unknown status": "unknown",
            "Completed": "completed",
            "Terminated": "stopped",
            "Suspended": "stopped",
            "Withdrawn": "stopped",
            "Not yet recruiting": "ongoing",
            "Recruiting": "ongoing",
            "Enrolling by invitation": "ongoing",
            "Active, not recruiting": "ongoing",
            "Available": "completed",
            "No longer available": "completed",
            "Temporarily not available": "completed",
            "Approved for marketing": "completed",
        }


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

Missing class docstring

Too many instance attributes (9/7)

class ClinicalTrial:
    ctid: Codes.ClinicaltrialId
    title: str
    conditions: FrozenSet[str]
    disease_ids: FrozenSet[Codes.ClinicaltrialId]
    phase: str
    status: str
    interventions: FrozenSet[str]
    cids: FrozenSet[Codes.PubchemCompoundId]
    source: str

    @property
    def mapped_phase(self) -> float:

Missing function or method docstring

        return ClinicalTrialsGovUtils.phase_map().get(self.phase, 0)

    @property
    def mapped_status(self) -> str:

Missing function or method docstring

        return ClinicalTrialsGovUtils.status_map().get(self.status, "unknown")


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

Missing class docstring

class GhsCode:
    code: Codes.GhsCode
    statement: str
    clazz: str
    categories: FrozenSet[str]
    signal_word: str
    type: str

    @classmethod
    def find(cls, code: str) -> GhsCode:

Missing function or method docstring

        h = hazards[code]

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

        cats = h["category"]  # TODO

TODO and FIXME comments should generally be avoided.

        return GhsCode(
            code=Codes.GhsCode(code),
            statement=h["statement"],
            clazz=h["class"],
            categories=cats,
            signal_word=h["signal_word"],
            type=h["type"],
        )

    @property
    def level(self) -> int:

Missing function or method docstring

        return int(self.code[1])


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

Missing class docstring

class AssociatedDisorder:
    gid: str
    disease_id: Codes.MeshCode
    disease_name: str
    evidence_type: str
    n_refs: int


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

Missing class docstring

class AtcCode:
    code: str
    name: str

    @property
    def level(self) -> int:

Missing function or method docstring

        return len(self.parts)

    @property
    def parts(self) -> Sequence[str]:

Missing function or method docstring

        pat = re.compile(r"([A-Z])([0-9]{2})?([A-Z])?([A-Z])?([A-Z])?")
        match = pat.fullmatch(self.code)
        return [g for g in match.groups() if g is not None]


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

Missing class docstring

class DrugbankInteraction:
    gene_symbol: Codes.GeneId
    action: str
    target_name: str
    general_function: Sequence[str]
    specific_function: str
    pmids: FrozenSet[Codes.PubmedId]
    dois: FrozenSet[Codes.Doi]


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

Missing class docstring

class DrugbankDdi:
    drug_drugbank_id: Codes.DrugbankCompoundId
    drug_pubchem_id: Codes.PubchemCompoundId
    drug_drugbank_name: str
    description: str


class AssayType(enum.Enum):

Missing class docstring

    confirmatory = enum.auto()
    literature = enum.auto()


class Activity(enum.Enum):

Missing class docstring

    active = enum.auto()
    inactive = enum.auto()
    inconclusive = enum.auto()
    unspecified = enum.auto()


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

Missing class docstring

Too many instance attributes (13/7)

class Bioactivity:
    assay_id: int
    assay_type: AssayType
    assay_ref: str
    assay_name: str
    assay_made_date: date
    gene_id: Optional[Codes.GeneId]
    tax_id: Optional[int]
    pmid: Optional[Codes.PubmedId]
    activity: Optional[Activity]
    activity_name: Optional[str]
    activity_value: float
    target_name: Optional[str]
    compound_name: str


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

Too many instance attributes (9/7)

Missing class docstring

class PdbEntry:
    pdbid: Codes.PdbId
    title: str
    exp_method: str
    resolution: float
    lig_names: FrozenSet[str]
    cids: FrozenSet[Codes.PubchemCompoundId]
    uniprot_ids: FrozenSet[Codes.UniprotId]
    pmids: FrozenSet[Codes.PubmedId]
    dois: FrozenSet[Codes.Doi]


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

Missing class docstring

Too many instance attributes (11/7)

class PubmedEntry:
    pmid: Codes.PubmedId
    article_type: str
    pmidsrcs: FrozenSet[str]
    mesh_headings: FrozenSet[Codes.MeshHeading]
    mesh_subheadings: FrozenSet[Codes.MeshSubheading]
    mesh_codes: FrozenSet[Codes.MeshCode]
    cids: FrozenSet[Codes.PubchemCompoundId]
    article_title: str
    article_abstract: str
    journal_name: str
    pub_date: date


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

Missing class docstring

class Publication:
    pmid: Codes.PubmedId
    pub_date: date
    is_review: bool
    title: str
    journal: str
    relevance_score: int


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

Too many instance attributes (8/7)

Missing class docstring

class CoOccurrence:
    neighbor_id: str
    neighbor_name: str
    kind: CoOccurrenceType
    # https://pubchemdocs.ncbi.nlm.nih.gov/knowledge-panels
    article_count: int
    query_article_count: int
    neighbor_article_count: int
    score: int
    publications: FrozenSet[Publication]

    def strip_pubs(self) -> CoOccurrence:

Missing function or method docstring

        return CoOccurrence(
            self.neighbor_id,
            self.neighbor_name,
            self.kind,
            self.article_count,
            self.query_article_count,
            self.neighbor_article_count,
            self.score,
            frozenset({}),
        )


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

Empty class docstring

class DrugGeneInteraction:
    """"""

    gene_name: Optional[str]
    gene_claim_id: Optional[str]
    source: str
    interactions: FrozenSet[str]
    pmids: FrozenSet[Codes.PubmedId]
    dois: FrozenSet[Codes.Doi]


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

Missing class docstring

class CompoundGeneInteraction:
    gene_name: Optional[Codes.GeneId]
    interactions: FrozenSet[str]
    tax_name: Optional[str]
    pmids: FrozenSet[Codes.PubmedId]


__all__ = [
    "ClinicalTrial",
    "AssociatedDisorder",
    "AtcCode",
    "AssayType",
    "DrugbankInteraction",
    "DrugbankDdi",
    "Bioactivity",
    "Activity",
    "DrugGeneInteraction",
    "CompoundGeneInteraction",
    "GhsCode",
    "PubmedEntry",
    "Code",
    "Codes",
    "CoOccurrenceType",
    "CoOccurrence",
    "Publication",
    "ComputedProperty",
    "ClinicalTrialsGovUtils",
]