def load_latest_game(cls, email): """Return latest game by a user or a new game if one didn't exist.""" with connection: with connection.cursor() as cursor: user = User.get_user_by_email(email) cursor.execute(database.GET_LATEST_GAME_TABLE_BY_EMAIL, (email,)) bulk = cursor.fetchone() print (bulk) if bulk: (game_table_id, timestamp_created, computer_hand_id, player_hand_id, deck_id, user_id, turn_indicator) = bulk else: return cls.new_game(user) # Get Hands cursor.execute(database.GET_HAND_BY_ID, (player_hand_id, )) p_s1, p_v1, p_s2, p_v2, p_s3, p_v3, p_s4, p_v4, p_s5, p_v5,\ uid, mtime = cursor.fetchone() player = User.get_user_by_id(uid) player_hand = Hand(player, Card(p_s1, p_v1), Card(p_s2, p_v2), Card(p_s3, p_v3), Card(p_s4, p_v4), Card(p_s5, p_v5)) cursor.execute(database.GET_HAND_BY_ID, (computer_hand_id, )) c_s1, c_v1, c_s2, c_v2, c_s3, c_v3, c_s4, c_v4, c_s5, c_v5,\ cuid, cmtime = cursor.fetchone() computer = User.get_user_by_id(COMPUTER_UID) computer_hand = Hand(computer, Card(c_s1, c_v1), Card(c_s2, c_v2), Card(c_s3, c_v3), Card(c_s4, c_v4), Card(c_s5, c_v5)) deck = Deck(deck_id) return cls(deck, user, player_hand, computer_hand, game_table_id, turn_indicator)
def five_completed_tasks(): card1 = Card(1, 1, "Card 1 Done", LISTS[2].id, None, YESTERDAY_DATE) card2 = Card(2, 2, "Card 2 Done", LISTS[2].id, None, YESTERDAY_DATE) card3 = Card(3, 3, "Card 3 Done", LISTS[2].id, None, YESTERDAY_DATE) card4 = Card(4, 4, "Card 4 Done", LISTS[2].id, None, YESTERDAY_DATE) card5 = Card(5, 5, "Card 5 Done", LISTS[2].id, None, YESTERDAY_DATE) return [card1, card2, card3, card4, card5]
def cards_with_last_modified_dates(): card1 = Card(1, 1, "Card 1 Todo Yesterday", LISTS[0].id, None, YESTERDAY_DATE) card2 = Card(2, 2, "Card 2 Todo Today", LISTS[0].id, None, TODAY_DATE) card3 = Card(3, 3, "Card 3 Done Yesterday", LISTS[2].id, None, YESTERDAY_DATE) card4 = Card(4, 4, "Card 4 Done Today", LISTS[2].id, None, TODAY_DATE) return [card1, card2, card3, card4]
def __initialize_deck(self): for suite in self.__suites: for count, name in enumerate(self.__names, start=1): if name == 'ACE': card = Card(suite, name, 'ACE', 10) elif name == 'JACK' or name == 'QUEEN' or name == 'KING': card = Card(suite, name, 'FACE_CARD', 10) else: card = Card(suite, name, 'RANKS', count) self.__cards.append(card)
def updateAsInventory(self, context): self.cards = [] if context.update: json = self.api.updateAndGetInitFile(context) else: json = self.api.getInit(context) card_map = json['user_units'] self.name = json['user_data']['name'] + "_inventory" # print('[Deck] inventory for ', self.name) for card in card_map: card_to_add = Card() card_to_add.id = int(card_map[card]['unit_id']) card_to_add.level = int(card_map[card]['level']) print('[Deck] Adding card - id: {0}, level: {1}'.format( card_to_add.id, card_to_add.level)) self.cards.append(card_to_add) self.updateDeckFromXML() print('[Deck] update as inventory - returning') return self.cards
def test_get_kind(): """ Expect to return kind as string given data. """ kind = entity.get_kind(Card({})) assert kind == 'card'
def test_query_cards(self): # initialize some sample cards # testing comment user = self.generate_user(COOL_USERNAME, PASSWORD) card_names = [ "Jace, The Mind Sculptor", "Jace's Defeat", "Jace, Vrynn's Prodigy", "Jackal Pup", "Scalding Tarn", "Ancestral Vision", "Serum Visions", "Lightning Bolt", "Forked Bolt", "Boltwing Marauder", "Firebolt" ] for name in card_names: new_card = Card(name) db.session.add(new_card) db.session.commit() # assert that each query for a specific card has exactly one match. # Note for our input that none of the names are substrings of another for name in card_names: sample = Card.query.filter_by( search_name=Card.format_card_name_for_search(name)).first() query = user.query_cards(name) self.assertEqual(len(query), 1) # these queries have the query amount and expected output test_queries = [("Tarn", 1), ("Jace", 3), ("jace", 3), ("Jac", 4), ("bolt", 4), ("vision", 2), ("visions", 1)] for test in test_queries: card_name = test[0] expected_quantity = test[1] query = user.query_cards(card_name) self.assertEqual(len(query), expected_quantity)
def test_card_search_name(self): # there's 18000 in this AllCards.json so we only check some of them # This variable can be adjusted to check all of them # To check all 18000 cards, it will take at least 30 seconds # and will bog down other tests NUM_CARDS_TO_CHECK = 100 with open("./data/AllCards.json", "r") as f: card_data = json.load(f) count = 0 for name in card_data: if count < NUM_CARDS_TO_CHECK: new_card = Card(name) db.session.add(new_card) count += 1 db.session.commit() count = 0 for name in card_data: if count < NUM_CARDS_TO_CHECK: card = Card.search_card_by_name(name) self.assertIsNotNone(card) formatted_name = Card.format_card_name_for_search(name) cards = Card.query.filter_by(search_name=formatted_name).all() self.assertEqual(len(cards), 1) count += 1
def choose_card(db_conn, user, unit): """ Given a user and a unit, choose an appropriate card. Return a card instance. """ # TODO-3 simplify this method unit_id = unit['entity_id'] query = (Card.start_accepted_query().filter({ 'unit_id': unit_id }).sample(10)) # TODO-2 index # TODO-3 does this belong as a model method? # TODO-2 is the sample value decent? # TODO-2 has the learner seen this card recently? cards = [Card(d) for d in query.run(db_conn)] if not len(cards): return None previous_response = get_latest_response(user['id'], unit_id, db_conn) if previous_response: learned = previous_response['learned'] # Don't allow the previous card as the next card cards = [ card for card in cards if card['entity_id'] != previous_response['card_id'] ] else: learned = init_learned shuffle(cards) assessment, nonassessment = partition(cards, lambda c: c.has_assessment()) choose_assessment = random() < p_assessment_map[floor(learned * 10)] if choose_assessment: if not len(assessment): return nonassessment[0] for card in assessment: params = get_card_parameters({'entity_id': card['entity_id']}, db_conn) if params: values = get_card_parameters_values(params) guess = values['guess'] slip = values['slip'] correct = calculate_correct(guess, slip, learned) if 0.25 < correct < 0.75: return card else: return card return assessment[0] if len(nonassessment): return nonassessment[0] if len(assessment): return assessment[0] return None
def setUp(self): db.create_all() # initialize 100 cards for x in range(0, 100): new_card = Card("card" + str(x)) db.session.add(new_card) db.session.commit()
def card_create(request): '''创建礼包卡 ''' msg = '' card_count = int(request.REQUEST.get('card_count','0')) batch_id = int(request.REQUEST.get('batch_id','0')) record = int(request.REQUEST.get('record','0')) card_size = 2000 if card_count < card_size: card_size = card_count if card_count - record < card_size: card_size = card_count - record is_finish = 0 if card_count == record: is_finish = 1 if batch_id > 0 and card_count > 0 and card_size > 0 and is_finish == 0: try: card_batch = CardBatch.objects.using('card').get(id = batch_id) key = card_batch.key #card = Card() card_table_name = Card.get_card_table_name(key) Card._meta.db_table = Card.get_card_table_name(key) card = Card() card.batch_id = batch_id conn = connections['card'] cursor = conn.cursor() if card_batch: insert_sql = [] add_time = datetime.datetime.now() number_cache_list = [] for i in range(0,card_size): while True: number = Card.get_card_number(key) if number not in number_cache_list: number_cache_list.append(number) break count_sql = "SELECT COUNT(*) FROM `%s` c WHERE c.`number` = '%s' "%(card_table_name,number) cursor.execute(count_sql) count = cursor.fetchone() repeat_count = int(count[0]) if repeat_count == 0: insert_sql.append("('%s','%s','%s',0,0)"%(batch_id,number,add_time)) i = i + 1 cursor.execute('INSERT INTO `%s`(`batch_id`,`number`,`add_time`,`status`,`use_count`) VALUES %s'%(card_table_name, ','.join(insert_sql))) cursor.close() card_batch.total_count = card_batch.total_count + i card_batch.save(using='card') record = record + i except Exception, e: print('create card number error:', e) traceback.print_exc() msg = '%s'%e
def test_get_cards(api): response = api.get('https://statsroyale.com/api/cards') assert response.ok cards = [] for card in response.json(): cards.append(Card(**card)) assert len(cards) == 98
def draw(self): with connection: with connection.cursor() as cursor: cursor.execute(database.DRAW_A_CARD, (self.id, )) _id, suit, value, deck = cursor.fetchone() cursor.execute(database.MARK_A_CARD_DRAWN, (datetime.datetime.timestamp( datetime.datetime.now()), _id)) return Card(suit, value)
def post(self): parsed_args = parser.parse_args() card = Card(title=parsed_args['title'], content=parsed_args['content']) if 'links' in parsed_args and parsed_args['links'] is not None: for l in parsed_args['links']: link = Link(url=l['url']) card.links.append(link) session.add(card) session.commit() return card, 201
def instance(data): """ Given a kind and some json, call insert on that kind and return the results. """ if 'card' in data: return Card(data['card']) # TODO-1 This needs to also get the right card kind... elif 'unit' in data: return Unit(data['unit']) elif 'set' in data: return Set(data['set'])
def create_card(deck, **overrides): params = { "data": {"random": "data"}, "deck": deck, } params.update(overrides) card = Card(**params) db.session.add(card) db.session.commit() return card
def post(self): body = request.get_json() card = Card(body["card_number"], body["emp_id"]) try: card.save() except Exception as e: return ( { "msg": "Something went wrong while adding access card to db.", "description": e, }, 500, ) return {"msg": "New card created for employee.", "card": card.json()}, 201
def instance_new_entity(data): """ Save as above, but a little safer. """ fields = ('id', 'created', 'modified', 'entity_id', 'previous_id', 'status', 'available') if 'card' in data: return Card(omit(data['card'], fields)) # TODO-1 This needs to also get the right card kind... elif 'unit' in data: return Unit(omit(data['unit'], fields)) elif 'set' in data: return Set(omit(data['set'], fields))
def load(cls, id): """id in the hands table.""" with connection: with connection.cursor() as cursor: cursor.execute(database.GET_HAND_BY_ID, (id, )) (suit1, value1, suit2, value2, suit3, value3, suit4, value4, suit5, value5, user_id, time_modified) = cursor.fetchone() cards = [] for suit, value in Hand.pairwise( (suit1, value1, suit2, value2, suit3, value3, suit4, value4, suit5, value5)): if suit and value: cards.append(Card(suit, value)) return cls(User.get_user_by_id(user_id), *cards)
def test_card_contract(): card_json = { "id": 26000014, "name": "Musketeer", "icon": "musketeer", "cost": 4, "rarity": "Rare", "type": "tid_card_type_character", "arena": 0, "hash": "b26f2c4dab2ba00cbabd91c2cc755f9f" } card = Card(**card_json) assert card.name == 'Musketeer'
def create_card(): form = CardForm() if request.method == 'POST' and form.validate_on_submit(): cpf = form.cpf.data income = form.income.data score, credit, approval = score_calc(income) # score = score_calc(float(income))[0] # credit = score_calc(float(income))[1] flash(f'The CPF {cpf} with score {score} and Income {income} was approval status is {approval} ') Card(cpf, income, score, credit, approval).save_to_mongo() print("Saved to DB") return render_template("cards/create_card.html", form=form, pageTitle="Create Credit Card Form")
def game(bet_value, player): color_list = ["Trèfle", "Coeur", "Pique", "Carrau"] value_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13] deck = [] for value in value_list: for color in color_list: new_card = Card(value, color) deck.append(new_card) selected_cards = random.sample(deck, 5) print("Vous avez tiré : \n") for selected_card in selected_cards: player.add_card(selected_card) deck.remove(selected_card) print(selected_card.get_name()) final_card_list = [] for card_tmp in player.get_card_list(): choice = input("\nVoulez vous garder : " + card_tmp.get_name() + " | oui/non ") if choice == "oui": final_card_list.append(card_tmp) print("ok, la carte est conservé") elif choice == "non": new_selected_card = random.sample(deck, 1) final_card_list.append(new_selected_card[0]) deck.remove(new_selected_card[0]) print("vous avez tiré :" + new_selected_card[0].get_name()) else: final_card_list.append(card_tmp) print("Veleur incorrecte, la carte est conservé par défaut") player.update_all_cards(final_card_list) print("_______________________________________\n") print("Votre tirage final est : \n") for card_to_dispaly in player.get_card_list(): print(card_to_dispaly.get_name()) result(bet_value, player)
def getDeckFromCardMap(self, cardMap, lower, upper): self.cards = [] order = [] # Get index values of array for card in cardMap: card_index = int(card) if lower <= card_index <= upper: order.append(card_index) order.sort() for index in range(len(order)): for card in cardMap: if int(card) == order[index]: card_to_add = Card() card_to_add.id = int(cardMap[card]['unit_id']) card_to_add.level = int(cardMap[card]['level']) self.cards.append(card_to_add)
def get_suit_rank_date_chart(self, config): path_to_chart = 'suit_rank_date_chart' daily_tt_data = self.get_report_data() chart_title = "Suit/Rank Clustering by Date" if self.CONFIG_START_DATE in config: daily_tt_data = self.filter_by_date(config[self.CONFIG_START_DATE], config[self.CONFIG_END_DATE], daily_tt_data) chart_title = "Suit and Rank Plot for the Date Range of {} -- {}".format( config[self.CONFIG_START_DATE], config[self.CONFIG_END_DATE]) # each suit is a key in a dict, each val is a list containing these as items: # (datetime(2013, 1, 2), 300) # (yyyy,m,d), rank chart_data_set = {} for dtt in daily_tt_data: data = daily_tt_data[dtt] (month, day, year) = data['date'].split("/") # datetime and card obj import datetime dailytt_date = datetime.date(int(year), int(month), int(day)) card = Card() try: card.suit = data[self.REPORT_TERM_SUIT] card.rank = int(data[self.REPORT_TERM_RANK]) except KeyError as kex: print('caught bad key {} for data {} with id {}'.format( kex, data, dtt)) dt = Daily_TT(dailytt_date, card) chart_keys = chart_data_set.keys() if card.suit in chart_keys: chart_data_set[card.suit].append((dt.date, dt.card.rank)) else: chart_data_set[card.suit] = [(dt.date, dt.card.rank)] logging.info('suits by date data looks like: {}'.format( str(chart_data_set))) return self.get_date_xy_chart(data=chart_data_set)
def test_cards_with_same_suite_and_value_are_equal(self): card1, card2 = Card('5C'), Card('5C') self.assertEqual(card1, card2)
def test_min_of_lower_card_diff_suite(self): card1, card2 = Card('AC'), Card('2H') self.assertLess(card2, card1)