mandos.model.apis.pubchem_support.pubchem_data

Complexity

Total Complexity

155

Size/Duplication

Total Lines	1066
Duplicated Lines	0 %

Importance

Changes

0

101 Methods

Rating	Name	Duplication	Size	Complexity
A	PubchemData.biological_test_results()	0	3	1
A	Classification.chembl_tree()	0	3	1
A	Toxicity._whoami()	0	3	1
A	SafetyAndHazards.ghs_codes()	0	19	1
A	PharmacologyAndBiochemistry.moa_summary_hsdb_links()	0	3	1
A	DrugAndMedicationInformation.mini()	0	3	1
A	PharmacologyAndBiochemistry.summary_drugbank_text()	0	12	1
A	PubchemData.drug_and_medication_information()	0	3	1
A	NamesAndIdentifiers.descriptor()	0	15	1
A	DrugAndMedicationInformation.dea_schedule()	0	15	1
A	PubchemDataView._classifications()	0	3	1
A	DrugAndMedicationInformation.clinical_trials()	0	19	2
A	DrugAndMedicationInformation.livertox_classes()	0	11	1
A	PubchemData.related_records()	0	3	1
A	ChemicalAndPhysicalProperties.single_property()	0	3	1
A	PharmacologyAndBiochemistry._whoami()	0	3	1
B	ChemicalAndPhysicalProperties.computed()	0	21	6
A	PubchemData.parent_or_self()	0	4	2
A	PubchemData.associated_disorders_and_diseases()	0	3	1
A	NamesAndIdentifiers.inchi()	0	3	1
A	BiomolecularInteractionsAndPathways.chemical_gene_interactions()	0	18	1
C	Literature.depositor_pubmed_articles()	0	70	9
A	BiomolecularInteractionsAndPathways._whoami()	0	3	1
A	BiomolecularInteractionsAndPathways.drugbank_ddis()	0	15	1
A	DrugAndMedicationInformation.indication_summary_drugbank()	0	12	1
A	PubchemData.toxicity()	0	3	1
A	BiologicalTestResults._whoami()	0	3	1
A	Classification.atc_tree()	0	3	1
A	NamesAndIdentifiers.inchikey()	0	3	1
A	Classification.chebi_tree()	0	3	1
A	RelatedRecords._whoami()	0	3	1
A	AssociatedDisordersAndDiseases._whoami()	0	3	1
A	PharmacologyAndBiochemistry.moa_summary_drugbank_text()	0	3	1
A	Literature.gene_cooccurrences()	0	3	1
A	PharmacologyAndBiochemistry._get_moa_links()	0	16	1
A	NamesAndIdentifiers.molecular_formula()	0	13	1
A	PubchemMiniDataView._whoami()	0	3	1
A	TitleAndSummary.safety()	0	12	1
A	BiomolecularInteractionsAndPathways.drugbank_legal_groups()	0	7	3
A	ChemicalAndPhysicalProperties._extract_kvr()	0	6	3
A	PharmacologyAndBiochemistry.atc()	0	14	1
A	PubchemDataView.to_json()	0	12	2
A	PubchemData.pharmacology_and_biochemistry()	0	3	1
A	DrugAndMedicationInformation.indication_summary_livertox()	0	12	1
A	PubchemData.title_and_summary()	0	3	1
A	Patents._whoami()	0	3	1
A	PubchemDataView._has_ref()	0	2	2
A	PharmacologyAndBiochemistry.biochem_reactions()	0	4	1
A	PubchemMiniDataView._mini()	0	3	1
A	ChemicalAndPhysicalProperties.xlogp3()	0	3	1
A	Classification._whoami()	0	3	1
A	PubchemData.literature()	0	3	1
A	PubchemDataView._refs()	0	3	1
B	Literature._get_cooccurrences()	0	41	3
A	Literature.disease_cooccurrences()	0	3	1
A	PubchemData.chemical_and_physical_properties()	0	3	1
A	PharmacologyAndBiochemistry.summary_ncit_links()	0	18	1
A	RelatedRecords.parent()	0	13	2
A	DrugAndMedicationInformation.hsdb_uses()	0	13	2
A	Classification.g2p_tree()	0	3	1
A	PubchemDataView._toc()	0	3	1
A	NamesAndIdentifiers.modify_date()	0	13	1
A	PubchemData.biomolecular_interactions_and_pathways()	0	3	1
A	DrugAndMedicationInformation.dea_class()	0	11	1
A	PharmacologyAndBiochemistry.mesh()	0	9	1
A	Classification.cpdat_tree()	0	3	1
A	NamesAndIdentifiers._whoami()	0	3	1
A	ChemicalAndPhysicalProperties.charge()	0	3	1
A	Classification.mesh_tree()	0	3	1
A	Toxicity.acute_effects()	0	16	1
A	PubchemDataView.cid()	0	9	2
A	PharmacologyAndBiochemistry.moa_summary_hsdb_text()	0	3	1
A	Literature._whoami()	0	3	1
A	PubchemData.name()	0	3	1
A	PubchemData.safety_and_hazards()	0	3	1
A	PharmacologyAndBiochemistry._get_moa_text()	0	11	1
A	PubchemData.classification()	0	3	1
A	PharmacologyAndBiochemistry.moa_summary_drugbank_links()	0	3	1
A	ChemicalAndPhysicalProperties.mol_weight()	0	6	2
A	ChemicalAndPhysicalProperties.tpsa()	0	6	2
A	SafetyAndHazards._whoami()	0	3	1
A	ChemicalAndPhysicalProperties.complexity_rating()	0	3	1
F	ChemicalAndPhysicalProperties._extract_value_and_unit()	0	27	14
B	Literature._guess_neighbor()	0	11	6
A	ChemicalAndPhysicalProperties._whoami()	0	3	1
A	Classification.dea()	0	3	1
A	Classification.chemid()	0	3	1
B	BiologicalTestResults.bioactivity()	0	25	6
A	NamesAndIdentifiers.create_date()	0	13	1
A	BiomolecularInteractionsAndPathways.drugbank_interactions()	0	21	4
A	PubchemDataView._links()	0	3	1
A	Patents.associated_disorders_and_diseases()	0	9	1
A	PubchemDataView.__init__()	0	2	1
A	PubchemData.names_and_identifiers()	0	3	1
A	PubchemData.parent_or_none()	0	3	1
A	AssociatedDisordersAndDiseases.associated_disorders_and_diseases()	0	15	1
A	PharmacologyAndBiochemistry.summary_ncit_text()	0	13	1
A	PubchemDataView._tables()	0	3	1
A	Literature.chemical_cooccurrences()	0	3	1
A	BiomolecularInteractionsAndPathways.drug_gene_interactions()	0	18	1
A	PubchemDataView._nav()	0	3	1

"""

Too many lines in module (1066/1000)

PubChem data views and processors.
"""
from __future__ import annotations

import abc
import re
from datetime import date, datetime
from typing import Mapping, Optional, Sequence, Union, FrozenSet, Any, Dict
from typing import Tuple as Tup
from urllib.parse import unquote as url_unescape

import orjson

Unable to import 'orjson'

from pocketutils.core.dot_dict import NestedDotDict

Unable to import 'pocketutils.core.dot_dict'

from pocketutils.tools.common_tools import CommonTools

Unable to import 'pocketutils.tools.common_tools'

from pocketutils.tools.string_tools import StringTools

Unable to import 'pocketutils.tools.string_tools'

from mandos import logger

# noinspection PyProtectedMember
from mandos.model import MultipleMatchesError
from mandos.model.apis.pubchem_support._nav_fns import Filter, Mapx, Flatmap

# noinspection PyProtectedMember
from mandos.model.apis.pubchem_support._nav_model import FilterFn

# noinspection PyProtectedMember
from mandos.model.apis.pubchem_support._nav import JsonNavigator
from mandos.model.apis.pubchem_support.pubchem_models import (
    ComputedProperty,
    Codes,
    CoOccurrenceType,
    ClinicalTrial,
    GhsCode,
    AssociatedDisorder,
    AtcCode,
    DrugbankInteraction,
    DrugbankDdi,
    PubmedEntry,
    Publication,
    Activity,
    CoOccurrence,
    DrugGeneInteraction,
    ChemicalGeneInteraction,
    Bioactivity,
    AcuteEffectEntry,
    DrugbankTargetType,
)


class Misc:

Missing class docstring

    empty_frozenset = frozenset([])


class Patterns:

Missing class docstring

    ghs_code = re.compile(r"((?:H\d+)(?:\+H\d+)*)")
    ghs_code_singles = re.compile(r"(H\d+)")
    pubchem_compound_url = re.compile(r"^https:\/\/pubchem\.ncbi\.nlm\.nih\.gov\/compound\/(.+)$")
    atc_codes = re.compile(r"([A-Z])([0-9]{2})?([A-Z])?([A-Z])?([A-Z])?")
    mesh_codes = re.compile(r"[A-Z]")


class PubchemDataView(metaclass=abc.ABCMeta):

Empty class docstring

    """ """

    def __init__(self, data: NestedDotDict):
        self._data = data

    def to_json(self) -> str:

Missing function or method docstring

        def default(obj: Any) -> Any:

Either all return statements in a function should return an expression, or none of them should.

            if isinstance(obj, NestedDotDict):
                # noinspection PyProtectedMember
                return dict(obj._x)

It seems like _x was declared protected and should not be accessed from this context.

        # noinspection PyProtectedMember
        data = dict(self._data._x)

It seems like _x was declared protected and should not be accessed from this context.

        encoded = orjson.dumps(data, default=default, option=orjson.OPT_INDENT_2)
        encoded = encoded.decode(encoding="utf8")
        encoded = StringTools.retab(encoded, 2)
        return encoded

    @property
    def cid(self) -> int:

Missing function or method docstring

        if self._data["record.RecordType"] != "CID":
            raise ValueError(
                "RecordType for {} is {}".format(
                    self._data["record.RecordNumber"], self._data["record.RecordType"]
                )
            )
        return self._data["record.RecordNumber"]

    @property
    def _toc(self) -> JsonNavigator:
        return self._nav / "Section" % "TOCHeading"

    @property
    def _tables(self) -> JsonNavigator:
        return JsonNavigator.create(self._data) / "external_tables"

    @property
    def _links(self) -> JsonNavigator:
        return JsonNavigator.create(self._data) / "link_sets"

    @property
    def _classifications(self) -> JsonNavigator:
        return self._nav / "classifications"

    @property
    def _nav(self) -> JsonNavigator:
        return JsonNavigator.create(self._data) / "record"

    @property
    def _refs(self) -> Mapping[int, str]:
        return {z["ReferenceNumber"]: z["SourceName"] for z in (self._nav / "Reference").contents}

    def _has_ref(self, name: str) -> FilterFn:
        return FilterFn(lambda dot: self._refs.get(dot.get_as("ReferenceNumber", int)) == name)


class PubchemMiniDataView(PubchemDataView, metaclass=abc.ABCMeta):

Empty class docstring

    """ """

    @property
    def _whoami(self) -> str:
        raise NotImplementedError()

    @property
    def _mini(self) -> JsonNavigator:
        return self._toc / self._whoami / "Section" % "TOCHeading"


class TitleAndSummary(PubchemDataView):

Empty class docstring

    """ """

    @property
    def safety(self) -> FrozenSet[str]:

Missing function or method docstring

        return (
            self._toc
            / "Chemical Safety"
            / "Information"
            / self._has_ref("PubChem")
            / "Value"
            / "StringWithMarkup"
            / "Markup"
            >> "Extra"
        ).to_set


class RelatedRecords(PubchemMiniDataView):

Empty class docstring

    """ """

    @property
    def _whoami(self) -> str:
        return "Related Records"

    @property
    def parent(self) -> Optional[int]:

Missing function or method docstring

        parent = (
            self._mini
            / "Parent Compound"
            / "Information"
            / "Value"
            / "StringWithMarkup"
            // ["String"]
            // Flatmap.require_only()
        )
        parent = parent / Mapx.extract_group_1(r"CID (\d+) +.*") // Flatmap.request_only()
        return self.cid if parent.get is None else int(parent.get)


class NamesAndIdentifiers(PubchemMiniDataView):

Empty class docstring

    """ """

    @property
    def _whoami(self) -> str:
        return "Names and Identifiers"

    @property
    def inchikey(self) -> str:

Missing function or method docstring

        return self.descriptor("InChI Key")

    @property
    def inchi(self) -> str:

Missing function or method docstring

        return self.descriptor("InChI")

    @property
    def molecular_formula(self) -> str:

Missing function or method docstring

        return (
            self._mini
            / "Molecular Formula"
            / "Information"
            / self._has_ref("PubChem")
            / "Value"
            / "StringWithMarkup"
            // ["String"]
            // Flatmap.require_only()
            // Flatmap.require_only()
        ).get

    def descriptor(self, key: str) -> str:

Missing function or method docstring

        return (
            self._mini
            / "Computed Descriptors"
            / "Section"
            % "TOCHeading"
            / key
            / "Information"
            / self._has_ref("PubChem")
            / "Value"
            / "StringWithMarkup"
            // ["String"]
            // Flatmap.require_only()
            // Flatmap.require_only()
        ).get

    @property
    def create_date(self) -> date:

Missing function or method docstring

        return (
            self._toc
            / "Create Date"
            / "Information"
            / self._has_ref("PubChem")
            / "Value"
            // ["DateISO8601"]
            // Flatmap.require_only()
            / date.fromisoformat
            // Flatmap.require_only()
        ).get

    @property
    def modify_date(self) -> date:

Missing function or method docstring

        return (
            self._toc
            / "Modify Date"
            / "Information"
            / self._has_ref("PubChem")
            / "Value"
            // ["DateISO8601"]
            // Flatmap.require_only()
            / date.fromisoformat
            // Flatmap.require_only()
        ).get


class ChemicalAndPhysicalProperties(PubchemMiniDataView):

Empty class docstring

    """ """

    @property
    def _whoami(self) -> str:
        return "Chemical and Physical Properties"

    @property
    def xlogp3(self) -> str:

Missing function or method docstring

        return self.single_property("XLogP3").req_is(float)

    @property
    def mol_weight(self) -> str:

Missing function or method docstring

        weight = self.single_property("Molecular Weight")
        if weight.unit != "g/mol":
            raise ValueError(f"Expected g/mol for weight; got {weight.unit}")
        return weight.req_is(float)

    @property
    def tpsa(self) -> str:

Missing function or method docstring

        weight = self.single_property("Topological Polar Surface Area")
        if weight.unit != "Ų":
            raise ValueError(f"Expected Ų for weight; got {weight.unit}")
        return weight.req_is(float)

    @property
    def charge(self) -> int:

Missing function or method docstring

        return self.single_property("Formal Charge", "PubChem").value

    @property
    def complexity_rating(self) -> int:

Missing function or method docstring

        return self.single_property("Complexity", "PubChem").value

    def single_property(self, key: str, ref: Optional[str] = "PubChem") -> ComputedProperty:

Missing function or method docstring

        return CommonTools.only(
            [kvr for kvr in self.computed if kvr.key == key and (ref is None or kvr.ref == ref)]
        )

    @property
    def computed(self) -> FrozenSet[ComputedProperty]:

Missing function or method docstring

        cid = self.cid
        props = {
            dot["TOCHeading"]: dot["Information"]
            for dot in (self._mini / "Computed Properties" / "Section").get
        }
        results: Dict[Tup[str, str], ComputedProperty] = {}
        for heading, info in props.items():
            for dot in info:
                try:
                    dot = NestedDotDict(dot)
                    kvr = self._extract_kvr(heading, dot)
                    if kvr is not None:
                        if (kvr.key, kvr.ref) in results:
                            raise MultipleMatchesError(f"Multiple matches for {kvr} on {cid}")
                        results[(kvr.key, kvr.ref)] = kvr
                except (KeyError, ValueError):
                    logger.debug(f"Failed on {dot} for cid {cid}")
                    raise
        return frozenset(results.values())

    def _extract_kvr(self, heading: str, dot: NestedDotDict) -> Optional[ComputedProperty]:
        if "Value" not in dot or "Reference" not in dot:
            return None
        ref = ", ".join(dot["Reference"])
        value, unit = self._extract_value_and_unit(dot["Value"])
        return ComputedProperty(heading, value, unit, ref)

    def _extract_value_and_unit(

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

        self, dot: NestedDotDict

Wrong hanging indentation before block (add 4 spaces).

    ) -> Tup[Union[None, int, str, float, bool], str]:
        value, unit = None, None
        if "Number" in dot and len(["Number"]) == 1:
            value = dot["Number"][0]
        elif "Number" in dot and len(["Number"]) > 1:
            value = ", ".join([str(s) for s in dot["Number"]])
        elif (
            "StringWithMarkup" in dot

Wrong hanging indentation before block (add 4 spaces).

            and len(dot["StringWithMarkup"]) == 1

Wrong hanging indentation before block (add 4 spaces).

            and "String" in dot["StringWithMarkup"][0]

Wrong hanging indentation before block (add 4 spaces).

        ):
            value = dot["StringWithMarkup"][0]["String"]
        elif (
            "StringWithMarkup" in dot

Wrong hanging indentation before block (add 4 spaces).

            and len(dot["StringWithMarkup"]) > 1

Wrong hanging indentation before block (add 4 spaces).

            and all(["String" in swump for swump in dot["StringWithMarkup"]])

Wrong hanging indentation before block (add 4 spaces).

        ):
            value = ", ".join([str(s) for s in dot["StringWithMarkup"]])
        else:
            value = None
        if "Unit" in dot and value is not None:
            unit = dot["Unit"]
        if isinstance(value, str):
            value = value.strip().replace("\n", "").replace("\r", "").strip()
        return value, unit


class DrugAndMedicationInformation(PubchemDataView):

Empty class docstring

    """ """

    @property
    def mini(self) -> JsonNavigator:

Missing function or method docstring

        return self._toc / "Drug and Medication Information" / "Section" % "TOCHeading"

    @property
    def indication_summary_drugbank(self) -> Optional[str]:

Missing function or method docstring

        return (
            self.mini
            / "Drug Indication"
            / "Information"
            / self._has_ref("DrugBank")
            / "Value"
            / "StringWithMarkup"
            >> "String"
            >> Flatmap.join_nonnulls()
        ).get

    @property
    def indication_summary_livertox(self) -> Optional[str]:

Missing function or method docstring

        return (
            self.mini
            / "LiverTox Summary"
            / "Information"
            / self._has_ref("LiverTox")
            / "Value"
            / "StringWithMarkup"
            >> "String"
            >> Flatmap.join_nonnulls()
        ).get

    @property
    def livertox_classes(self) -> FrozenSet[str]:

Missing function or method docstring

        return (
            self.mini
            / "Drug Classes"
            / "Information"
            / self._has_ref("LiverTox")
            / "Value"
            / "StringWithMarkup"
            >> "String"
        ).to_set

    @property
    def dea_class(self) -> FrozenSet[str]:

Missing function or method docstring

        return (
            self.mini
            / "DEA Drug Facts"
            / "Information"
            / self._has_ref("Drug Enforcement Administration (DEA)")
            / "Value"
            / "StringWithMarkup"
            >> "String"
        ).to_set

    @property
    def dea_schedule(self) -> Optional[Codes.DeaSchedule]:

Missing function or method docstring

        return (
            self.mini
            / "DEA Controlled Substances"
            / "Information"
            / self._has_ref("Drug Enforcement Administration (DEA)")
            / "Value"
            / "StringWithMarkup"
            // ["String"]
            // Flatmap.require_only()
            / Mapx.extract_group_1(r" *Schedule ([IV]+).*")
            / Codes.DeaSchedule
            // Flatmap.request_only()
        ).get

    @property
    def hsdb_uses(self) -> FrozenSet[str]:

Missing function or method docstring

        mesh = "National Library of Medicine's Medical Subject Headings"
        return (
            self.mini
            / "Therapeutic Uses"
            / "Information"
            / self._has_ref("Hazardous Substances Data Bank (HSDB)")
            / FilterFn(lambda dot: dot.req_as("Reference", str).startswith(mesh))
            / "Value"
            / "StringWithMarkup"
            >> "String"
        ).to_set

    @property
    def clinical_trials(self) -> FrozenSet[ClinicalTrial]:

Missing function or method docstring

        trials = (self._tables / "clinicaltrials").get
        objs = []
        for trial in trials:
            source = self._refs[int(trial["srcid"])]
            obj = ClinicalTrial(
                Codes.ClinicaltrialId.of(trial["ctid"]),
                trial["title"],
                frozenset([Codes.GenericDiseaseCode.of(z) for z in trial["diseaseids"].split("|")]),
                frozenset(trial["conditions"].split("|")),
                trial["phase"],
                trial["status"],
                frozenset(trial["interventions"].split("|")),
                frozenset([Codes.PubchemCompoundId.of(z) for z in trial["cids"].split("|")]),
                source,
            )
            objs.append(obj)
        return frozenset(objs)


class PharmacologyAndBiochemistry(PubchemMiniDataView):

Empty class docstring

    """ """

    @property
    def _whoami(self) -> str:
        return "Pharmacology and Biochemistry"

    @property
    def summary_drugbank_text(self) -> Optional[str]:

Missing function or method docstring

        return (
            self._mini
            / "Pharmacology"
            / "Information"
            / self._has_ref("DrugBank")
            / "Value"
            / "StringWithMarkup"
            >> "String"
            >> Flatmap.join_nonnulls()
        ).get

    @property
    def summary_ncit_text(self) -> Optional[str]:

Missing function or method docstring

        return (
            self._mini
            / "Pharmacology"
            / "Information"
            / self._has_ref("NCI Thesaurus (NCIt)")
            / Filter.key_equals("Name", "Pharmacology")
            / "Value"
            / "StringWithMarkup"
            >> "String"
            >> Flatmap.join_nonnulls()
        ).get

    @property
    def summary_ncit_links(self) -> FrozenSet[str]:

Missing function or method docstring

        return (
            self._mini
            / "Pharmacology"
            / "Information"
            / self._has_ref("NCI Thesaurus (NCIt)")
            / Filter.key_equals("Name", "Pharmacology")
            / "Value"
            / "StringWithMarkup"
            / "Markup"
            / Filter.key_equals("Type", "PubChem Internal Link")
            // ["URL"]
            // Flatmap.require_only()
            / Mapx.extract_group_1(Patterns.pubchem_compound_url)
            / url_unescape
            / Mapx.lowercase_unless_acronym()  # TODO necessary but unfortunate -- cocaine and Cocaine

This line is too long as per the coding-style (102/100).

TODO and FIXME comments should generally be avoided.

        ).to_set

    @property
    def mesh(self) -> FrozenSet[str]:

Missing function or method docstring

        return (
            self._mini
            / "MeSH Pharmacological Classification"
            / "Information"
            / self._has_ref("MeSH")
            >> "Name"
        ).to_set

    @property
    def atc(self) -> FrozenSet[AtcCode]:

Missing function or method docstring

        strs = (
            self._mini
            / "ATC Code"
            / "Information"
            / self._has_ref("WHO Anatomical Therapeutic Chemical (ATC) Classification")
            / Filter.key_equals("Name", "ATC Code")
            / "Value"
            / "StringWithMarkup"
            >> "String"
        ).to_set
        return frozenset(
            [AtcCode(s.split(" - ")[0].strip(), s.split(" - ")[1].strip()) for s in strs]
        )

    @property
    def moa_summary_drugbank_links(self) -> FrozenSet[str]:

Missing function or method docstring

        return self._get_moa_links("DrugBank")

    @property
    def moa_summary_drugbank_text(self) -> Optional[str]:

Missing function or method docstring

        return self._get_moa_text("DrugBank")

    @property
    def moa_summary_hsdb_links(self) -> FrozenSet[str]:

Missing function or method docstring

        return self._get_moa_links("Hazardous Substances Data Bank (HSDB)")

    @property
    def moa_summary_hsdb_text(self) -> Optional[str]:

Missing function or method docstring

        return self._get_moa_text("Hazardous Substances Data Bank (HSDB)")

    def _get_moa_text(self, ref: str) -> Optional[str]:
        return (
            self._mini
            / "Mechanism of Action"
            / "Information"
            / self._has_ref(ref)
            / "Value"
            / "StringWithMarkup"
            >> "String"
            >> Flatmap.join_nonnulls(sep=" /// ")
        ).get

    def _get_moa_links(self, ref: str) -> FrozenSet[str]:
        return (
            self._mini
            / "Mechanism of Action"
            / "Information"
            / self._has_ref(ref)
            / "Value"
            / "StringWithMarkup"
            / "Markup"
            / Filter.key_equals("Type", "PubChem Internal Link")
            // ["URL"]
            // Flatmap.require_only()
            / Mapx.extract_group_1(Patterns.pubchem_compound_url)
            / url_unescape
            / Mapx.lowercase_unless_acronym()  # TODO necessary but unfortunate -- cocaine and Cocaine

This line is too long as per the coding-style (102/100).

TODO and FIXME comments should generally be avoided.

        ).to_set

    @property
    def biochem_reactions(self) -> FrozenSet[str]:

Missing function or method docstring

        # TODO from multiple sources

TODO and FIXME comments should generally be avoided.

        return frozenset({s.strip() for s in (self._tables / "pathwayreaction" >> "name").to_set})


class SafetyAndHazards(PubchemMiniDataView):

Empty class docstring

    """ """

    @property
    def _whoami(self) -> str:
        return "Safety and Hazards"

    @property
    def ghs_codes(self) -> FrozenSet[GhsCode]:

Missing function or method docstring

        codes = (
            self._mini
            / "Hazards Identification"
            / "Section"
            % "TOCHeading"
            / "GHS Classification"
            / "Information"
            / self._has_ref("European Chemicals Agency (ECHA)")
            / Filter.key_equals("Name", "GHS Hazard Statements")
            / "Value"
            / "StringWithMarkup"
            // ["String"]
            // Flatmap.require_only()
            / Mapx.extract_group_1(r"^(H\d+)[ :].*$")
            // Mapx.split_and_flatten_nonnulls("+")  # TODO: how is this being used to flatten?

TODO and FIXME comments should generally be avoided.

        ).get
        return frozenset([GhsCode.find(code) for code in codes])


class Toxicity(PubchemMiniDataView):

Empty class docstring

    """ """

    @property
    def _whoami(self) -> str:
        return "Toxicity"

    @property
    def acute_effects(self) -> FrozenSet[AcuteEffectEntry]:

Missing function or method docstring

        return (
            self._tables
            / "chemidplus"
            // ["gid", "effect", "organism", "testtype", "route", "dose"]
            / [
                Mapx.get_int(nullable=True),
                Mapx.split_to(Codes.ChemIdPlusEffect.of, ";", nullable=True),
                Codes.ChemIdPlusOrganism.of,
                str,
                str,
                str,
            ]
            // Flatmap.construct(AcuteEffectEntry)
        ).to_set


class AssociatedDisordersAndDiseases(PubchemMiniDataView):

Empty class docstring

    """ """

    @property
    def _whoami(self) -> str:
        return "Associated Disorders and Diseases"

    @property
    def associated_disorders_and_diseases(self) -> FrozenSet[AssociatedDisorder]:

Missing function or method docstring

        return (
            self._tables
            / "ctd_chemical_disease"
            // ["gid", "diseaseextid", "diseasename", "directevidence", "dois"]
            / [
                str,
                Codes.MeshCode.of,
                Mapx.req_is(str),
                Mapx.req_is(str),
                Mapx.n_bar_items(null_is_zero=True),
            ]
            // Flatmap.construct(AssociatedDisorder)
        ).to_set


class Literature(PubchemMiniDataView):

Empty class docstring

    """ """

    @property
    def _whoami(self) -> str:
        return "Literature"

    @property
    def depositor_pubmed_articles(self) -> FrozenSet[PubmedEntry]:

Missing function or method docstring

        def split_mesh_headings(s: str) -> FrozenSet[Codes.MeshHeading]:

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

            # this is a nightmare
            # these fields are comma-delimited strings, but there are commas within each
            # all of the examples I've seen with this are for chem name cis/trans
            # we can fix those
            # however, there may be some left incorrectly split
            # and it's possible that we join some when we shouldn't
            # ex: 6-Cyano-7-nitroquinoxaline-2,3-dione,Animals,Anticonvulsants,Cocaine,Death, [...]
            # ex: 2,3,4,5-Tetrahydro-7,8-dihydroxy-1-phenyl-1H-3-benzazepine,Animals,Benzazepines, [...]

This line is too long as per the coding-style (104/100).

            if s is None:
                return Misc.empty_frozenset
            bits = []
            current_bit = " "
            for bit in s.split(","):
                if current_bit[-1].isdigit() and bit[0].isdigit():
                    current_bit += bit
                else:
                    bits.append(current_bit.strip())
                    current_bit = bit
            # get the one at the end
            bits.append(current_bit)
            return frozenset({b.strip() for b in bits if b.strip() != ""})

        def split_mesh_subheadings(s: Optional[str]) -> FrozenSet[Codes.MeshSubheading]:

Argument 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 is None:
                return Misc.empty_frozenset
            return frozenset({k.strip() for k in s.split(",") if k.strip() != ""})

        def split_mesh_codes(s: Optional[str]) -> FrozenSet[Codes.MeshCode]:

Argument 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 is None:
                return Misc.empty_frozenset
            z = [bit.split(" ")[0] for bit in s.split(",")]

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

            return frozenset({b.strip() for b in z if b.strip() != ""})

        def split_sources(s: Optional[str]) -> FrozenSet[str]:

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

            return frozenset(s.split(","))

        def split_cids(s: Optional[str]) -> FrozenSet[int]:

Argument 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 is None:
                return Misc.empty_frozenset
            return frozenset([int(q) for q in s.split(",")])

        def get_text(s: Optional[str]) -> Optional[str]:

Argument 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 is None:
                return None
            return StringTools.strip_brackets_and_quotes(s.strip()).strip()

        keys = {
            "pmid": Codes.PubmedId.of,
            "articletype": Mapx.req_is(str),
            "pmidsrcs": split_sources,
            "meshheadings": split_mesh_headings,
            "meshsubheadings": split_mesh_subheadings,
            "meshcodes": split_mesh_codes,
            "cids": split_cids,
            "articletitle": get_text,
            "articleabstract": get_text,
            "articlejourname": get_text,
            "articlepubdate": Mapx.int_date(),
        }
        entries = (
            self._tables
            / "pubmed"
            // list(keys.keys())
            / list(keys.values())
            // Flatmap.construct(PubmedEntry)
        ).to_set
        return entries

    @property
    def chemical_cooccurrences(self) -> FrozenSet[CoOccurrence]:

Missing function or method docstring

        return self._get_cooccurrences(CoOccurrenceType.chemical)

    @property
    def gene_cooccurrences(self) -> FrozenSet[CoOccurrence]:

Missing function or method docstring

        return self._get_cooccurrences(CoOccurrenceType.gene)

    @property
    def disease_cooccurrences(self) -> FrozenSet[CoOccurrence]:

Missing function or method docstring

        return self._get_cooccurrences(CoOccurrenceType.disease)

    def _get_cooccurrences(self, kind: CoOccurrenceType) -> FrozenSet[CoOccurrence]:
        links = (self._links / kind.x_name / "LinkDataSet" / "LinkData").get
        results = set()
        for link in links:
            link = NestedDotDict(link)
            try:
                neighbor_id = str(link["ID_2"][kind.id_name])
            except KeyError:
                raise KeyError(f"Could not find ${kind.id_name} in ${link['ID_2']}")
            neighbor_id = self._guess_neighbor(kind, neighbor_id)
            evidence = link["Evidence"][kind.x_name]
            neighbor_name = evidence["NeighborName"]
            ac = evidence["ArticleCount"]

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

            nac = evidence["NeighborArticleCount"]
            qac = evidence["QueryArticleCount"]
            score = evidence["CooccurrenceScore"]
            articles = [NestedDotDict(k) for k in evidence["Article"]]
            pubs = {
                Publication(
                    pmid=Codes.PubmedId.of(pub["PMID"]),
                    pub_date=datetime.strptime(pub["PublicationDate"].strip(), "%Y-%m-%d").date(),
                    is_review=bool(pub["IsReview"]),
                    title=pub["Title"].strip(),
                    journal=pub["Journal"].strip(),
                    relevance_score=pub.req_as("RelevanceScore", int),
                )
                for pub in articles
            }
            results.add(
                CoOccurrence(
                    neighbor_id=neighbor_id,
                    neighbor_name=neighbor_name,
                    kind=kind,
                    article_count=ac,
                    query_article_count=qac,
                    neighbor_article_count=nac,
                    score=score,
                    publications=frozenset(pubs),
                )
            )
        return frozenset(results)

    def _guess_neighbor(self, kind: CoOccurrenceType, neighbor_id: str) -> str:

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

        if kind is CoOccurrenceType.chemical:

Unnecessary "elif" after "return"

            return Codes.PubchemCompoundId(neighbor_id)
        elif kind is CoOccurrenceType.gene and neighbor_id.startswith("EC:"):
            return Codes.EcNumber(neighbor_id)
        elif kind is CoOccurrenceType.gene:
            return Codes.GeneId(neighbor_id)
        elif kind is CoOccurrenceType.disease:
            return Codes.MeshCode(neighbor_id)
        else:
            raise ValueError(f"Could not find ID type for {kind} ID {neighbor_id}")


class Patents(PubchemMiniDataView):

Empty class docstring

    """ """

    @property
    def _whoami(self) -> str:
        return "Patents"

    @property
    def associated_disorders_and_diseases(self) -> FrozenSet[AssociatedDisorder]:

Missing function or method docstring

        return (
            self._tables
            / "patent"
            // ["diseasename", "directevidence", "dois"]
            / [Mapx.req_is(str), Mapx.req_is(str), Mapx.n_bar_items()]
            // Flatmap.construct(AssociatedDisorder)
        ).to_set


class BiomolecularInteractionsAndPathways(PubchemMiniDataView):

Empty class docstring

    """ """

    @property
    def _whoami(self) -> str:
        return "Biomolecular Interactions and Pathways"

    @property
    def drug_gene_interactions(self) -> FrozenSet[DrugGeneInteraction]:

Missing function or method docstring

        # the order of this dict is crucial
        keys = {
            "genename": Mapx.req_is(str, nullable=True),
            "geneclaimname": Mapx.get_str(nullable=True),
            "interactionclaimsource": Mapx.req_is(str, nullable=True),
            "interactiontypes": Mapx.split("|", nullable=True),
            "pmids": Mapx.split(",", nullable=True),
            "dois": Mapx.split("|", nullable=True),
        }
        return (
            self._tables
            / "dgidb"
            // list(keys.keys())
            / list(keys.values())
            // Flatmap.construct(DrugGeneInteraction)
        ).to_set

    @property
    def chemical_gene_interactions(self) -> FrozenSet[ChemicalGeneInteraction]:

Missing function or method docstring

        # the order of this dict is crucial
        # YES, the | used in pmids really is different from the , used in DrugGeneInteraction
        keys = {
            "genesymbol": Codes.GenecardSymbol.of_nullable,
            "interaction": Mapx.split("|", nullable=True),
            "taxid": Mapx.get_int(nullable=True),
            "taxname": Mapx.req_is(str, True),
            "pmids": Mapx.split("|", nullable=True),
        }
        return (
            self._tables
            / "ctdchemicalgene"
            // list(keys.keys())
            / list(keys.values())
            // Flatmap.construct(ChemicalGeneInteraction)
        ).to_set

    @property
    def drugbank_interactions(self) -> FrozenSet[DrugbankInteraction]:

Missing function or method docstring

        keys = {
            "gid": (lambda f: None if f is None else str(int(f))),
            "genesymbol": Codes.GenecardSymbol.of,
            "drugaction": Mapx.req_is(str, nullable=True),
            "targetcomponentname": Mapx.req_is(str),
            "targettype": (lambda s: DrugbankTargetType[s.lower()]),
            "targetname": Mapx.req_is(str),
            "generalfunc": Mapx.req_is(str, nullable=True),
            "specificfunc": Mapx.req_is(str, nullable=True),
            "pmids": Mapx.split(",", nullable=True),
            "dois": Mapx.split("|", nullable=True),
        }
        return (
            self._tables
            / "drugbank"
            // list(keys.keys())
            / list(keys.values())
            // Flatmap.construct(DrugbankInteraction)
        ).to_set

    @property
    def drugbank_legal_groups(self) -> FrozenSet[str]:

Missing function or method docstring

        q = set()

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

        for x in (self._tables / "drugbank" // ["druggroup"] // Flatmap.require_only()).to_set:

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

            for y in x.split(";"):

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

                q.add(y.strip())
        return frozenset(q)

    @property
    def drugbank_ddis(self) -> FrozenSet[DrugbankDdi]:

Missing function or method docstring

        keys = {
            "dbid2": Codes.DrugbankCompoundId,
            "cid2": Codes.PubchemCompoundId,
            "name": Mapx.req_is(str),
            "descr": Mapx.req_is(str),
        }
        return (
            self._tables
            / "drugbankddi"
            // list(keys.keys())
            / list(keys.values())
            // Flatmap.construct(DrugbankDdi)
        ).to_set


class BiologicalTestResults(PubchemMiniDataView):

Empty class docstring

    """ """

    @property
    def _whoami(self) -> str:
        return "Biological Test Results"

    @property
    def bioactivity(self) -> FrozenSet[Bioactivity]:

Missing function or method docstring

        keys = {
            "aid": Mapx.get_int,
            "aidtype": Mapx.req_is(str, nullable=False),
            "aidsrcname": Mapx.req_is(str, nullable=True),
            "aidname": Mapx.req_is(str, nullable=True),
            "aidmdate": Mapx.int_date(nullable=True),
            "geneid": Codes.GeneId.of_nullable,
            "taxid": Mapx.str_to(str, flex_type=True, nullable=True),
            "pmid": Codes.PubmedId.of_nullable,
            "activity": (lambda s: None if s is None else Activity[s.lower()]),
            "acname": Mapx.str_to(str, nullable=True),
            "acvalue": (lambda x: None if x is None else float(x)),
            "targetname": Mapx.req_is(str, nullable=True),
            "cmpdname": Mapx.req_is(str, nullable=False),
        }
        return (
            self._tables
            / "bioactivity"
            // list(keys.keys())
            / FilterFn(lambda lst: lst[11] is not None)
            / list(keys.values())
            // Flatmap.construct(Bioactivity)
        ).to_set


class Classification(PubchemMiniDataView):

Empty class docstring

    """ """

    @property
    def _whoami(self) -> str:
        return "Classification"

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

Missing function or method docstring

        raise NotImplementedError()

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

Missing function or method docstring

        raise NotImplementedError()

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

Missing function or method docstring

        raise NotImplementedError()

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

Missing function or method docstring

        raise NotImplementedError()

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

Missing function or method docstring

        raise NotImplementedError()

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

Missing function or method docstring

        raise NotImplementedError()

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

Missing function or method docstring

        raise NotImplementedError()

    @property
    def dea(self) -> FrozenSet[str]:

Missing function or method docstring

        raise NotImplementedError()


class PubchemData(PubchemDataView):

Missing class docstring

    @property
    def name(self) -> Optional[str]:

Missing function or method docstring

        return self._data.get("record.RecordTitle")

    @property
    def title_and_summary(self) -> TitleAndSummary:

Missing function or method docstring

        return TitleAndSummary(self._data)

    @property
    def names_and_identifiers(self) -> NamesAndIdentifiers:

Missing function or method docstring

        return NamesAndIdentifiers(self._data)

    @property
    def chemical_and_physical_properties(self) -> ChemicalAndPhysicalProperties:

Missing function or method docstring

        return ChemicalAndPhysicalProperties(self._data)

    @property
    def related_records(self) -> RelatedRecords:

Missing function or method docstring

        return RelatedRecords(self._data)

    @property
    def drug_and_medication_information(self) -> DrugAndMedicationInformation:

Missing function or method docstring

        return DrugAndMedicationInformation(self._data)

    @property
    def pharmacology_and_biochemistry(self) -> PharmacologyAndBiochemistry:

Missing function or method docstring

        return PharmacologyAndBiochemistry(self._data)

    @property
    def safety_and_hazards(self) -> SafetyAndHazards:

Missing function or method docstring

        return SafetyAndHazards(self._data)

    @property
    def toxicity(self) -> Toxicity:

Missing function or method docstring

        return Toxicity(self._data)

    @property
    def literature(self) -> Literature:

Missing function or method docstring

        return Literature(self._data)

    @property
    def associated_disorders_and_diseases(self) -> AssociatedDisordersAndDiseases:

Missing function or method docstring

        return AssociatedDisordersAndDiseases(self._data)

    @property
    def biomolecular_interactions_and_pathways(self) -> BiomolecularInteractionsAndPathways:

Missing function or method docstring

        return BiomolecularInteractionsAndPathways(self._data)

    @property
    def biological_test_results(self) -> BiologicalTestResults:

Missing function or method docstring

        return BiologicalTestResults(self._data)

    @property
    def classification(self) -> Classification:

Missing function or method docstring

        return Classification(self._data)

    @property
    def parent_or_none(self) -> Optional[int]:

Missing function or method docstring

        return self.related_records.parent

    @property
    def parent_or_self(self) -> int:

Missing function or method docstring

        parent = self.related_records.parent
        return self.cid if parent is None else parent


__all__ = [
    "PubchemData",
    "TitleAndSummary",
    "RelatedRecords",
    "ChemicalAndPhysicalProperties",
    "DrugAndMedicationInformation",
    "PharmacologyAndBiochemistry",
    "SafetyAndHazards",
    "Toxicity",
    "AssociatedDisordersAndDiseases",
    "Literature",
    "NamesAndIdentifiers",
    "BiomolecularInteractionsAndPathways",
    "Classification",
]