DivisionService

Complexity

Total Complexity

23

Size/Duplication

Total Lines	75
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	1

8 Methods

Rating	Name	Duplication	Size	Complexity
A	max_league_threshold()	0	2	3
A	__init__()	0	8	2
A	add_player()	0	4	1
A	get_player_division()	0	3	1
A	promote_player()	0	5	1
B	get_division()	0	9	6
D	post_result()	0	28	8
A	update_player_score()	0	4	1

# coding=utf-8
import logging
from abc import ABCMeta, abstractmethod
from typing import List, Dict

The import typing could not be resolved.

Unused Dict imported from typing

logger = logging.getLogger(__name__)


class Division:
    def __init__(self, id: int, name: str, league: int, threshold: float):

This seems to re-define the built-in id.

        self.id = id
        self.name = name
        self.league = league
        self.threshold = threshold


class PlayerDivisionInfo:
    def __init__(self, user_id: int, current_league: int, current_score: float):
        self.user_id = user_id
        self.league = current_league
        self.score = current_score

    def is_in_inferior_league(self, compared_to: 'PlayerDivisionInfo') -> bool:
        return self.league < compared_to.league

    def is_in_superior_league(self, compared_to: 'PlayerDivisionInfo') -> bool:
        return self.league > compared_to.league

    def __str__(self):
        return "PlayerDivisionInfo(user_id=%s, league=%s, score=%s)" % (self.user_id, self.league, self.score)


class DivisionPersistor(ABCMeta):

This abstract class does not seem to be used anywhere.

    """
    Interface for the persistance layer
    """

    @abstractmethod
    def add_player(self, player: 'PlayerDivisionInfo') -> None:

The first argument of the metaclass method add_player should be named cls.

        """
        Add a new player to the persistance layer
        :param player: new player with zero score and initial league
        """
        pass

    @abstractmethod
    def update_player(self, player: 'PlayerDivisionInfo') -> None:

The first argument of the metaclass method update_player should be named cls.

        """
        Update a player after a game (league, score, games)
        :param player: updated player
        """
        pass


class DivisionService:
    """
    Division service calculates changes to the ladder leagues & divisions after each game
    """

    def __init__(self, divisions: List['Division'], player_division_infos: List['PlayerDivisionInfo'],
                 persistor: 'DivisionPersistor'):
        self.divisions = divisions
        self.players = dict()  # type: Dict[int, 'PlayerDivisionInfo']
        self.persistor = persistor

        for info in player_division_infos:
            self.players[info.user_id] = info

    def add_player(self, player_id: int) -> None:
        logger.debug("Added new player %s to divisions", player_id)
        self.players[player_id] = PlayerDivisionInfo(player_id, 1, 0.0)
        self.persistor.add_player(self.players[player_id])

    def update_player_score(self, player: PlayerDivisionInfo, new_score: float) -> None:
        logger.debug("Update score for %s to %s", player)

Not enough arguments for logging format string

        player.score = new_score
        self.persistor.update_player(player)

    def promote_player(self, player):
        logger.info("%s got promoted to league %s", player, player.league + 1)
        player.score = 0.0
        player.league += 1
        self.persistor.update_player(player)

    def post_result(self, player_one: int, player_two: int, player_one_has_won: bool) -> None:
        if player_one not in self.players:
            self.add_player(player_one)

        if player_two not in self.players:
            self.add_player(player_two)

        winner = self.players[player_one] if player_one_has_won else self.players[player_two]
        loser = self.players[player_two] if player_one_has_won else self.players[player_one]

        if winner.is_in_inferior_league(loser):
            gain = 1.5
            loss = 1.0
        elif winner.is_in_superior_league(loser):
            gain = 0.5
            loss = 0.5
        else:
            gain = 1.0
            loss = 0.5

        logger.debug("%s won against %s - gain: %s - loss: %s", winner, loser, gain, loss)

        if winner.score + gain > self.max_league_threshold(winner.league):
            self.promote_player(winner)
        else:
            self.update_player_score(winner, winner.score + gain)

        self.update_player_score(loser, max(0.0, loser.score - loss))

    def get_player_division(self, player_id: int) -> 'Division':
        player = self.players[player_id]
        return self.get_division(player.league, player.score)

    def max_league_threshold(self, league: int) -> float:
        return max([x.threshold for x in self.divisions if x.league == league])

    def get_division(self, league: int, score: float) -> Division:
        divisions_of_league = [x for x in self.divisions if x.league == league]

        for division in sorted(divisions_of_league, key=lambda d: d.threshold):
            if division.threshold > score:
                return division

        logger.error("league %s has no division for score %s", league, score)
        return None