mandos.model.apis.pubchem_support.pubchem_models

Complexity

Total Complexity

45

Size/Duplication

Total Lines	522
Duplicated Lines	4.6 %

Importance

Changes

0

25 Methods

Rating	Name	Duplication	Size	Complexity
A	CoOccurrence.strip_pubs()	0	10	1
A	ClinicalTrialsGovUtils.known_phases()	0	3	1
A	GhsCode.find()	0	11	1
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	ClinicalTrialsGovUtils.resolve_statuses()	0	14	5
A	Code.of_nullable()	13	13	4
A	Codes.category()	0	3	1
A	ClinicalTrialsGovUtils.known_statuses()	0	3	1
A	Bioactivity.target_name_abbrev_species()	0	22	3
A	ClinicalTrial.mapped_phase()	0	3	1
A	ClinicalTrialsGovUtils.phase_map()	0	10	1
A	Codes.subcategory()	0	3	1
A	Code.of()	11	11	3
A	AtcCode.parts()	0	5	1
A	ClinicalTrial.mapped_status()	0	3	1
A	CoOccurrenceType.id_name()	0	9	4
A	AtcCode.level()	0	3	1
A	ClinicalTrialsGovUtils.status_map()	0	16	1
A	GhsCode.level()	0	3	1
A	Codes.is_human()	0	3	1
A	AcuteEffectEntry.mg_per_kg()	0	7	2
A	CoOccurrenceType.x_name()	0	9	4

from __future__ import annotations

Missing module docstring

import enum
import re
import typing
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 pocketutils.tools.string_tools import StringTools

Unable to import 'pocketutils.tools.string_tools'

from mandos.model import MandosResources
from mandos.model.apis.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

This code seems to be duplicated in your project.

    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)
                value = StringTools.strip_off_end(str(value).strip(), ".0")
            except ArithmeticError:
                value = str(value)
                value = StringTools.strip_off_end(str(value).strip(), ".0")
        value = str(value).strip()
        return cls(value)

    @classmethod

This code seems to be duplicated in your project.

    def of_nullable(cls, value: Union[None, str, int, float]):

Missing function or method docstring

        if value is None:
            return None
        if isinstance(value, float):
            try:
                value = int(value)
                value = StringTools.strip_off_end(str(value).strip(), ".0")
            except ArithmeticError:
                value = str(value)
                value = StringTools.strip_off_end(str(value).strip(), ".0")
        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 ChemIdPlusOrganism(Code):
        """
        E.g. 'women', 'frog', 'infant', or 'domestic animals - goat/sheep'
        """

        @property
        def is_human(self) -> bool:

Missing function or method docstring

            return str(self) in {"women", "woman", "men", "man", "infant", "infants", "human"}

    class ChemIdPlusEffect(Code):
        """
        E.g. 'BEHAVIORAL: MUSCLE WEAKNESS'
        """

        @property
        def category(self) -> str:

Missing function or method docstring

            return self[: self.index(":")].strip()

        @property
        def subcategory(self) -> str:

Missing function or method docstring

            return self[self.index(":") + 1 :].strip()

    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 AcuteEffectEntry:
    gid: int
    effects: FrozenSet[Codes.ChemIdPlusEffect]
    organism: Codes.ChemIdPlusOrganism
    test_type: str
    route: str
    dose: str

    @property
    def mg_per_kg(self) -> float:

Missing function or method docstring

        # TODO: Could it ever start with just a dot; e.g. '.175'?

TODO and FIXME comments should generally be avoided.

        match = re.compile(r".+?\((\d+(?:.\d+)?) *mg/kg\)").fullmatch(self.dose)
        if match is None:
            raise ValueError(f"Dose {self.dose} (accute effect {self.gid}) could not be parsed")
        return float(match.group(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]


class DrugbankTargetType(enum.Enum):

Missing class docstring

    target = enum.auto()
    carrier = enum.auto()
    transporter = enum.auto()
    enzyme = enum.auto()


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

Too many instance attributes (10/7)

Missing class docstring

class DrugbankInteraction:
    record_id: Optional[str]
    gene_symbol: Codes.GeneId
    action: Optional[str]
    protein_id: str
    target_type: DrugbankTargetType
    target_name: str
    general_function: Optional[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 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)

Too many instance attributes (13/7)

Missing class docstring

class Bioactivity:
    assay_id: int
    assay_type: str
    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: Optional[float]
    target_name: Optional[str]
    compound_name: str

    @property
    def target_name_abbrev_species(self) -> typing.Tuple[Optional[str], str, Optional[str]]:

Missing function or method docstring

        # first, look for a species name in parentheses
        # We use \)+ at the end instead of \)
        # this is to catch cases where we have parentheses inside of the species name
        # this happens with some virus strains, for e.g.
        match = re.compile(r"^(.+?)\(([^)]+)\)+$").fullmatch(self.target_name)
        if match is None:
            species = None
            target = self.target_name
        else:
            species = match.group(2)
            target = match.group(1)
        # now try to get an abbreviation
        match = re.compile(r"^ *([^ ]+) +- +(.+)$").fullmatch(target)
        if match is None:
            abbrev = None
            name = target
        else:
            abbrev = match.group(1)
            name = match.group(2)
        return name, abbrev, species


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

Missing class docstring

Too many instance attributes (9/7)

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 ChemicalGeneInteraction:
    gene_name: Optional[Codes.GeneId]
    interactions: FrozenSet[str]
    tax_id: Optional[int]
    tax_name: Optional[str]
    pmids: FrozenSet[Codes.PubmedId]


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