def run_test():
cm = CardManager(card_filename='res/CubeLegacyClassic.csv')
mm = MetatribeManager(
type_to_tribe_filename='res/types.txt',
special_tribes_filename='res/special_tribes.txt',
)
culler = Culler(cull_filename='res/culls_v2.txt')
creatures = cm.filter(lambda x: 'Creature' in x.supertypes)
culled = creatures.filter(lambda x: not culler(x))
jcc = culled.filter(lambda x: mm.is_jcc(x))
non_jcc = culled.filter(lambda x: not mm.is_jcc(x))
print('creatures: {}'.format(len(creatures.cards)))
print('non-jcc : {}'.format(len(non_jcc.cards)))
print('jcc : {}'.format(len(jcc.cards)))
print('culls : {}'.format(len(culler.card_names)))
print('-----')
tribes = mm.split_by_tribe(non_jcc.cards)
del tribes['jcc']
for t, cs in tribes.items():
print('{:6}: {}'.format(t, len(cs)))
remaining = non_jcc.filter(lambda x: not mm.is_myth(x))
remaining = remaining.filter(lambda x: not mm.is_animal(x))
remaining = remaining.filter(lambda x: not mm.is_human(x))
def test_user_search_card_no_found(self, mocked_input):
"""
Tests user_search_card when no card result matches.
"""
mocked_input.side_effect = ['BCIT student card', 'done']
Controller.card_manager = CardManager()
self.assertRaises(NameNotFoundError, Controller.user_search_card)
def test_user_add_card_invalid_card_type_string(self, mocked_input):
"""
Tests user_add_card when invalid card type(String) given.
"""
mocked_input.side_effect = ['my choice', 'done']
Controller.card_manager = CardManager()
self.assertRaises(InvalidCardTypeError, Controller.user_add_card)
def __init__(self, skip_init_cards=False):
self.space_pad = 0
self.moves_tried = {}
self.card_manager = CardManager()
initial_cards = self.card_manager._initial_draw()
self.initialize_board(initial_cards)
self.update_next_cards()
def test_user_add_card_reward_card(self, mocked_input):
"""
Tests user_add_card when a reward card is successfully added.
"""
mocked_input.side_effect = [
'1', 'Starbucks reward card', 'eric', 'Starbucks', 'points', 'done'
]
Controller.card_manager = CardManager()
self.assertTrue(Controller.user_add_card)
def test_user_add_card_balance_card(self, mocked_input):
"""
Tests user_add_card when a balance card is successfully added.
"""
mocked_input.side_effect = [
'2', 'Compass Card', 'eric', 'TransLink', '150', 'done'
]
Controller.card_manager = CardManager()
self.assertTrue(Controller.user_add_card)
def test_user_add_card_invalid_height_input(self, mocked_input):
"""
Tests user_add_card when invalid height input given.
"""
mocked_input.side_effect = [
'6', 'Driver licence', 'eric', 'government of Canada',
'2000-12-12', '2020-12-12', 'A010xxx', '26', 'very tall', 'done'
]
Controller.card_manager = CardManager()
self.assertRaises(InvalidHeightError, Controller.user_add_card)
def test_user_add_card_invalid_date_input(self, mocked_input):
"""
Tests user_add_card when invalid date format given.
"""
mocked_input.side_effect = [
'4', 'card a', 'eric', 'somewhere', 'Oct.6th.1919'
'done'
]
Controller.card_manager = CardManager()
self.assertRaises(InvalidDateFormatError, Controller.user_add_card)
def test_user_add_card_invalid_balance_input(self, mocked_input):
"""
Tests user_add_card when invalid card balance given.
"""
mocked_input.side_effect = [
'2', 'card a', 'eric', 'somewhere', '-100'
'done'
]
Controller.card_manager = CardManager()
self.assertRaises(InvalidCardBalanceError, Controller.user_add_card)
def test_user_add_card_other_card(self, mocked_input):
"""
Tests user_add_card when an other type card is successfully added.
"""
mocked_input.side_effect = [
'7', 'Moive ticket', 'eric', 'Scotia Bank theatre',
'Redeems one movie', 'done'
]
Controller.card_manager = CardManager()
self.assertTrue(Controller.user_add_card)
def test_user_add_card_govID_card(self, mocked_input):
"""
Tests user_add_card when a government id card is successfully added.
"""
mocked_input.side_effect = [
'6', 'Drivers licence', 'eric', 'ICBC', '2012-12-12', '2013-12-12',
'123123123', '26', '179', 'Male', 'done'
]
Controller.card_manager = CardManager()
self.assertTrue(Controller.user_add_card)
def test_user_add_card_id_card(self, mocked_input):
"""
Tests user_add_card when a id card is successfully added.
"""
mocked_input.side_effect = [
'5', 'BCIT student card', 'eric', 'BCIT', '2012-12-12',
'2013-12-12', 'A01037479', 'done'
]
Controller.card_manager = CardManager()
self.assertTrue(Controller.user_add_card)
def test_user_add_card_bank_card(self, mocked_input):
"""
Tests user_add_card when a bank card is successfully added.
"""
mocked_input.side_effect = [
'4', 'BMO credit card', 'eric', 'BMO', '2012-12-12', '2013-12-12',
'downtown branch', 'done'
]
Controller.card_manager = CardManager()
self.assertTrue(Controller.user_add_card)
def test_user_add_card_Membership_card(self, mocked_input):
"""
Tests user_add_card when a membership card is successfully added.
"""
mocked_input.side_effect = [
'3', 'YMCA card', 'eric', 'YMCA', '2012-12-12', '2013-12-12',
'regular', 'done'
]
Controller.card_manager = CardManager()
self.assertTrue(Controller.user_add_card)
def test_user_back_up_data_success(self, mocked_input):
"""
Tests user_back_up_card when successfully backed up.
"""
mocked_input.side_effect = [
'1', 'Starbucks reward card', 'eric', 'Starbucks', 'points', 'done'
]
Controller.card_manager = CardManager()
Controller.user_add_card()
file_path = Controller.user_backup_data()
self.assertTrue(os.path.exists(file_path))
def start_app(cls):
"""
Starts the application by prompting user menu.
Catches all kinds of exceptions if raised.
"""
cls.card_manager = CardManager()
menu_dict = {1: Controller.user_add_card,
2: Controller.user_remove_card,
3: Controller.user_view_all_card,
4: Controller.user_view_card,
5: Controller.user_search_card,
6: Controller.user_backup_data,
7: Controller.end_app}
while True:
try:
user_input = int(input(f'1. Add a card\n'
f'2. Remove a card\n'
f'3. View all cards\n'
f'4. View cards by type\n'
f'5. Search for a card\n'
f'6. Back up data\n'
f'7. Exit app\n'
f' : '))
menu_dict[user_input]()
except KeyError:
print(f'Invalid option\nPlease enter integer 1 to 7!\n')
except ValueError:
print(f'Invalid option\nPlease enter integers only!\n')
except InvalidCardBalanceError as e:
print(f'InvalidCardBalanceError caught! {e}')
except InvalidCardTypeError as e:
print(f'InvalidCardTypeError caught! {e}')
except InvalidDateFormatError as e:
print(f'InvalidDateFormatError caught! {e}')
except DuplicatedNameError as e:
print(f'DuplicatedNameError caught! {e}')
except NameNotFoundError as e:
print(f'NameNotFoundError caught! {e}')
except EmptyCardManagerError as e:
print(f'EmptyCardManagerError caught! {e}')
except InvalidAgeError as e:
print(f'InvalidAgeError caught! {e}')
except InvalidHeightError as e:
print(f'InvalidHeightError caught! {e}')
except InvalidSexError as e:
print(f'InvalidSexError caught! {e}')
except TypeError as e:
print(f'InvalidFileTypeError caught! {e}')
def test_user_back_up_data(self):
"""
Tests user_back_up_card when card manager is empty.
"""
Controller.card_manager = CardManager()
self.assertRaises(EmptyCardManagerError, Controller.user_backup_data)
def user_add_card(cls):
"""
Prompts for user inputs to create a card and add it to card manager.
"""
print('Enter card type:')
for key, card_type in CardManager.card_str_type_dict.items():
print(f'{key}: {card_type}')
try:
card_type_key = int(input(': '))
except ValueError:
raise InvalidCardTypeError
if card_type_key not in CardManager.card_type_dict.keys():
raise InvalidCardTypeError
print(
f'Adding a new {CardManager.card_str_type_dict[card_type_key]}: ')
card_name = input(' Enter card name: ')
if len(card_name) == 0:
print('Card name cannot be empty!\n')
return
for card in cls.card_manager.cards:
if card_name == Controller.card_manager.card_name(card):
raise DuplicatedNameError
card_holder = input(' Enter card holder name: ')
issued_by = input(' Issued by: ')
expiry_date = None
issue_date = None
id_number = None
new_card = None
date_format = '%Y-%m-%d'
if issubclass(CardManager.card_type_dict[card_type_key],
Expirable):
issue_date = input(' Enter issue date(YYYY-MM-DD): ')
try:
datetime.datetime.strptime(issue_date, date_format)
except ValueError:
raise InvalidDateFormatError
expiry_date = input(' Enter expiry date(YYYY-MM-DD): ')
try:
datetime.datetime.strptime(expiry_date, date_format)
except ValueError:
raise InvalidDateFormatError
if issubclass(CardManager.card_type_dict[card_type_key], IDCard):
id_number = input(' Enter card ID number: ')
if card_type_key == 1:
reward_type = input(
' Enter reward type(e.g. stamps/points): ')
new_card = CardManager.create_reward_card(card_name,
card_holder,
issued_by,
reward_type)
elif card_type_key == 2:
try:
balance = int(input(' Enter card balance: '))
except ValueError:
raise InvalidCardBalanceError
if balance < 0:
raise InvalidCardBalanceError
new_card = CardManager.create_balance_card(card_name,
card_holder,
issued_by, balance)
elif card_type_key == 3:
membership_level = input(' Enter membership_level(e.g. vip): ')
new_card = CardManager.create_membership_card \
(card_name, card_holder, issued_by, issue_date,
expiry_date,
membership_level)
elif card_type_key == 4:
bank_info = input(' Enter bank information(e.g. address): ')
new_card = CardManager.create_bank_card(card_name, card_holder,
issued_by, issue_date,
expiry_date, bank_info)
elif card_type_key == 5:
new_card = CardManager.create_id_card(card_name, card_holder,
issued_by, issue_date,
expiry_date, id_number)
elif card_type_key == 6:
print(' Enter following personal information: ')
try:
age = int(input(' Enter age(0-99): '))
except ValueError:
raise InvalidAgeError
else:
if age < 0 or age > 100:
raise InvalidAgeError
try:
height = float(input(' Enter height(cm): '))
except ValueError:
raise InvalidHeightError
else:
if height < 0:
raise InvalidHeightError
sex = input(' Enter sex(male/female): ')
if sex.lower() not in ['male', 'female']:
raise InvalidSexError
personal_information = {'age': age, 'sex': sex, 'height': height}
new_card = CardManager.create_gov_id_card \
(card_name, card_holder, issued_by, issue_date,
expiry_date, id_number, personal_information)
elif card_type_key == 7:
card_description = input(' Enter card description: ')
new_card = CardManager.create_other(card_name, card_holder,
issued_by,
card_description)
cls.card_manager.add_card(new_card)
print(
f'{Controller.card_manager.card_name(new_card)} '
f'is successfully added to card manager! \n')
class GameBoard(object):
def __init__(self, skip_init_cards=False):
self.space_pad = 0
self.moves_tried = {}
self.card_manager = CardManager()
initial_cards = self.card_manager._initial_draw()
self.initialize_board(initial_cards)
self.update_next_cards()
def _random_coord(self):
return int(floor(random.random()*4))
def update_next_cards(self):
highest_card = self.highest_card()
self.next_cards = self.card_manager.draw_card(highest_card)
# Make sure that we space things out enough for large entries
self.space_pad = max(int(log(highest_card)/log(10)), self.space_pad)
def initialize_board(self, initial_cards):
self.board = [[0]*4, [0]*4, [0]*4, [0]*4] # [row][col]
for card in initial_cards:
placed = False
while not placed:
i, j = self._random_coord(), self._random_coord()
placed = self.board[i][j] == 0
if placed:
self.board[i][j] = card
def move_board(self, move_direction):
# Make from text direction to coordinate direction
# and function to apply
move_map = {
'up': (-1, self.shift_column),
'down': (1, self.shift_column),
'left': (-1, self.shift_row),
'right': (1, self.shift_row),
}
# Apply the shift to all rows or columns
direc, func = move_map[move_direction]
new_card_locs = []
for ii in xrange(4):
new_coord = func(ii, direc)
if new_coord is not None:
new_card_locs.append(new_coord)
if len(new_card_locs) == 0:
self.moves_tried[move_direction] = True
raise InvalidMoveException()
self._insert_new_card(new_card_locs)
self.update_next_cards()
self.moves_tried = {}
@property
def no_more_moves(self):
return len(self.moves_tried) == 4
def _insert_new_card(self, new_card_locs):
# Randomly select a new card and a new location for it
new_card = random.choice(self.next_cards)
new_coord = random.choice(new_card_locs)
self.board[new_coord[0]][new_coord[1]] = new_card
def shift_column(self, idx, direc):
"""
shifts column at idx up if direc = -1, down if direc = 1
returns the coordinate where a new card could be added,
None if no card coud be added
"""
col = [self.board[r][idx] for r in xrange(4)]
col, did_shift = shift_values(col, direc)
for r in xrange(4):
self.board[r][idx] = col[r]
new_coord = None
if did_shift:
y_coord = 0 if direc == 1 else 3
new_coord = (y_coord, idx)
return new_coord
def shift_row(self, idx, direc):
"""
shifts row at idx left if direc = -1, right if direc = 1
returns the coordinate where a new card could be added,
None is no card could be added
"""
row = self.board[idx]
row, did_shift = shift_values(row, direc)
self.board[idx] = row
new_coord = None
if did_shift:
x_coord = 0 if direc == 1 else 3
new_coord = (idx, x_coord)
return new_coord
def highest_card(self):
return max((max(x) for x in self.board))
def __str__(self):
ret = ""
fmt_str = "{:"+"{}".format(self.space_pad+2)+"d}"
for row in self.board:
row_str = ""
for val in row:
row_str += fmt_str.format(val)
row_str += "\n"
ret += row_str
return ret[:-1]
def __repr__(self):
return self.__str__()
def calc_score(self):
final_score = 0
for i in xrange(4):
for j in xrange(4):
final_score += score_card(self.board[i][j])
return int(final_score)
