PlayerDivisionInfo

Complexity

Total Complexity

4

Size/Duplication

Total Lines	14
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	1

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__init__()	0	4	1
A	__str__()	0	2	1
A	is_in_superior_league()	0	2	1
A	is_in_inferior_league()	0	2	1

# coding=utf-8
import logging
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 DivisionService:
    def __init__(self, divisions: List['Division'], player_division_infos: List['PlayerDivisionInfo']):
        self.divisions = divisions
        self.players = dict()  # type: Dict[int, 'PlayerDivisionInfo']

        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)

    def update_player_score(self, player: PlayerDivisionInfo, new_score: float) -> None:

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

        logger.debug("Update score for %s to %s", player)

Not enough arguments for logging format string

        player.score = new_score

    def promote_player(self, player):

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

        logger.info("%s got promoted to league %s", player, player.league + 1)
        player.score = 0.0
        player.league += 1

    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