Useful utility class

gistfile1.txt

"""`counters` module - Utility model objects for results tracking."""
from typing import Any
from typing import Iterator


class Tally:
    """`Tally` class: a simple results counter: allows accumulation and addition of results.

    >>> results = Tally(hits=1, misses=1)
    >>> print(results)
    Tally(hits = 1, misses = 1)
    >>> more_results = Tally(2, 2)
    >>> print(more_results)
    Tally(hits = 2, misses = 2)
    >>> results += more_results
    >>> print(results)
    Tally(hits = 3, misses = 3)
    >>> eval(repr(results)) == results  #
    True
    >>> results.misses
    3
    >>> results.miss(5)
    8
    >>> results.misses
    8
    >>> results.hits
    3
    >>> results.hit()
    4
    """

    def __init__(self, hits=0, misses=0, **kwargs):
        self.number_hit = hits
        self.number_missed = misses

    @property
    def hits(self) -> int:
        return self.number_hit

    @property
    def misses (self) -> int:
        return self.number_missed

    def hitted(self) -> int:
        return self.number_hit

    def missed(self) -> int:
        return self.number_missed


    def hit(self, value=1) -> int:
        self.number_hit += value
        return self.number_hit

    def miss(self, value=1) -> int:
        self.number_missed += value
        return self.number_missed

    def increment_total(self) -> None:
        self.number_hit += 1

    def __repr__(self) -> str:
        """The string returned by __repr__ should be unambiguous and, if possible, match
        the source code necessary to recreate the object being represented. (_Fluent Python_)"""
        class_name = type(self).__name__
        return "{}(hits = {}, misses = {})".format(class_name, self.number_hit, self.number_missed)

    def __add__(self, other):
        return Tally(self.number_hit + other.number_hit, self.number_missed + other.number_missed)

    def __iter__(self) -> Iterator[Any]:
        return (i for i in (self.number_hit, self.number_missed))

    def __hash__(self) -> int:
        return hash(tuple(self))  # type: ignore

    def __eq__(self, other) -> bool:
        return tuple(self) == tuple(other)  # type: ignore