Class for generation insignia string of military rank

rank.py

#!/usr/bin/env python3

"""
DESCRIPTION
    Class for generation insignia string of military rank
LICENSE
    This work is licensed under a Creative Commons Attribution-NonCommercial 4.0 International License.
    http://creativecommons.org/licenses/by-nc/4.0/
OUTPUT

===Show all===

(0, '{    |') (0, '|    }')
(1, "{   '|") (1, "|'   }")
(2, "{  ''|") (2, "|''  }")
(3, "{ '''|") (3, "|''' }")
(4, "{''''|") (4, "|''''}")
(5, '{   +|') (5, '|+   }')
(6, '{  ++|') (6, '|++  }')
(7, '{ +++|') (7, '|+++ }')
(8, '{++++|') (8, '|++++}')
(9, '{   *|') (9, '|*   }')
(10, '{  **|') (10, '|**  }')
(11, '{ ***|') (11, '|*** }')
(12, '{   <|') (12, '|>   }')
(13, '{  <<|') (13, '|>>  }')
(14, '{ <<<|') (14, '|>>> }')

===Show extra rank===

 3 |''' } <Side.right: 2>
 8 |++++} <Side.right: 2>
13 {  <<| <Side.left: 1>
"""


# code here

from enum import Enum

class Side(Enum):
    left = 1
    right = 2


class MilitaryLevel():

    def __init__(self, char_left, char_right, size):
        self.char_left = char_left
        self.char_right = char_right
        self.size = size

    def check_parameters(self):
        if not (isinstance(self.char_left, type("")) and len(self.char_left) == 1):
            raise ValueError("Char_left parameter is not one character long.")
        if not (isinstance(self.char_right, type("")) and len(self.char_right) == 1):
            raise ValueError("Char_left parameter is not one character long.")

    def check_size(self, size):
        if self.size > size:
            self.size = size
            return False
        else:
            return True


class MilitaryRank():

    def __init__(self, size=4, edges_left="{|", edges_right="|}", insignia=(MilitaryLevel("'", "'", 4),
                                                     MilitaryLevel("+", "+", 4),
                                                     MilitaryLevel("*", "*", 4),
                                                     MilitaryLevel("<", ">", 4))):
        self.size = size
        self.edges_left = edges_left
        self.edges_right = edges_right
        self.insignia = insignia
        self.check_parameters()
        self.max_rank = self.insignia_sum()

    def check_parameters(self):
        if not isinstance(self.size, int):
            raise ValueError("Size argument is not int.")
        if not (isinstance(self.edges_left, type(" ")) and len(self.edges_left) == 2):
            raise ValueError("Edges_left argument is not 2 characters length string.")
        if not (isinstance(self.edges_right, type(" ")) and len(self.edges_right) == 2):
            raise ValueError("Edges_right argument is not 2 characters length string.")
        if not isinstance(self.insignia, tuple):
            raise ValueError("Insignia argument is not a tuple.")
        for item in self.insignia:
            if not (isinstance(item, MilitaryLevel)):
                raise ValueError("Insignia argument does not contain MilitaryLevel objects.")
            elif not item.check_size(self.size):
                print("Insignia {0} was bigger size than MilitaryRank, but was cut.".format(item.char_right))

    def insignia_sum(self):
        _sum = 0
        for duo in self.insignia:
            _sum += duo.size
        return _sum

    def get_rank(self, level, side):
        if not isinstance(level, int):
            raise ValueError("Level argument is not type int.")
        if level > self.max_rank:
            raise ValueError("Level argument is higher than max value.")
        if not isinstance(side, Side):
            raise ValueError("Side is not type of Side class.")
        level_orig = level
        rank_insignia = ""
        rank_count = 0
        i = 0
        for duo in self.insignia:
            if 0 <= duo.size - level <= duo.size:
                rank_count = duo.size - level
                if side == Side.left:
                    rank_insignia = "{0}{1}{2}{3}".format(
                            self.edges_left[0],
                            " "*(self.size-level),
                            duo.char_left*level,
                            self.edges_left[-1])
                else:
                    rank_insignia = "{0}{1}{2}{3}".format(
                            self.edges_right[0],
                            duo.char_right*level,
                            " "*(self.size-level),
                            self.edges_right[-1])
                break
            else:
                level -= duo.size
                i += 1
                continue
        return (level_orig, rank_insignia)

    def show_all(self):
        for i in range(self.max_rank+1):
            print(self.get_rank(i, Side.left), self.get_rank(i, Side.right))



if __name__ == '__main__':
    print("\n===Show all===\n")
    x = MilitaryRank(size=4, edges_left="{|", edges_right="|}",
                     insignia=(MilitaryLevel("'", "'", 4),
                                MilitaryLevel("+", "+", 4),
                                MilitaryLevel("*", "*", 3),
                                MilitaryLevel("<", ">", 3)))
    x.show_all()
    print("\n===Show extra rank===\n")
    print(" 3", x.get_rank(3, Side.right)[-1], repr(Side.right))
    print(" 8", x.get_rank(8, Side.right)[-1], repr(Side.right))
    print("13", x.get_rank(13, Side.left)[-1], repr(Side.left))

# vim:set sr et ts=4 sw=4 ft=python fenc=utf-8: // See Vim, :help 'modeline'