mandos.analysis.concordance

Complexity

Total Complexity

8

Size/Duplication

Total Lines	71
Duplicated Lines	0 %

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	ConcordanceCalculator._calc()	0	2	1
A	ConcordanceCalculator.generate()	0	5	2
A	ConcordanceCalculator.__init__()	0	4	1
A	TauConcordanceCalculator._n_z()	0	13	1
A	TauConcordanceCalculator._calc()	0	5	1
A	ConcordanceCalculator.calc()	0	9	2

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

Unused Set imported from typing

Unused Collection imported from typing

Unused Dict 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, SimilarityDf

Unused AnalysisUtils imported from mandos.analysis

ConcordanceDf = (
    TypedDfs.typed("ConcordanceDf").require("sample", dtype=int).require("score", 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(self, phi: SimilarityDf, psi: SimilarityDf) -> ConcordanceDf:

Missing function or method docstring

        if phi.columns.tolist() != psi.columns.tolist():
            raise ValueError(
                f"Mismatched compounds: {phi.columns.tolist()} != {psi.columns.tolist()}"
            )
        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.columns = ["sample", "score"]
        return ConcordanceDf(df)

    def generate(self, phi: SimilarityDf, psi: SimilarityDf) -> Generator[float, None, None]:

Missing function or method docstring

        for b in range(self.n_samples):

The variable b seems to be unused.

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)

            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: SimilarityDf, psi: SimilarityDf) -> 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: SimilarityDf, psi: SimilarityDf) -> 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 "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)

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)

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

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


__all__ = ["ConcordanceCalculator", "TauConcordanceCalculator"]