mandos.analysis.concordance

Complexity

Total Complexity

15

Size/Duplication

Total Lines	108
Duplicated Lines	0 %

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	ConcordanceCalculator._calc()	0	2	1
A	ConcordanceCalculator.generate()	0	10	3
A	ConcordanceCalculator.__init__()	0	4	1
A	TauConcordanceCalculator._i_sum()	0	3	1
A	TauConcordanceCalculator._n_z()	0	3	1
A	TauConcordanceCalculator._calc()	0	5	1
A	ConcordanceCalculator.calc_all()	0	4	3
A	ConcordanceAlg.clazz()	0	3	1
A	ConcordanceCalculation.create()	0	11	1
A	ConcordanceCalculator.calc()	0	12	2

"""
Calculations of concordance between annotations.
"""
import abc
import enum
import math
from typing import Collection, Dict, Generator, Sequence, Set, Tuple, Union, Type

Unused Collection imported from typing

Unused Dict imported from typing

Unused Set imported from typing

Unused Tuple imported from typing

import numpy as np

Unable to import 'numpy'

import pandas as pd

Unable to import 'pandas'

from typeddfs import TypedDfs

Unable to import 'typeddfs'

from mandos.analysis import AnalysisUtils

Unused AnalysisUtils imported from mandos.analysis

from mandos.analysis import SimilarityDfLongForm, SimilarityDfShortForm
from mandos.model import CleverEnum

ConcordanceDf = (
    TypedDfs.typed("ConcordanceDf")
    .require("phi", "psi", dtype=str)
    .require("sample", dtype=int)
    .require("tau", dtype=float)
).build()


class ConcordanceCalculator(metaclass=abc.ABCMeta):

Missing class docstring

    def __init__(self, n_samples: int, seed: int):
        self.n_samples = n_samples
        self.seed = seed
        self.rand = np.random.RandomState(seed)

    def calc_all(self, phis: SimilarityDfLongForm, psis: SimilarityDfLongForm) -> ConcordanceDf:

Missing function or method docstring

        for phi in phis["phi"].unique():
            for psi in psis["psi"].unique():
                self.calc(None, None, phi, psi)  # TODO

TODO and FIXME comments should generally be avoided.

    def calc(

Missing function or method docstring

        self, phi: SimilarityDfShortForm, psi: SimilarityDfShortForm, phi_name: str, psi_name: str

Wrong hanging indentation before block (add 4 spaces).

    ) -> ConcordanceDf:
        phi_cols, psi_cols = phi.columns.tolist(), psi.columns.tolist()
        if phi_cols != psi_cols:
            raise ValueError(f"Mismatched compounds: {phi_cols} != {psi_cols}")
        df = pd.DataFrame(data=self.generate(phi, psi), columns=["score"])

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

        df = df.reset_index()

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

        df["phi"] = phi_name
        df["psi"] = psi_name
        df.columns = ["sample", "tau", "phi", "psi"]
        return ConcordanceDf.convert(df)

    def generate(

Missing function or method docstring

        self, phi: SimilarityDfShortForm, psi: SimilarityDfShortForm

Wrong hanging indentation before block (add 4 spaces).

    ) -> Generator[float, None, None]:
        if self.n_samples == 1:
            yield self._calc(phi, psi)
        else:
            for b in range(self.n_samples):

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

The variable b seems to be unused.

                phi_b = self.rand.choice(phi, replace=True)
                psi_b = self.rand.choice(psi, replace=True)
                yield self._calc(phi_b, psi_b)

    def _calc(self, phi: SimilarityDfShortForm, psi: SimilarityDfShortForm) -> float:

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 TauConcordanceCalculator(ConcordanceCalculator):

Missing class docstring

    def _calc(self, phi: SimilarityDfShortForm, psi: SimilarityDfShortForm) -> float:
        n = len(phi)

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

        numerator = self._n_z(phi, psi, 1) - self._n_z(phi, psi, -1)
        denominator = math.factorial(n) / (2 * math.factorial(n - 2))
        return numerator / denominator

    def _n_z(self, a: Sequence[float], b: Sequence[float], z: int) -> int:

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

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

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

        values = [self._i_sum(a, b, i, z) for i in range(len(a))]
        return int(np.sum(values))

    def _i_sum(self, a: np.array, b: np.array, i: int, z: int):

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

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

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

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

        values = [int(np.sign(a[i] - a[j]) == z * np.sign(b[i] - b[j]) != 0) for j in range(i)]
        return int(np.sum(values))


class ConcordanceAlg(CleverEnum):

Missing class docstring

    tau = enum.auto()

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

Missing function or method docstring

        return {ConcordanceAlg.tau: TauConcordanceCalculator}[self]


class ConcordanceCalculation:

Missing class docstring

    @classmethod
    def create(

Too many arguments (6/5)

Missing function or method docstring

        cls,

Wrong hanging indentation before block (add 4 spaces).

        algorithm: Union[str, ConcordanceAlg],

Wrong hanging indentation before block (add 4 spaces).

        phi_name: str,

Wrong hanging indentation before block (add 4 spaces).

        psi_name: str,

Wrong hanging indentation before block (add 4 spaces).

        n_samples: int,

Wrong hanging indentation before block (add 4 spaces).

        seed: int,

Wrong hanging indentation before block (add 4 spaces).

    ) -> ConcordanceCalculator:
        algorithm = ConcordanceAlg.of(algorithm).clazz
        return algorithm(n_samples=n_samples, seed=seed, phi_name=phi_name, psi_name=psi_name)


__all__ = [
    "ConcordanceCalculator",
    "TauConcordanceCalculator",
    "ConcordanceDf",
    "ConcordanceCalculation",
    "ConcordanceAlg",
]