mandos.model.hits

Complexity

Total Complexity

8

Size/Duplication

Total Lines	108
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	Triple.tab_header()	0	15	1
A	AbstractHit.to_triple()	0	8	1
A	AbstractHit.__hash__()	0	2	1
A	AbstractHit.predicate()	0	8	1
A	Triple.statement()	0	12	1
A	Triple.tabs()	0	11	2
A	AbstractHit.fields()	0	8	1

import dataclasses

Missing module docstring

from dataclasses import dataclass
from typing import Optional, Sequence


@dataclass(frozen=True, repr=True, order=True)
class Triple:
    """
    Compound, predicate, object.
    """

    compound_id: str
    compound_lookup: str
    compound_name: str
    predicate: str
    object_name: str
    object_id: str

    @classmethod
    def tab_header(cls) -> str:
        """

        Returns:

        """
        return "\t".join(
            [
                "compound_id",
                "compound_lookup",
                "compound_name",
                "predicate",
                "object_name",
                "object_id",
            ]
        )

    @property
    def tabs(self) -> str:

Missing function or method docstring

        items = [
            self.compound_lookup,
            self.compound_id,
            self.compound_name,
            self.predicate,
            self.object_name,
            self.object_id,
        ]
        return "\t".join(["-" if k is None else str(k) for k in items])

    @property
    def statement(self) -> str:
        """
        Returns a simple text statement with brackets.

        Returns:

        """
        sub = f"{self.compound_lookup} [{self.compound_id}] [{self.compound_name}]>"
        pred = f"<{self.predicate}>"
        obj = f"<{self.object_name} [{self.object_id}]>"
        return "\t".join([sub, pred, obj])


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

Empty class docstring

class AbstractHit:
    """"""

    record_id: Optional[str]
    compound_id: str
    inchikey: str
    compound_lookup: str
    compound_name: str
    object_id: str
    object_name: str

    def to_triple(self) -> Triple:

Missing function or method docstring

        return Triple(
            compound_lookup=self.compound_lookup,
            compound_id=self.compound_id,
            compound_name=self.compound_name,
            predicate=self.predicate,
            object_id=self.object_id,
            object_name=self.object_name,
        )

    @property
    def predicate(self) -> str:
        """

        Returns:

        """
        raise NotImplementedError()

    def __hash__(self):
        return hash(self.record_id)

    @classmethod
    def fields(cls) -> Sequence[str]:
        """

        Returns:

        """
        return [f.name for f in dataclasses.fields(cls)]


__all__ = ["AbstractHit", "Triple"]