mandos.analysis.distances

Complexity

Total Complexity

11

Size/Duplication

Total Lines	78
Duplicated Lines	0 %

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	JPrimeMatrixCalculator._jx()	0	4	1
A	MatrixAlg.clazz()	0	3	1
A	JPrimeMatrixCalculator.calc()	0	6	2
A	JPrimeMatrixCalculator._vee()	0	2	1
A	MatrixCalculation.create()	0	5	2
A	JPrimeMatrixCalculator._j_prime()	0	12	2
A	JPrimeMatrixCalculator._wedge()	0	2	1
A	MatrixCalculator.calc()	0	2	1

"""
Calculations of concordance between annotations.
"""
import abc
import enum
import math
from collections import defaultdict
from typing import Collection, Sequence, Type, Union

import numpy as np

Unable to import 'numpy'

from mandos.analysis import AnalysisUtils as Au
from mandos.analysis import SimilarityDf
from mandos.model import CleverEnum
from mandos.model.hits import AbstractHit

# note that most of these math functions are much faster than their numpy counterparts
# if we're not broadcasting, it's almost always better to use them
# some are more accurate, too
# e.g. we're using fsum rather than sum


class MatrixCalculator(metaclass=abc.ABCMeta):

Missing class docstring

    def calc(self, hits: Sequence[AbstractHit]) -> SimilarityDf:

Missing function or method docstring

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

        raise NotImplemented()

NotImplemented does not seem to be callable.

NotImplemented raised - should raise NotImplementedError

class JPrimeMatrixCalculator(MatrixCalculator):

Missing class docstring

    def calc(self, hits: Sequence[AbstractHit]) -> SimilarityDf:
        inchikey_to_hits = Au.hit_multidict(hits, "origin_inchikey")
        data = defaultdict(dict)
        for (c1, hits1), (c2, hits2) in zip(inchikey_to_hits.items(), inchikey_to_hits.items()):

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

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

            data[c1][c2] = self._j_prime(hits1, hits2)
        return SimilarityDf.from_dict(data)

    def _j_prime(self, hits1: Collection[AbstractHit], hits2: Collection[AbstractHit]) -> float:
        sources = {h.data_source for h in hits1}.intersection({h.data_source for h in hits2})
        if len(sources) == 0:
            return np.nan
        values = [
            self._jx(
                [h for h in hits1 if h.data_source == source],
                [h for h in hits1 if h.data_source == source],
            )
            for source in sources
        ]
        return float(math.fsum(values) / len(values))

    def _jx(self, hits1: Collection[AbstractHit], hits2: Collection[AbstractHit]) -> float:
        pair_to_weights = Au.weights_of_pairs(hits1, hits2)
        values = [self._wedge(ca, cb) / self._vee(ca, cb) for ca, cb in pair_to_weights.values()]
        return float(math.fsum(values) / len(values))

    def _wedge(self, ca: float, cb: float) -> float:

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

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

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

        return math.sqrt(Au.elle(ca) * Au.elle(cb))

    def _vee(self, ca: float, cb: float) -> float:

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

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

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

        return Au.elle(ca) + Au.elle(cb) - math.sqrt(Au.elle(ca) * Au.elle(cb))


class MatrixAlg(CleverEnum):

Missing class docstring

    j = enum.auto()

    @property
    def clazz(self) -> Type[MatrixCalculator]:

Missing function or method docstring

        return {MatrixAlg.j: JPrimeMatrixCalculator}[self]


class MatrixCalculation:

Missing class docstring

    @classmethod
    def create(cls, algorithm: Union[str, MatrixAlg]) -> MatrixCalculator:

Missing function or method docstring

        alg_name = algorithm if isinstance(algorithm, str) else algorithm.name
        alg = MatrixAlg.of(algorithm)
        return alg.clazz(alg_name)


__all__ = ["MatrixCalculator", "JPrimeMatrixCalculator"]