mandos.model.apis.hmdb_support.hmdb_data.HmdbData.cas() - Code Metrics - Inspection of "fix: missing code" - dmyersturnbull/mandos - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 3a0c28...4b9dc0 )

by Douglas

created 2021-11-04 01:35 UTC

HmdbData.cas() A

↳ Parent: mandos.model.apis.hmdb_support.hmdb_data

Complexity

Conditions

Size

Total Lines	3
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	3
nop	1
dl	0
loc	3
rs	10
c	0
b	0
f	0

import math

from dataclasses import dataclass
from datetime import datetime
from functools import cached_property

from typing import Mapping, NamedTuple, Optional, Sequence

import regex

from pocketutils.core.chars import Chars

from pocketutils.core.dot_dict import NestedDotDict

from pocketutils.core.enums import FlagEnum

from pocketutils.tools.common_tools import CommonTools


from mandos.model.apis.hmdb_support.properties import PREDICTED_PROPERTIES, RULES, _Prop
from mandos.model.utils.setup import logger

_prefixes = dict(M=1e6, mM=1e3, µM=1, uM=1, nM=1e-3, pM=1e-6, fM=1e-9)
_p1 = regex.compile(r"^([0-9.]+ +\(([0-9.]+) *\- *([0-9.]+)\)$", flags=regex.V1)
_p2 = regex.compile(r"^([0-9.]+) +\+\/\- +([0-9.]+)$", flags=regex.V1)


class ConcentrationBound(NamedTuple):

    mean: float
    lower: float
    upper: float

    @property
    def std(self) -> float:

        return self.upper / 2 - self.lower / 2

    @property
    def is_symmetric(self) -> bool:

        return math.isclose(self.upper - self.mean, self.mean - self.lower)


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

class HmdbProperty:
    kind: str
    source: str
    value: str


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

class HmdbDisease:
    name: str
    omim_id: str
    n_refs: int


class PersonAge(FlagEnum):

    unknown = ()
    adults = ()
    children = ()


class PersonSex(FlagEnum):

    unknown = ()
    male = ()
    female = ()


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

class HmdbConcentration:
    specimen: str
    ages: PersonAge
    sexes: PersonSex
    condition: Optional[str]
    micromolar: Optional[ConcentrationBound]
    mg_per_kg: Optional[ConcentrationBound]

    def __post_init__(self):
        if (self.mg_per_kg is None) + (self.micromolar is None) != 1:
            raise AssertionError(
                f"Provided both micromolar ({self.micromolar})"
                + f" and mg/kg ({self.mg_per_kg}), or neither"
            )

    @cached_property
    def format_value(self) -> str:

        return f"{self._value}{Chars.narrownbsp}{self._unit}"

    @cached_property
    def format_value_pm(self) -> str:

        v, u, s = self._value, self._unit, Chars.narrownbsp

        return f"{v.mean}{Chars.plusminus}{v.std}{s}{u}"

    @cached_property
    def format_value_range(self) -> str:

        v, u, s = self._value, self._unit, Chars.narrownbsp

        return f"{v.mean}{s}({v.lower}{Chars.en}{v.upper}){s}{u}"

    @property
    def _value(self) -> ConcentrationBound:
        if self.mg_per_kg is not None:
            return self.mg_per_kg
        return self.micromolar

    @property
    def _unit(self) -> str:
        if self.mg_per_kg is not None:
            return " mg/kg"
        return " µmol/L"


class HmdbData:

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

    @property
    def cid(self) -> str:

        return self._data.req_as("metabolite.accession", str)

    @property
    def inchi(self) -> str:

        return self._data.req_as("metabolite.inchi", str)

    @property
    def inchikey(self) -> str:

        return self._data.req_as("metabolite.inchikey", str)

    @property
    def smiles(self) -> str:

        return self._data.req_as("metabolite.smiles", str)

    @property
    def cas(self) -> str:

        return self._data.req_as("metabolite.cas_registry_number", str)

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

        return self._data.get_as("metabolite.inchikey", str)

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

        return self._data.get_as("metabolite.pubchem_compound_id", str)

    @property
    def create_date(self) -> datetime:

        return datetime.fromisoformat(self._data.req_as("metabolite.creation_date", str))

    @property
    def mod_date(self) -> datetime:

        return datetime.fromisoformat(self._data.req_as("metabolite.update_date", str))

    @cached_property
    def predicted_properties(self) -> Sequence[HmdbProperty]:

        data = self._data.get("metabolite.predicted_properties", [])
        return [
            HmdbProperty(kind=x["kind"], source=x["source"], value=x["value"])
            for x in data
            if _Prop(x["kind"], x["source"]) in PREDICTED_PROPERTIES
        ]

    @cached_property
    def rules(self) -> Mapping[str, bool]:

        data = self._data.get("metabolite.predicted_properties", [])
        return {
            r["kind"]: CommonTools.parse_bool_flex(r["value"])
            for r in data
            if (r["kind"], r["source"]) in RULES
        }

    @cached_property
    def diseases(self) -> Sequence[HmdbDisease]:

        data = self._data.get_list_as("metabolite.diseases", NestedDotDict)
        return [HmdbDisease(d["name"], d["omim_id"], len(d.get("references", []))) for d in data]

    @cached_property
    def specimens(self) -> Sequence[str]:

        return self._data.get_list_as("metabolite.biological_properties.biospecimen_locations", str)

    @cached_property
    def tissue_locations(self) -> Sequence[str]:

        return self._data.get_list_as("metabolite.biological_properties.tissue_locations", str)

    @cached_property
    def normal_concentrations(self) -> Sequence[HmdbConcentration]:

        data = self._data.get_list_as("metabolite.normal_concentrations", NestedDotDict, [])
        results = []
        for d in data:

            x = self._new_conc(d)

            if x is not None:
                results.append(x)
        return results

    def _new_conc(self, x: NestedDotDict) -> Optional[HmdbConcentration]:

        specimen = x["biospecimen"]
        # both can be "Not Specified"
        ages = {
            "Adult": PersonAge.adults,
            "Children": PersonAge.children,
            "Both": PersonAge.adults | PersonAge.children,
        }.get(x.get_as("subject_age", str, "").split(" ")[0], PersonAge.unknown)
        sexes = {
            "Male": PersonSex.male,
            "Female": PersonSex.female,
            "Both": PersonSex.female | PersonSex.male,
        }.get(x.get_as("subject_sex", str, ""), PersonSex.unknown)
        condition = (
            None
            if x.get("subject_condition") == "Normal"
            else x.get_as("patient_information", str, "")
        )
        value, units = x.get_as("concentration_value", str), x.get_as("concentration_units", str)
        if value is None or len(value) == 0:
            logger.trace(f"Discarding {x} with empty value")
            return None
        if units not in ["uM", "mg/kg"]:
            logger.trace(f"Discarding {x} with units '{units}'")
            return None
        bound = self._parse_conc(value)
        if bound is None:
            logger.warning(f"Could not parse concentration {value} (units: {units})")
            logger.trace(f"Full data: {x}")
            return None
        return HmdbConcentration(
            specimen=specimen,
            ages=ages,
            sexes=sexes,
            condition=condition,
            micromolar=bound if units == "uM" else None,
            mg_per_kg=bound if units == "mg/kg" else None,
        )

    def _parse_conc(self, value: str) -> Optional[ConcentrationBound]:
class Foo:
    def some_method(self, x, y):
        return x + y;
        m: regex.Match = _p1.fullmatch(value)

        if m is not None:
            return ConcentrationBound(*m.groups())
        m: regex.Match = _p2.fullmatch(value)

        if m is not None:
            v, std = m.groups()

            return ConcentrationBound(v, v - std, v + std)
        return None

    @cached_property
    def abnormal_concentrations(self) -> Sequence[HmdbConcentration]:

        return self._data.get("metabolite.normal_concentrations", [])


__all__ = [
    "HmdbProperty",
    "ConcentrationBound",
    "HmdbData",
    "PersonSex",
    "PersonAge",
    "HmdbConcentration",
    "HmdbDisease",
]


1			import math
			0 ignored issues – show introduced 2021-11-04 01:37 UTC by Report Bug Copy Issue Report Missing module docstring Loading history...
2			from dataclasses import dataclass
3			from datetime import datetime
4			from functools import cached_property
			0 ignored issues – show Bug introduced 2021-11-04 01:02 UTC by Report Bug Copy Issue Report The name `cached_property` does not seem to exist in module `functools`. Loading history...
5			from typing import Mapping, NamedTuple, Optional, Sequence
6
7			import regex
			0 ignored issues – show introduced 2021-11-04 01:37 UTC by Report Bug Copy Issue Report Unable to import 'regex' Loading history...
8			from pocketutils.core.chars import Chars
			0 ignored issues – show introduced 2021-11-04 01:02 UTC by Report Bug Copy Issue Report Unable to import 'pocketutils.core.chars' Loading history...
9			from pocketutils.core.dot_dict import NestedDotDict
			0 ignored issues – show introduced 2021-01-25 23:06 UTC by Report Bug Copy Issue Report Unable to import 'pocketutils.core.dot_dict' Loading history...
10			from pocketutils.core.enums import FlagEnum
			0 ignored issues – show introduced 2021-11-04 01:02 UTC by Report Bug Copy Issue Report Unable to import 'pocketutils.core.enums' Loading history...
11			from pocketutils.tools.common_tools import CommonTools
			0 ignored issues – show introduced 2021-03-10 02:41 UTC by Report Bug Copy Issue Report Unable to import 'pocketutils.tools.common_tools' Loading history...
12
13			from mandos.model.apis.hmdb_support.properties import PREDICTED_PROPERTIES, RULES, _Prop
14			from mandos.model.utils.setup import logger
15
16			_prefixes = dict(M=1e6, mM=1e3, µM=1, uM=1, nM=1e-3, pM=1e-6, fM=1e-9)
17			_p1 = regex.compile(r"^([0-9.]+ +\(([0-9.]+) \- ([0-9.]+)\)$", flags=regex.V1)
18			_p2 = regex.compile(r"^([0-9.]+) +\+\/\- +([0-9.]+)$", flags=regex.V1)
19
20
21			class ConcentrationBound(NamedTuple):
			0 ignored issues – show introduced 2021-11-04 01:37 UTC by Report Bug Copy Issue Report Missing class docstring Loading history...
22			mean: float
23			lower: float
24			upper: float
25
26			@property
27			def std(self) -> float:
			0 ignored issues – show introduced 2021-11-04 01:37 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
28			return self.upper / 2 - self.lower / 2
29
30			@property
31			def is_symmetric(self) -> bool:

dmyersturnbull / mandos

Push — main ( 3a0c28...4b9dc0 )

HmdbData.cas() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like