def get_card(id=None, name=None, fields=None):
"""
Retrieves a card from the database using a name or card id. If both name
and id are provided, only the id will be used. If neither id nor name are
provided this function will return a random card.
:param name: Optional. Specifies the name of the card to retrieve.
:param id: Optional. Specifies the id of the card to retrieve.
:param fields: Optional. Specifies what fields to populate for the returned
card object (defaults to all).
:returns: A Card object.
"""
card_url = "{0}/{1}/{2}"
if fields:
fields = 'fields={0}'.format(','.join(fields))
results = None
if id:
results = _process_simple_request(
card_url.format(MTG_DB_URL, CARDS_PATH, id),
error_msg="No card found by that id.",
payload=fields)
elif name:
results = _process_simple_request(
card_url.format(MTG_DB_URL, CARDS_PATH, clean_card_name(name)),
error_msg="No card found by that name.",
payload=fields)[0]
else:
return get_random_card(fields=fields)
return Card(results)
def add_card():
"""
Add a card to the database, given properly formed JSON information.
TODO: Error messages
:return:
"""
data = request.get_json()
if data is None:
return jsonify({'status': 400, 'message': 'no JSON in request body.'})
if 'listId' not in data or data['listId'] is None:
return jsonify({
'status': 400,
'message': 'must provide listId to create a card.'
})
l = List.query.get(data['listId'])
if l is None:
return jsonify({
'status': 400,
'message': 'given listId does not exist.'
})
c = Card(data.get('title', ''), data.get('description', ''), l)
db.session.add(c)
db.session.commit()
return jsonify({'status': 201})
def test_a_card_can_be_played_in_a_trick(self) -> None:
players = [Player(), Player(), Player(), Player()]
deal = Deal(players=players, bidder_index=0)
trick = Trick(deal=deal, leading_player_index=0)
players[0].hand = {Card(suit=Suit.SPADES, rank=Rank.ACE)}
trick.play(Card(suit=Suit.SPADES, rank=Rank.ACE))
# The turn must shift to the next player
self.assertEqual(1, trick.player_index_to_play)
# The card must be removed from the player's hand
self.assertEqual(0, len(players[0].hand))
# The card resides within the played cards of the trick
self.assertEqual(
True,
Card(suit=Suit.SPADES, rank=Rank.ACE) in trick.played_cards)
def make_card():
if session['Admin']:
if request.method == 'GET':
page = request.args.get('page', 1, type=int)
vips = Vip.query.all()
card = Card.query.paginate(page, per_page=8, error_out=False)
return render_template('user.html',
template='make_card.html',
admin=True,
cards=card.items,
look=card,
vips=vips)
else:
card_num = request.form.get('cards')
time = request.form.get('time')
vip = request.form.get('vip')
if all([card_num, time, vip]):
name = Vip.query.filter_by(id=int(vip)).first()
name = name.name
for add in range(int(card_num)):
md5 = make_md5()
find = Card.query.filter_by(card=md5).first()
if find:
md5 = make_md5()
add_card = Card(name=name, vip_id=vip, time=time, card=md5)
db.session.add(add_card)
db.session.commit()
return jsonify({'msg': 'make'})
else:
return jsonify({'msg': 'e1'})
else:
return redirect(url_for('main.console'))
def add_card(house_name, key, value):
house_list = House.query(House.name == house_name).fetch()
if house_list:
card = Card(card_key=key, value=value)
house = house_list[0]
card.key = ndb.Key(Card, key, parent=house.key)
card.put()
return
def test_has_7_card_straight(self):
deck = Deck(custom_cards=[
Card(rank="3", rank_value=3, suit="𓆏", color="RED"),
Card(rank="5", rank_value=5, suit="𓃰", color="BLACK"),
Card(rank="6", rank_value=6, suit="𓆏", color="RED"),
Card(rank="7", rank_value=7, suit="𓆏", color="RED"),
Card(rank="7", rank_value=7, suit="𓃰", color="BLACK"),
Card(rank="8", rank_value=8, suit="𓃰", color="BLACK"),
Card(rank="9", rank_value=9, suit="𓃰", color="BLACK"),
Card(rank="10", rank_value=10, suit="𓃰", color="BLACK"),
Card(rank="J", rank_value=11, suit="𓆏", color="RED"),
])
self.assertTrue(deck.evaluator.has_straight(7))
def GetMessage(self, request, context):
ip = context.peer().split(':')[1]
time = datetime.utcnow()
print("called from %s (%d cards)" % (ip, len(request.cards)))
collection = gpu_db[ip]
cards = [Card(card=c, ip=ip, time=time) for c in request.cards]
collection.insert_many([c.to_json() for c in cards])
return ServerResponse(success='%s, your GPU\' info is collected.' %
request.cards[0].gpu_name)
def create_card(user_id):
"""Create new card in database for user"""
data = request.get_json()
card = Card(word=data["word"], defn=data["defn"], bin=0,
wrongs=0, user_id=user_id)
db.session.add(card)
db.session.commit()
return "card created"
def add_cards():
cards = request.json
db_cards = []
for card in cards:
card = Card(scryfall_id = card.id,name=card.name)
db_cards.add(card)
db.session.add_all(db_cards)
db.session.commit()
return jsonify({working:'as intended'})
def make_deck(self):
file_path = "txt/" + str(self.type) + "_cards.txt"
f = open(file_path)
cards = f.readlines()
for card in cards:
card_arr = card.split('-', 1)
new_card = Card(
value=card_arr[0].strip(),
description=card_arr[1].strip()
)
self.cards.append(new_card)
def create_rab():
if db.session.query(Roles).filter_by(
id_role=current_user.id_role).first().name != "Менеджер":
return 'What are you doing here?'
if request.method == 'GET':
return render_template('create_rab.html',
role=db.session.query(Roles).filter_by(
id_role=current_user.id_role).first().name)
if request.method == 'POST':
cipher = Salsa20.new(key=secret)
fio = request.form['fio']
created = time.strftime('%d/%m/%Y',
time.localtime()) # использовать дату
dob = request.form['dob']
if request.form['role'] == 'Стажер':
role = 1
id_position = 0
elif request.form['role'] == 'Продавец-консультант':
role = 1
id_position = 1
elif request.form['role'] == 'Менеджер':
role = 2
id_position = 2
email = request.form['email']
phone = request.form['phone']
company = request.form['company']
hash_password = generate_password_hash(request.form['password'])
hash_address = request.form['address']
hash_card = str(cipher.nonce +
cipher.encrypt(bytes(request.form['card'], 'utf-8')))
amount = request.form['amount']
new_Client = Clients(email=email,
fio=fio,
created=created,
dob=dob,
id_role=role)
db.session.add(new_Client)
db.session.commit()
new_Contactdetailsclients = Contactdetailsclients(
id_clients=new_Client.id_clients, phone=phone, company=company)
new_Secretdate = Secretdate(id_clients=new_Client.id_clients,
hash_password=hash_password,
hash_address=hash_address)
new_Card = Card(id_clients=new_Client.id_clients,
hash_card=hash_card,
amount=amount)
new_Staff = Staff(id_staff=new_Client.id_clients,
id_position=id_position)
db.session.add(new_Contactdetailsclients)
db.session.add(new_Secretdate)
db.session.add(new_Card)
db.session.add(new_Staff)
db.session.commit()
return redirect('/login')
def create_deck():
"""
Create a list of playing cards in our database
"""
suits = [0, 1, 2, 3]
ranks = [
'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten',
'jack', 'queen', 'king', 'ace'
]
cards = [Card(suit=suit, rank=rank) for rank in ranks for suit in suits]
Card.objects.bulk_create(cards)
def register_card(self, card):
"""Find the first user from the database with valid card registration"""
db_session = self.get_database_session()
users = db_session.query(User).filter(
User.card_registration_expiry >= 'NOW()').all()
if users:
card = Card(card, users[0].id)
self._logger.debug("Card created: %s", card)
db_session.add(card)
users[0].card_registration_expiry = None
db_session.commit()
send_card_registered()
def addCardView(request):
user = request.user
if user.profile.corporate is False:
# is user adding a card?
if request.method == 'POST':
form = AddCardForm(request.POST)
if form.is_valid():
card = Card(user=user,
number=form.cleaned_data.get('number'),
csv=form.cleaned_data.get('csv'),
exp_date=form.cleaned_data.get('exp_date'),
name=form.cleaned_data.get('name'),
address=form.cleaned_data.get('address'),
phone=form.cleaned_data.get('phone'),
c_currency=form.cleaned_data.get('c_currency'))
if (card.number[0] == '4'):
card.provider = 'Visa'
elif (card.number[0] == '5'):
card.provider = 'MasterCard'
elif (card.number[0] == '3'):
card.provider = 'American Express'
else:
card.provider = 'Unknown'
card.save()
return redirect('/cards/')
# display existing cards
else:
# if user is changing default card
if (request.GET.get('card', '')):
default_new = request.GET.get('card', '')
user.profile.default_payment = int(default_new)
user.save()
form = AddCardForm()
# get a lsit of all existing cards
cards = Card.objects.filter(user=user)
# hide all but the last 4 digits
for available_card in cards:
available_card.number = available_card.number[-4:]
# if user is removing a card
if (request.GET.get('rm', '')):
rm = request.GET.get('rm', '')
if (Card.objects.filter(pk=int(rm), user=user).exists()):
Card.objects.get(pk=int(rm)).delete()
cards = Card.objects.filter(user=user)
notifications = Notification.objects.filter(user=user)
context_dict = {
'notifications': notifications,
'form': form,
'cards': cards
}
return render(request, 'users/profile/cards.html', context_dict)
else:
return redirect('/')
def test_has_pairs(self):
deck = Deck(custom_ranks={
"2": 2,
"3": 3,
"4": 4,
"5": 5
},
custom_suits={"𓆏": "GREEN"})
deck.add_cards([Card(rank="3", rank_value=3, suit="𓆏", color="RED")])
self.assertTrue(deck.evaluator.has_pairs(1))
def test_cards_can_be_compared_before_a_suit_is_led(self) -> None:
players = [Player(), Player(), Player(), Player()]
deal = Deal(players=players, bidder_index=0)
trick = Trick(deal=deal, leading_player_index=0)
# The queen should be consider higher, as we are assuming we are not
# dealing with a trump suit, given that no trump suit was even specified yet.
self.assertEqual(
1,
trick.compare_cards(Card(suit=Suit.HEARTS, rank=Rank.JACK),
Card(suit=Suit.HEARTS, rank=Rank.QUEEN)))
# Unrelated cards cannot be compared properly without a trump suit or a led suit.
self.assertEqual(
0,
trick.compare_cards(
Card(suit=Suit.HEARTS, rank=Rank.JACK),
Card(suit=Suit.SPADES, rank=Rank.ACE),
))
deal.trump_suit = Suit.HEARTS
# Now that we have a trump suit defined, the higher trump should rank higher.
self.assertEqual(
-1,
trick.compare_cards(Card(suit=Suit.HEARTS, rank=Rank.JACK),
Card(suit=Suit.HEARTS, rank=Rank.QUEEN)))
def test_the_highest_card_in_a_trick_with_trumps(self) -> None:
players = [Player(), Player(), Player(), Player()]
deal = Deal(players=players, bidder_index=0, trump_suit=Suit.DIAMONDS)
trick = Trick(deal=deal, leading_player_index=0)
players[0].hand = {Card(suit=Suit.SPADES, rank=Rank.JACK)}
players[1].hand = {Card(suit=Suit.SPADES, rank=Rank.TEN)}
players[2].hand = {Card(suit=Suit.SPADES, rank=Rank.KING)}
players[3].hand = {Card(suit=Suit.DIAMONDS, rank=Rank.SEVEN)}
trick.play(Card(suit=Suit.SPADES, rank=Rank.JACK))
trick.play(Card(suit=Suit.SPADES, rank=Rank.TEN))
trick.play(Card(suit=Suit.SPADES, rank=Rank.KING))
trick.play(Card(suit=Suit.DIAMONDS, rank=Rank.SEVEN))
# Player 4 played a seven, but because it is a trump card, he will win.
self.assertEqual(3, trick.winning_card_index)
self.assertEqual(Card(suit=Suit.DIAMONDS, rank=Rank.SEVEN),
trick.winning_card)
def test_the_highest_card_in_a_trick_without_trumps(self) -> None:
players = [Player(), Player(), Player(), Player()]
deal = Deal(players=players, bidder_index=0, trump_suit=Suit.HEARTS)
trick = Trick(deal=deal, leading_player_index=0)
players[0].hand = {Card(suit=Suit.SPADES, rank=Rank.JACK)}
players[1].hand = {Card(suit=Suit.SPADES, rank=Rank.TEN)}
players[2].hand = {Card(suit=Suit.SPADES, rank=Rank.KING)}
players[3].hand = {Card(suit=Suit.DIAMONDS, rank=Rank.ACE)}
trick.play(Card(suit=Suit.SPADES, rank=Rank.JACK))
trick.play(Card(suit=Suit.SPADES, rank=Rank.TEN))
trick.play(Card(suit=Suit.SPADES, rank=Rank.KING))
trick.play(Card(suit=Suit.DIAMONDS, rank=Rank.ACE))
# Player 4 played an ace, but it is in the wrong suit.
# Player 1 played a jack, but it is not the trump suit, so the 10 wins.
self.assertEqual(1, trick.winning_card_index)
self.assertEqual(Card(suit=Suit.SPADES, rank=Rank.TEN),
trick.winning_card)
def test_has_three_pairs(self):
deck = Deck(custom_cards=[
Card(rank="3", rank_value=3, suit="𓆏", color="RED"),
Card(rank="5", rank_value=5, suit="𓃰", color="BLACK"),
Card(rank="3", rank_value=3, suit="𓆏", color="RED"),
Card(rank="4", rank_value=4, suit="𓆏", color="RED"),
Card(rank="4", rank_value=4, suit="𓃰", color="BLACK"),
Card(rank="5", rank_value=5, suit="𓃰", color="BLACK"),
Card(rank="6", rank_value=6, suit="𓃰", color="BLACK")
])
self.assertTrue(deck.evaluator.has_n_pairs(3))
def post(self):
user = users.get_current_user()
user_id = user.user_id()
current_user = Profile.query().filter(Profile.user_id == user_id).get()
the_question = self.request.get('question')
the_answer = self.request.get('answer')
difficulty = int(self.request.get('difficulty_selection'))
card = Card(question=the_question,
answer=the_answer,
level=difficulty,
owner=user.user_id())
card.put()
self.redirect('/create')
def find_info(entry):
soup = BeautifulSoup(entry.description, "html.parser")
secondtd = soup.findAll("td")[1]
card = create_card(secondtd.strings)
card_obj = session.query(Card).filter(
Card.title == card["title"]).one_or_none()
if card_obj is None:
card_obj = Card(title=card["title"])
record = Record(qty=card["qty"], price=card["price"])
card_obj.records.append(record)
print(f"{card_obj}")
for record in card_obj.records:
print(f"{record}")
return card_obj
def get_card_list(card_list):
"""
"""
req_url = '{0}/{1}/{2}'.format(MTG_DB_URL, CARDS_PATH,
','.join(str(id) for id in card_list))
results = _process_simple_request(
req_url,
error_msg='There was a problem building the \
card list. Ensure the list contains \
only valid card ids.')
cards = []
for card_data in results:
cards.append(Card(card_data))
return cards
def createcard():
form = CardCreateForm()
if current_user.is_authenticated:
if form.validate_on_submit():
newcard = Card(owner=current_user,
title=form.title.data,
year=form.year.data,
authors=form.authors.data)
db.session.add(newcard)
db.session.commit()
flash('card successfully created!')
return redirect(url_for('createcard'))
else:
flash('Sorry, you have to make an account first.')
return render_template("createcard.html", form=form)
def load_data_as_xml(data_dump_as_xml):
tree = etree.parse(data_dump_as_xml)
docinfo = tree.docinfo
if docinfo.encoding != "UTF-8":
raise XMLDataDumpException("Not supported encoding: %s" %
docinfo.encoding)
root = tree.getroot()
if root.tag != "data":
raise XMLDataDumpException("%s: %s != 'data'" %
(root.sourceline, root.tag))
for shelf_xml in root:
if shelf_xml.tag != "shelf":
raise XMLDataDumpException("%s: %s != 'shelf'" %
(shelf_xml.sourceline, shelf_xml.tag))
shelf = Shelf()
shelf.name = shelf_xml.get("name")
try:
shelf.save()
except IntegrityError as e:
raise XMLDataDumpException("%s: cannot add shelf: %s" %
(shelf_xml.sourceline, str(e)))
for deck_data in shelf_xml:
if deck_data.tag != "deck":
raise XMLDataDumpException(
"%s: %s != 'deck'" % (deck_data.sourceline, deck_data.tag))
deck = Deck()
deck.shelf = shelf
deck.name = deck_data.get("name")
deck.save()
for card_data in deck_data:
if card_data.tag != "card":
raise XMLDataDumpException(
"%s: %s != 'card'" %
(card_data.sourceline, card_data.tag))
if card_data[0].tag != "question":
raise XMLDataDumpException(
"%s: %s != 'question'" %
(card_data[0].sourceline, card_data[0].tag))
if card_data[1].tag != "answer":
raise XMLDataDumpException(
"%s: s%s != 'answer'" %
(card_data[1].sourceline, card_data[1].tag))
card = Card()
card.deck = deck
card.question = card_data[0].text
card.answer = card_data[1].text
card.save()
def test_flush_over_flush():
cards_by_player_index = {
0: [Card(Rank.King, Suit.Hearts),
Card(Rank.Eight, Suit.Hearts)],
1: [Card(Rank.Ace, Suit.Hearts),
Card(Rank.Seven, Suit.Hearts)]
}
board = [
Card(Rank.Two, Suit.Hearts),
Card(Rank.Three, Suit.Hearts),
Card(Rank.Four, Suit.Hearts),
Card(Rank.Six, Suit.Hearts),
Card(Rank.Nine, Suit.Hearts)
]
winning_player_index, winning_hand = poker.determine_winner(
cards_by_player_index, board)
assert winning_player_index == 1
assert type(winning_hand) == models.Flush
assert winning_hand.suit == Suit.Hearts
def test_doesnt_have_flush(self):
deck = Deck(custom_cards=[
Card(rank="3", rank_value=3, suit="𓆏", color="RED"),
Card(rank="3", rank_value=3, suit="𓆏", color="RED"),
Card(rank="3", rank_value=3, suit="𓆏", color="RED"),
Card(rank="4", rank_value=4, suit="𓃰", color="BLACK"),
Card(rank="K", rank_value=13, suit="𓃰", color="BLACK"),
Card(rank="Q", rank_value=12, suit="𓃰", color="BLACK")
])
self.assertTrue(deck.evaluator.has_flush(4) is False)
def card_form():
form = CardForm()
if request.method == 'POST' and form.validate:
# print(form, form.title.data)
title = request.form['title']
short_description = request.form['short_description']
description = request.form['description']
price = request.form['price']
card_service = request.form['card_service']
image_path = save_file(form.card_image.data)
card = Card(title, short_description, description, price, card_service,
image_path)
card.save()
# cards = Card.query.all()
return render_template('card_form.html', form=form)
def test_invalid_hand_too_many_cards(self):
cards = [
Card('6', 'S'),
Card('6', 'H'),
Card('6', 'D'),
Card('K', 'C'),
Card('K', 'H'),
Card('A', 'S')
]
with self.assertRaises(InvalidPokerHand):
PokerHand(cards)
def test_only_higher_trump_cards_are_legal_if_led_suit_is_unavailable_and_trumps_were_already_played(
self) -> None:
players = [Player(), Player(), Player(), Player()]
players[0].hand = {Card(suit=Suit.DIAMONDS, rank=Rank.KING)}
players[1].hand = {Card(suit=Suit.HEARTS, rank=Rank.KING)}
players[2].hand = {
Card(suit=Suit.HEARTS, rank=Rank.QUEEN),
Card(suit=Suit.HEARTS, rank=Rank.ACE),
Card(suit=Suit.CLUBS, rank=Rank.ACE),
}
deal = Deal(players=players, bidder_index=0, trump_suit=Suit.HEARTS)
trick = Trick(deal=deal, leading_player_index=0)
trick.play(Card(suit=Suit.DIAMONDS, rank=Rank.KING))
trick.play(Card(suit=Suit.HEARTS, rank=Rank.KING))
self.assertEqual({
Card(suit=Suit.HEARTS, rank=Rank.ACE),
}, trick.legal_cards)
def genSKILL(divs):
cards = []
card_type = u'技能'
for div in divs:
a = div.find('div', 'card-image').find('a')
img = a.find('img')
card_img = img['src']
attrdiv = div.find('div', 'card-attribute')
card_name = attrdiv.find('h2').find('a').text
card_desc = None
card_remark = None
if attrdiv.findAll('p') is not None:
p = attrdiv.findAll('p')
for pi in p:
if pi.has_key('class'):
card_remark = pi.text
else:
card_desc = pi.text
lis = attrdiv.find('ul').findAll('li')
card_class = None
card_race = None
card_rarity = None
card_set = None
for li in lis:
a = li.find('a')
if a is not None:
if a['href'].find('Class') != -1:
card_class = a.span.text
elif a['href'].find('Race') != -1:
card_race = a.text
elif a['href'].find('Rarity') != -1:
card_rarity = a.span.text
elif a['href'].find('CardSet') != -1:
card_set = a.text
card = Card(card_name=card_name,
card_type=card_type,
card_img=card_img,
card_class=card_class,
card_rarity=card_rarity,
card_set=card_set,
card_desc=card_desc,
card_remark=card_remark)
cards.append(card)
return cards
