pocketutils.tools.unit_tools

Complexity

Total Complexity

43

Size/Duplication

Total Lines	319
Duplicated Lines	0 %

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
C	UnitTools.approx_time_wrt()	0	38	9
A	UnitTools.delta_time_to_str()	0	24	4
A	UnitTools.extract_micromolar()	0	24	3
A	UnitTools.round_to_sigfigs()	0	22	4
A	UnitTools.split_species_micromolar()	0	28	3
A	UnitTools.friendly_size()	0	7	1
A	UnitTools.concentration_to_micromolar()	0	28	1
C	UnitTools.format_micromolar()	0	57	11
A	UnitTools.canonicalize_quantity()	0	21	2
A	UnitTools.ms_to_minsec()	0	37	5

import logging

Missing module docstring

import math
from datetime import date, datetime, timedelta
from typing import Optional, SupportsFloat, Tuple, Union

import regex

Unable to import 'regex'

from pint import Quantity, UnitRegistry

Unable to import 'pint'

from pint.errors import PintTypeError

Unable to import 'pint.errors'

from pocketutils.core._internal import nicesize

The name core does not seem to exist in module pocketutils.

from pocketutils.core.exceptions import OutOfRangeError, StringPatternError

The name core does not seem to exist in module pocketutils.

from pocketutils.tools.base_tools import BaseTools
from pocketutils.tools.string_tools import StringTools

logger = logging.getLogger("pocketutils")
_UNIT_REG = UnitRegistry()


class UnitTools(BaseTools):

Missing class docstring

    @classmethod
    def approx_time_wrt(

Too many return statements (7/6)

        cls,

Wrong hanging indentation before block (add 4 spaces).

        now: Union[date, datetime],

Wrong hanging indentation before block (add 4 spaces).

        then: Union[date, datetime],

Wrong hanging indentation before block (add 4 spaces).

        *,

Wrong hanging indentation before block (add 4 spaces).

        skip_today: bool = False,

Wrong hanging indentation before block (add 4 spaces).

        sig: int = 3,

Wrong hanging indentation before block (add 4 spaces).

    ) -> str:
        """
        Describes ``then`` with higher resolution for smaller differences to ``now``.

        Examples:
            - ``approx_time_wrt(date(2021, 1, 12), date(1996, 10, 1))  # "1996"``
            - ``approx_time_wrt(date(2021, 1, 12), date(2021, 10, 1))  # "2021-01-12"``
            - ``approx_time_wrt(date(2021, 10, 1), datetime(2021, 10, 1, 11, 55))  # "2021-01-12 11:55"``

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

            - ``approx_time_wrt(date(2021, 10, 1), datetime(2021, 10, 1, 11, 0, 0, 30, 222222))  # "2021-01-12 00:00:30"``

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

            - ``approx_time_wrt(date(2021, 10, 1), datetime(2021, 10, 1, 11, 0, 0, 2, 222222))  # "2021-01-12 00:00:02.222"``

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

            - ``approx_time_wrt(date(2021, 10, 1), datetime(2021, 10, 1, 11, 0, 0, 2, 22))  # "2021-01-12 00:00:02.000022"``

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

        """
        delta = now - then if now > then else then - now
        tot_days = (delta.days) + (delta.seconds / 86400) + (delta.microseconds / 86400 / 10**6)
        tot_secs = tot_days * 86400
        _today = "" if skip_today and then.date() == now.date() else "%Y-%m-%d "
        if tot_days > sig * 365.24219:

Unnecessary "elif" after "return"

            return str(then.year)
        elif tot_days > sig * 30.437:
            return then.strftime("%Y-%m")
        elif tot_days > sig:
            return then.strftime("%Y-%m-%d")
        elif tot_secs > sig * 60:
            return then.strftime(_today + "%H:%M")
        elif tot_secs > sig:
            return then.strftime(_today + "%H:%M:%S")
        elif tot_secs > sig / 1000:
            return then.strftime(_today + "%H:%M:%S") + "." + str(round(then.microsecond / 1000))
        else:
            return then.strftime(_today + "%H:%M:%S.%f")

    @classmethod
    def delta_time_to_str(cls, delta_sec: Union[float, timedelta], *, space: str = "") -> str:
        """
        Returns a pretty string from a difference in time in seconds.
        Rounds hours and minutes to 2 decimal places, and seconds to 1.
        Ex: delta_time_to_str(313) == 5.22min
            delta_sec: The time in seconds
            space: Space char between digits and units;
                   good choices are empty, ASCII space, Chars.narrownbsp, Chars.thinspace,
                   and Chars.nbsp.

        Returns:
            A string with units 'hr', 'min', or 's'
        """
        if isinstance(delta_sec, timedelta):
            delta_sec = delta_sec.total_seconds()
        if abs(delta_sec) > 60 * 60 * 3:

Unnecessary "elif" after "return"

            return (
                StringTools.strip_empty_decimal(str(round(delta_sec / 60 / 60, 2))) + space + "hr"
            )
        elif abs(delta_sec) > 180:
            return StringTools.strip_empty_decimal(str(round(delta_sec / 60, 2))) + space + "min"
        else:
            return StringTools.strip_empty_decimal(str(round(delta_sec, 1))) + space + "s"

    @classmethod
    def ms_to_minsec(cls, ms: int, space: str = "") -> str:

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

        """
        Converts a number of milliseconds to one of the following formats.
        Will be one of these:
            - 10ms         if < 1 sec
            - 10:15        if < 1 hour
            - 10:15:33     if < 1 day
            - 5d:10:15:33  if > 1 day
        Prepends a minus sign (−) if negative.

        Args:
            ms: The milliseconds
            space: Space char between digits and 'ms' (if used);
                   good choices are empty, ASCII space, Chars.narrownbsp,
                   Chars.thinspace, and Chars.nbsp.

        Returns:
            A string of one of the formats above
        """
        ms = abs(int(ms))
        seconds = int((ms / 1000) % 60)
        minutes = int((ms / (1000 * 60)) % 60)
        hours = int((ms / (1000 * 60 * 60)) % 24)
        days = int(ms / (1000 * 60 * 60 * 24))
        z_hr = str(hours).zfill(2)
        z_min = str(minutes).zfill(2)
        z_sec = str(seconds).zfill(2)
        sgn = "−" if ms < 0 else ""
        if ms < 1000:

Unnecessary "elif" after "return"

            return f"{sgn}{ms}{space}ms"
        elif days > 1:
            return f"{days}d:{z_hr}:{z_min}:{z_sec}"
        elif hours > 1:
            return f"{sgn}{z_hr}:{z_min}:{z_sec}"
        else:
            return f"{sgn}{z_min}:{z_sec}"

    @classmethod
    def friendly_size(cls, n_bytes: int, *, space: str = " ") -> str:
        """
        Returns a text representation of a number of bytes.
        Uses base 2 with IEC 1998, rounded to 0 decimal places, and without a space.
        """
        return nicesize(n_bytes, space=space)

    @classmethod
    def round_to_sigfigs(cls, num: SupportsFloat, sig_figs: Optional[int]) -> float:
        """
        Round to specified number of sigfigs.

        Args:
            num: A Python or Numpy float or something that supports __float__
            sig_figs: The number of significant figures, non-negative

        Returns:
            A Python integer
        """
        if sig_figs is None:
            return float(num)
        if sig_figs < 0:
            raise OutOfRangeError(f"sig_figs {sig_figs} is negative", minimum=0)
        num = float(num)
        if num != 0:

Unnecessary "else" after "return"

            digits = -int(math.floor(math.log10(abs(num))) - (sig_figs - 1))
            return round(num, digits)
        else:
            return 0  # can't take the log of 0

    @classmethod
    def format_micromolar(
        cls,

Wrong hanging indentation before block (add 4 spaces).

        micromolar: float,

Wrong hanging indentation before block (add 4 spaces).

        n_sigfigs: Optional[int] = 5,

Wrong hanging indentation before block (add 4 spaces).

        *,

Wrong hanging indentation before block (add 4 spaces).

        adjust_units: bool = True,

Wrong hanging indentation before block (add 4 spaces).

        use_sigfigs: bool = True,

Wrong hanging indentation before block (add 4 spaces).

        space: str = "",

Wrong hanging indentation before block (add 4 spaces).

    ) -> str:
        """
        Returns a concentration with units, with the units scaled as needed.
        Can handle millimolar, micromolar, nanomolar, and picomolar.

        Args:
            micromolar: Value
            n_sigfigs: For rounding; no rounding if None
            adjust_units: If False, will always use micromolar
            use_sigfigs: If True, rounds to a number of significant figures; otherwise round to decimal places

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

            space: Space char between digits and units;
                   good choices are empty, ASCII space,
                   :attr:`pocketutils.core.chars.Chars.narrownbsp`,
                   :attr:`pocketutils.core.chars.Chars.thinspace`,
                   and :attr:`pocketutils.core.chars.Chars.nbsp`.

        Returns:
            The concentration with a suffix of µM, mM, nM, or mM
        """
        d = micromolar

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

        m = abs(d)

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)

        unit = "µM"
        if adjust_units:
            if m < 1e-6:
                d *= 1e9

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

                unit = "fM"
            elif m < 1e-3:
                d *= 1e6

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

                unit = "pM"
            elif m < 1:
                d *= 1e3

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

                unit = "nM"
            elif m >= 1e6:
                d /= 1e6

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

                unit = "M"
            elif m >= 1e3:
                d /= 1e3

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

                unit = "mM"
        if n_sigfigs is None:
            pass
        elif use_sigfigs:
            d = cls.round_to_sigfigs(d, n_sigfigs)

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

        else:
            d = round(d, n_sigfigs)

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

        if round(d) == d and str(d).endswith(".0"):

Unnecessary "else" after "return"

            return str(d)[:-2] + space + unit
        else:
            return str(d) + space + unit

    @classmethod
    def split_species_micromolar(cls, text: str) -> Tuple[str, Optional[float]]:
        """
        Splits a name into a chemical/concentration pair, falling back with the full name.
        Ex: "abc 3.5uM" → (abc, 3.5)
        Ex: "abc 3.5 µM" → (abc, 3.5)
        Ex: "abc (3.5mM)" → (abc, 3500.0)
        Ex: "abc 3.5mM" → (abc, None)
        Ex: "3.5mM" → (3.5mM, None)  # an edge case: don't pass in only units
        Uses a moderately strict pattern for the drug and dose:
            - The dose must terminate the string, except for end parenthesis or whitespace.
            - The drug and dose must be separated by at least one non-alphanumeric, non-dot, non-hyphen character.

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

            - Units must follow the digits, separated by at most whitespace, and are case-sensitive.
        """
        # lazy ops in the first group and in the non-(alphanumeric/dot/dash) separator between the drug and dose

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

        pat = regex.compile(
            r"^\s*(.*?)(?:[^A-Za-z0-9.\-]+?[\s(\[{]*(\d+(?:.\d*)?)\s*([mµunpf]M)\s*[)\]}]*)?\s*$",
            flags=regex.V1,
        )
        match = pat.fullmatch(text)
        if match is None:
            raise StringPatternError(f"Text {text} couldn't be parsed", value=text, pattern=pat)
        if match.group(2) is None:

Unnecessary "else" after "return"

            return text.strip(), None
        else:
            drug = match.group(1).strip("([{)]}")
            dose = UnitTools.concentration_to_micromolar(float(match.group(2)), match.group(3))
            return drug, dose

    @classmethod
    def extract_micromolar(cls, text: str) -> Optional[float]:
        """
        Returns what looks like a concentration with units. Accepts one of: mM, µM, uM, nM, pM.
        Searches pretty flexibly.
        If no matches are found, returns None.
        If multiple matches are found, warns and returns None.
        """
        # we need to make sure mM ex isn't part of a larger name
        pat1 = regex.compile(r"(\d+(?:.\d*)?)\s*([mµunpf]M)\s*[)\]}]*", flags=regex.V1)

        def find(pat):
            return {
                UnitTools.concentration_to_micromolar(float(match.group(1)), match.group(2))
                for match in pat.finditer(text)
                if match is not None
            }

        matches = find(pat1)
        if len(matches) == 1:

Unnecessary "elif" after "return"

            return next(iter(matches))
        elif len(matches) > 1:
            logger.warning(f"Found {len(matches)} potential doses: {matches} . Returning None.")

Use lazy % formatting in logging functions

        return None

    @classmethod
    def concentration_to_micromolar(cls, digits: SupportsFloat, units: str) -> float:
        """
        Converts a concentration with units to micromolar.

        Args:
            digits: Float or float-compatible value
            units: Units that ``digits`` are in

        Example:
            .. code-block::

                concentration_to_micromolar(53, 'nM')  # returns 0.053

        See Also:
            :meth:`extract_micromolar`
        """
        return (
            float(digits)
            * {
                "M": 1e6,
                "mM": 1e3,
                "µM": 1,
                "uM": 1,
                "nM": 1e-3,
                "pM": 1e-6,
                "fM": 1e-9,
            }[units]
        )

    @classmethod
    def canonicalize_quantity(cls, s: str, dimensionality: str) -> Quantity:

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)

        """
        Returns a quantity in reduced units from a magnitude with units.

        Args:
            s: The string to parse; e.g. ``"1 m/s^2"``.
               Unit names and symbols permitted, and spaces may be omitted.
            dimensionality: The resulting Quantity is checked against this;
                            e.g. ``"[length]/[meter]^2"``

        Returns:
            a pint ``Quantity``

        Raise:
            PintTypeError: If the dimensionality is inconsistent
        """
        q = _UNIT_REG.Quantity(s).to_reduced_units()

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)

        if not q.is_compatible_with(dimensionality):
            raise PintTypeError(f"{s} not of dimensionality {dimensionality}")
        return q


__all__ = ["UnitTools"]