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)
