mandos.model.apis.pubchem_support.pubchem_models

Complexity

Total Complexity

41

Size/Duplication

Total Lines	511
Duplicated Lines	0 %

Importance

Changes

0

25 Methods

Rating	Name	Duplication	Size	Complexity
A	ComputedProperty.req_is()	0	4	2
A	Code.type_name()	0	3	1
A	ComputedProperty.as_str()	0	3	1
A	CoOccurrence.strip_pubs()	0	10	1
A	ClinicalTrialsGovUtils.known_phases()	0	3	1
A	GhsCode.find()	0	11	1
A	Codes.value()	0	3	1
A	ClinicalTrialsGovUtils.resolve_statuses()	0	14	5
A	Code.of_nullable()	0	5	2
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()	0	4	1
A	AtcCode.parts()	0	4	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	8	2
A	CoOccurrenceType.x_name()	0	9	4

from __future__ import annotations

Missing module docstring

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

import orjson

Unable to import 'orjson'

from pocketutils.core.dot_dict import NestedDotDict

Unable to import 'pocketutils.core.dot_dict'

from pocketutils.core.enums import CleverEnum

Unable to import 'pocketutils.core.enums'

from pocketutils.core.exceptions import XTypeError, XValueError

Unable to import 'pocketutils.core.exceptions'

from pocketutils.tools.string_tools import StringTools

Unable to import 'pocketutils.tools.string_tools'

from mandos.model.apis.pubchem_support._nav_fns import Mapx
from mandos.model.apis.pubchem_support._patterns import Patterns
from mandos.model.utils.setup import MandosResources

hazards = MandosResources.file("hazards.json").read_text(encoding="utf8")
hazards = NestedDotDict(orjson.loads(hazards))
hazards = {d["code"]: d for d in hazards["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 XTypeError(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]) -> __qualname__:

Undefined variable '__qualname__'

Missing function or method docstring

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)

        value = StringTools.strip_off_end(str(value).strip(), ".0").strip()
        return cls(value)

    @classmethod
    def of_nullable(cls, value: Union[None, str, int, float]) -> Optional[__qualname__]:

Missing function or method docstring

        if value is None:
            return None
        return cls.of(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(CleverEnum):

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.5,
        }

    @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 XValueError(f"Invalid status {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)

Too many instance attributes (9/7)

Missing class docstring

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

        match = Patterns.mg_per_kg_pattern.search(self.dose)
        if match is None:
            # e.g. mg/m3/2H (mass per liter per time)
            raise XValueError(f"Dose {self.dose} (acute effect {self.gid}) could not be parsed")
        scale = dict(g=1e3, gm=1e3, mg=1, ug=10e-3, ng=10e-6, pg=10e-9)[match.group(2)]
        return float(match.group(1)) * scale


@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

        match = Patterns.atc_parts_pattern.fullmatch(self.code)
        return [g for g in match.groups() if g is not None]


class DrugbankTargetType(CleverEnum):

Missing class docstring

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


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

Missing class docstring

Too many instance attributes (10/7)

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(CleverEnum):

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: 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 = Patterns.target_name_abbrev_species_pattern_1.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 = Patterns.target_name_abbrev_species_pattern_2.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)

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)

Too many instance attributes (11/7)

Missing class docstring

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",
]