def accept_bid(self, bid):
# if hand concluded throw error
# if bidding concluded throw error
# if it's not the player's turn throw error
# if the bid isn't allowed throw error
# bid greater than previous
# if misere, required threshold of past bids is met
if not self.next_player() == bid.player_id:
raise OutOfTurnError
# make sure new bid is higher than the last one
if not bid > self.last_normal_bid():
raise ValueError('New Bid must be higher than previous bid')
# if the bid is misere, make sure that a 7 bid has been made
if bid == Bid('MISERE') and not self.last_normal_bid() >= Bid(
'SEVEN', 'SPADES'):
raise ValueError(
'Misere cannot be bid until a 7 Bid has been made')
# the bid is valid
self.bids.append(bid)
# if this was the last bid, start the first trick
if self.bidding_is_concluded():
self.tricks.append(Trick(self.winning_bid().player_id))
def destroy(product_id):
product = Product.get_or_none(Product.id == product_id)
owner = User.get_or_none(User.id == product.user_id)
subq = Bid.select(fn.MAX(
Bid.bid_amount)).where(Bid.product_id == product_id)
query = Bid.select(Bid.bidder_id).where(Bid.bid_amount == subq)
bidder = User.get_or_none(User.id == query.scalar())
check_bid = Bid.select(fn.MAX(
Bid.bid_amount)).where(Bid.product_id == product_id)
highest_bid = check_bid.scalar()
update = Product.update(bid_end=True).where(Product.id == product_id)
update.execute()
server = smtplib.SMTP('smtp.gmail.com', 587)
server.ehlo()
server.starttls()
server.ehlo()
server.login(os.getenv("MAIL"), os.getenv("PASS"))
subject = f"Sold!"
body = f"{owner.username} has ended the bid for {product.title} at ${highest_bid}.\nHighest bid by {bidder.username}(You).\nContact the owner via {owner.email} to discuss further :)\nSign in to view the product at http://127.0.0.1:5000/bid/{product_id}?"
msg = f"Subject: {subject}\n\n{body}"
server.sendmail(os.getenv("MAIL"), bidder.email, msg)
flash("Email has been sent to bidder!", "success")
print("Email has been sent!")
server.quit()
return redirect(url_for("bid.new", product_id=product_id, product=product))
def create(product_id):
product = Product.get_or_none(Product.id == product_id)
bid = request.form.get("bid_num")
if bid == "":
flash("Please enter a bidding amount!", "warning")
return redirect(
url_for("bid.new", product_id=product_id, product=product))
else:
bid_num = int(bid)
owner = User.get_or_none(User.id == product.user_id)
bidder = User.get_or_none(User.id == current_user.id)
check_bid = Bid.select(fn.MAX(
Bid.bid_amount)).where(Bid.product_id == product_id)
highest_bid = check_bid.scalar()
if highest_bid is None or bid_num > highest_bid:
Bid.create(owner=owner.id,
owner_username=owner.username,
bidder=bidder.id,
bidder_username=bidder.username,
product_title=product.title,
product_pic=product.image_path,
bid_amount=bid_num,
product_id=product.id)
flash("Bid successful!", "success")
return redirect(
url_for("bid.new", product_id=product_id, product=product))
else:
flash("Must bid higher than the current highest bid!", "warning")
return redirect(
url_for("bid.new", product_id=product_id, product=product))
def icnet(self, max_iterations, gauss_stdev):
"""ICNET"""
# init broker
self.broker.set_initial_bid(self.estimated_transport_cost)
# establish transporters
self.set_transporters_initial_bids(gauss_stdev,
self.transporters_icnet)
nr_transporters_per_bid = random.randrange(1, self.nr_transporters)
transporters = []
for iterator in range(nr_transporters_per_bid):
transporters.append(random.choice(self.transporters_icnet))
bid_transporters = set(transporters)
# establish cargo owner
bid_cargo_owner = random.choice(self.cargo_owners)
bid_data = Bid(bid_cargo_owner.id, self.estimated_transport_cost)
# establishing the winner
negotiation_success, list_of_accepting_transporters, nr_iterations = self.negociation(
bid_transporters, max_iterations)
if negotiation_success == True:
winning_transporter, winner_price = self.determine_winning_transporter_icnet(
list_of_accepting_transporters)
winner_personality = winning_transporter.personality.get_personality(
)
bid_data.accepted(winning_transporter.id, winner_personality,
winner_price, nr_iterations)
self.stats.bids_icnet.append(bid_data)
self.personality_updates(bid_transporters, winning_transporter)
def winning_bid(self):
# if bidding not concluded throw error
# return last non-pass item of self.bids
if self.bids.count(Bid('PASS')) == 4:
return None
return [bid for bid in self.bids if bid != Bid('PASS')][-1]
def trick_is_concluded(self, trick_index):
# check length of trick at index
# if winning bid is open misere, concluded = len == 3
# else, concluded = len == 4
return len(
self.tricks[trick_index].cards) == (3 if self.winning_bid() in {
Bid('MISERE'), Bid('OPEN_MISERE')
} else 4)
def main():
test_round = Round()
print(test_round.nextPlayer())
test_round.addBid(Bid('1H'))
print(test_round.nextPlayer())
test_round.addBid(Bid('2S'))
print(test_round.nextPlayer())
test_round.addBid(Bid('3H'))
try:
test_round.addBid(Bid('3C'))
raise Exception
except ValueError as e:
print e
print(test_round.nextPlayer())
test_round.addBid(Bid('4H'))
print(test_round.nextPlayer())
test_round.addBid(Bid('5N'))
print(test_round.nextPlayer())
try:
test_round.addBid(Bid('1H'))
raise Exception
except ValueError as e:
print e
try:
test_round.addBid(Bid('5C'))
raise Exception
except ValueError as e:
print e
try:
test_round.addBid(Bid('5N'))
raise Exception
except ValueError as e:
print e
print(test_round)
def check(hand):
if hand.in_zone() and hand.hcp >= 10:
if hand.sut_length(1) == 6 and hand.sut_qual(1) >= 6:
return Bid(1, 1)
return None
elif not hand.in_zone() and hand.hcp >= 8:
if hand.sut_length(1) == 6:
return Bid.parse('2d')
else:
return None
else:
return None
def trick_winner(self, trick_index):
if len(self.tricks) - 1 > trick_index:
raise ValueError(f'Trick {trick_index} does not exist')
if not self.trick_is_concluded(trick_index):
raise ValueError(f'Trick {trick_index} is not concluded')
trick = self.tricks[trick_index]
def highest_trump(trump, cards):
if Card('JOKER') in cards:
return Card('JOKER')
# if the Joker was played, then the function has already returned, so we can safely access card.suit
trumps = [card for card in cards if card.suit == trump]
if not trumps:
return None
return max(trumps, key=lambda card: card.rank)
def highest_non_trump(trump, cards):
non_trumps = [
card for card in cards
if not card.is_joker() and not card.suit == trump
]
return max(non_trumps, key=lambda card: card.rank)
bid = self.winning_bid()
if bid in {Bid('MISERE'), Bid('OPEN_MISERE')
} or bid.suit == 'NO_TRUMPS':
trump = None
else:
trump = bid.suit
# time to figure out who won this thing
winning_card = highest_trump(trump, trick.cards) or highest_non_trump(
trump, trick.cards)
winning_index = trick.cards.index(winning_card)
# the winning player will be the player who is winning_index places to the left of the trick leader
# this means that the winning player will be (number of places between the bid winner and the trick leader + winning_index) to the left of the bid winner
if trick_index == 0:
trick_leader = self.winning_bid().player_id
else:
trick_leader = self.trick_winner(trick_index - 1)
trick_leader_index = self.hands.keys().index(trick_leader)
winning_player = self.hands.keys()[(trick_leader_index + winning_index)
% len(self.hands.keys())]
return winning_player
def bidding_is_concluded(self):
# TODO: remove these notes when everthing is a-ok good to go
# yes conditions:
# 4 passes
# normal bid + 3 passes
# hit bidding ceiling (10 no trumps)
enough_passes = len(
self.bids) == 4 and self.bids.count(Bid('PASS')) >= 3
bid_ceiling = len(self.bids) > 0 and self.bids[-1] == Bid(
'10', 'NO_TRUMPS')
return enough_passes or bid_ceiling
def scrape_bid_page(self, bid_id):
"""Scrapes the Commbuys bid detail page for the given bid id.
Relies on the position of information inside the main results table,
since the HTML contains no semantically-meaninful ids or classes.
Raises ValueError if it encounters unrecoverable parsing errors.
"""
page = self.scraper.get(self.details_url, params={'bidId': bid_id})
tree = html.fromstring(page.content)
bid_id = self._get_next_sibling_text_for(tree, "Bid Number:")
description = self._get_next_sibling_text_for(tree, "Description:")
department = self._get_next_sibling_text_for(tree, "Department:")
organization = self._get_next_sibling_text_for(tree, "Organization:")
location = self._get_next_sibling_text_for(tree, "Location:")
open_date_str = self._get_next_sibling_text_for(
tree, "Bid Opening Date:")
open_date = None
try:
open_date = datetime.strptime(open_date_str,
'%m/%d/%Y %I:%M:%S %p')
except ValueError:
log.warning("Could not parse {} into date".format(open_date_str))
# Discard empty strings from 'items'
items = list(filter(None, self._get_siblings_text_for(tree, "Item #")))
return Bid(identifier=bid_id,
description=description,
department=department,
organization=organization,
location=location,
open_date=open_date,
items=items,
site=self.get_site().name)
def card_can_be_played(self, player_id, card):
current_trick = self.tricks[-1]
if self.next_player() != player_id:
return False
if len(current_trick.cards
) == 0: # player is leading, so anything can be played
return True
else: # player is not leading, so we have to check if they're following suit (and at least one edge case rule)
led_suit = current_trick.cards[0].suit
player_can_follow_suit = len([
card for card in self.hands[player_id] if card.suit == led_suit
]) > 0
# if other team won bidding with misere/open misere, and the player can't follow suit, and the player has the Joker, they must play it
if self.winning_bid() in {
Bid('MISERE'), BID('OPEN_MISERE')
} and not self.are_teammates(
self.winning_bid().player_id,
player_id) and not player_can_follow_suit and Card(
'JOKER'
) in self.hands[player_id] and not card == Card('JOKER'):
return False
# make sure the player follows suit if they can
return card.suit == led_suit or not player_can_follow_suit
def check(hand):
if not hand.has_maj5():
return None
if hand.hcp < 10 or hand.hcp > 21:
return None
if hand.length() + hand.length(1) + hand.hcp < 20:
return None
return Bid(0, hand.best_major())
def hand_is_concluded(self):
# yes conditions:
# 4 passes
# 10 tricks complete
# misere/open misere bidder wins a trick
if not self.bidding_is_concluded(
): # this check allows safe usage of self.winning_bid
return False
four_passes = self.bids.count(Bid('PASS')) == 4
ten_tricks_complete = len(self.tricks) == 10
misere_won_trick = self.winning_bid() in {
Bid('MISERE'), BID('OPEN_MISERE')
}
return four_passes or ten_tricks_complete or misere_won_trick
def eval_move(self, move, challenge_possible=True, reveal_possible=True):
parts = move.split(' ')
if parts[0] == 'BID':
try:
bid = Bid(int(parts[1]), int(parts[2]))
assert 1 <= bid.value <= 6
assert bid > self.bid
assert bid.count <= self.n_dice + 1
except:
self.invalid_move(move)
return
self.bid = bid
self.inform_others('PLAYER_BIDS ' + str(self.cp().id) + ' ' +
str(bid))
elif parts[0] == 'REVEAL':
try:
assert reveal_possible
assert len(parts) > 1
dice = (int(x) for x in parts[1:])
for die in dice:
self.cp().hidden_dice.remove(die)
self.cp().revealed_dice.append(die)
except:
self.invalid_move(move)
return
self.inform_others('PLAYER_REVEALS ' + str(self.cp().id) + ' ' +
' '.join(parts[1:]))
self.cp().roll()
self.eval_move(self.cp().play(), False, False)
elif parts[0] == 'CHALLENGE':
self.finished_round = True
if not challenge_possible:
self.invalid_move(move)
return
self.inform_others('PLAYER_CHALLENGES ' + str(self.cp().id))
for i in range(self.n_players):
self.inform_others('PLAYER_HAD ' + str(self.cp().id) + ' ' +
' '.join(
str(x) for x in self.cp().hidden_dice))
self.shift_cpi()
all_dice = []
for p in self.players:
all_dice.extend(p.revealed_dice)
all_dice.extend(p.hidden_dice)
diff = self.bid.count - sum(
[1 for die in all_dice if die == self.bid.value or die == 1])
if diff < 0:
self.cp().n_dice += diff
elif diff > 0:
self.players[self.ppi].n_dice -= diff
self.cpi = self.ppi
else:
self.cp().n_dice -= 1
self.players[self.ppi].n_dice += 1
self.check_if_loses()
else:
self.invalid_move(move)
def addNewBid(self, clientId, bidValue, receipt):
previous_hash = -1
if len(self.__list_of_bids) > 0:
previous_hash = self.__list_of_bids[-1].previous_hash
bid = Bid(int(clientId), self.serialNumber, bidValue,
len(self.__list_of_bids), time.time(), previous_hash,
receipt)
self.__list_of_bids.append(bid)
def check(hand):
if hand.in_zone() and hand.hcp >= 10:
if hand.sut_length(3) == 6 and hand.sut_qual(3) >= 6:
return Bid(1, 3)
if hand.sut_length(2) == 6 and hand.sut_qual(2) >= 6:
return Bid(1, 2)
return None
elif not hand.in_zone():
if hand.hcp > 10:
if hand.sut_length(3) == 6:
return Bid(1, 3)
elif hand.sut_length(2) == 6:
return Bid(1, 2)
else:
return None
elif hand.hcp > 8:
if hand.sut_length(3) == 6 and hand.sut_qual(3) >= 6:
return Bid(1, 3)
if hand.sut_length(2) == 6 and hand.sut_qual(2) >= 6:
return Bid(1, 2)
return None
else:
return None
else:
return None
def registerBid(self, bidInputed):
print("bid recebido: " + str(bidInputed))
bid = Bid(bidInputed['stockName'], bidInputed['negotiatedPrice'],
bidInputed['quantity'], bidInputed['clientId'],
bidInputed['type'], BidStatus.PENDING)
if bid is None:
print("registerBid: Lance inválido recebido")
return False
presentBid = None
theList = None
if bid.type == BidType.BUY:
theList = self.listOfBuyers
elif bid.type == BidType.SELL:
theList = self.listOfSellers
else:
print("registerBid: Lance tem tipo inválido: " + str(bid.type))
return False
for b in theList:
if b.stockName == bid.stockName:
presentBid = b
presentBid.quantity = bid.quantity
presentBid.negotiatedPrice = bid.negotiatedPrice
presentBid.status = bid.status
presentBid.type = bid.type
self.computeBids()
print("registerBid: Lance já existe. Foi atualizado")
return True
if presentBid is None:
presentBid = Bid(bid.stockName, bid.negotiatedPrice, bid.quantity,
bid.clientId, bid.type, bid.status)
theList.append(presentBid)
print("Adicionando lance na lista " + str(theList))
self.computeBids()
print("registerBid: Novo lance registrado com sucesso")
return True
def query_all_live_auctions(self, involved_only=False):
def filter_func(auc_record):
return auc_record.get("status") == const.AUCTION_STATUS_IN_PROGRESS
auctions = Auction.all(filter_func)
if involved_only:
bids = Bid.all(lambda x: x["participant_id"] == self.id)
involved_auction_ids = set([b.auction_id for b in bids])
auctions = [a for a in auctions if a.id in involved_auction_ids]
return auctions
def play_round(self):
self.finished_round = False
self.bid = Bid(0, 6)
for i, p in enumerate(self.players):
p.write('NEW_ROUND ' +
' '.join(str(p.n_dice) for p in self.players_sorted))
p.revealed_dice = []
p.roll()
self.n_dice = sum(p.n_dice for p in self.players)
self.eval_move(self.cp().play(), challenge_possible=False)
while not self.finished and not self.finished_round:
self.shift_cpi()
self.eval_move(self.cp().play())
async def play_round(self):
self.finished_round = False
self.bid = Bid(0, 6)
for i, p in enumerate(self.players):
p.revealed_dice = []
p.roll()
p.bid = None
self.n_dice = sum(p.n_dice for p in self.players)
await self.broadcast_state()
await self.eval_move(await self.cp().play(), challenge_possible=False)
while not self.finished and not self.finished_round:
self.shift_cpi()
await self.broadcast_state()
await self.eval_move(await self.cp().play())
def get_random(self, minut=0, maxut=1):
print('Limits', minut, maxut)
lower = np.ma.masked_less_equal(self.utility_space[:, -1], maxut).mask
upper = np.ma.masked_greater_equal(self.utility_space[:, -1],
minut).mask
#(all_mask = [i for i, x in enumerate(range(len(lower))) if (lower[i] and upper[i])]
mask = (lower == True) & (upper == True)
valids = np.where(mask == True)[0]
print('valids.size', valids.size)
if valids.size == 0:
return None
index = random.choice(np.arange(valids.size))
return Bid(self.utility_space[valids[index]], self.discount,
valids[index])
def __init__(self):
dirname = os.path.dirname(__file__)
# Script configuration
os.environ['FABRIC_URL'] = 'http://localhost:3000/'
os.environ['STORAGE_DIR'] = os.path.join(dirname, 'tmp')
os.environ['USER_LIST'] = os.path.join(dirname, 'data/user.csv')
os.environ['USER_STORAGE'] = os.path.join(os.getenv('STORAGE_DIR'),
'user.csv')
os.environ['HOLIDAY_CALENDAR'] = os.path.join(
dirname, 'data/thHoliday2563-64.csv')
# Import Grouped command
self.user = User()
self.fabric = Fabric()
self.service = Service()
self.bid = Bid()
self.etl = ETL()
def scrape_bid_page(self, bid_id):
"""Scrapes the City of Boston bid detail page for the given bid_id.
Relies on the position of information inside the main results table,
since the HTML contains no semantically-meaninful ids or classes.
Raises ValueError if it encounters parsing errors.
"""
page = self.scraper.get(self.details_url, params={'ID': bid_id})
tree = html.fromstring(page.content)
first_center = tree.xpath('//center')[0]
start_text_element = first_center.xpath('b')[0]
description = start_text_element.text.strip()
items = ["".join(first_center.xpath('text()'))]
return Bid(identifier=bid_id,
description=description,
items=items,
site=self.get_site().name)
def next_player(self):
if self.hand_is_concluded():
return None
player_circle = [player_id for player_id in self.hands.keys()]
if not self.bidding_is_concluded():
# working this out is more complicated and more manual than I'd like;
# there might be a better formulaic method that I didn't come up with
player_pointer = 0
for bid in self.bids:
if bid == Bid('PASS'):
# remove the player who passed from player_circle
del player_circle[player_pointer]
# if the player_pointer was pointing to the end of the list, it should now point to the beginning
if player_pointer == len(player_circle):
player_pointer = 0
else:
# move the player_pointer around the circle 1 space
player_pointer = (player_pointer + i) % len(player_circle)
return player_circle[player_pointer]
else:
current_trick = self.tricks[-1]
# next player is at (index of trick leader + number of cards played in current trick) % player count
trick_leader_index = player_circle.index(
self.tricks[-2].trick_winner()) if len(self.tricks) > 1 else 0
cards_played_this_trick = len(current_trick.cards)
return player_circle[len(current_trick.cards) % len(player_circle)]
def get_by_index(self, index):
return Bid(self.utility_space[index], self.discount, index)
def filter_data(self, data, customer_bids=False):
if (self.printing_mode == True):
print("Filter data...")
# Error checking variables
lens = [] # List of bid_array lengths discovered in the dataset
buy_count = 0 # Number of buy bid_arrays
sell_count = 0 # Number of sell bid_arrays
junk = 0 # Number of bid_arrays not appended to the lists of bids
for xx, bid_array in enumerate(data):
# If the timestamps were splitted, indices must be changed
# To do: Is this done correctly?
if (len(bid_array) <= 1):
# Some datasets have internal break-lines
if (xx <= len(data) - 3):
continue
# Handling unexpected line at the end of some dataests
else:
print("breaking at ", xx, bid_array)
break
elif (len(bid_array) == 3):
continue
# Vstrip
if (bid_array[-1] == "\n"):
bid_array = bid_array[:-1]
# Error checking
if (self.printing_mode == True and len(bid_array) not in lens):
lens.append(len(bid_array))
print(xx, len(bid_array), bid_array)
# Setup indices based on bid array length
if (len(bid_array) == 30):
# Indices
self.index_of_timestamp = 10
self.index_of_timestamp2 = 13
self.index_of_isBuy = 9
self.index_of_price = 15
self.index_of_volume = 16
self.index_of_order_id = 17
self.index_of_delivery_product = 23
self.index_of_zone = 3
elif (len(bid_array) == 31):
# Indices
self.index_of_timestamp = 8
self.index_of_timestamp2 = 11
self.index_of_isBuy = 13
self.index_of_price = 16
self.index_of_volume = 17
self.index_of_order_id = 18
self.index_of_delivery_product = 24
self.index_of_zone = 3
elif (len(bid_array) == 22):
# Indices
self.index_of_timestamp = 8
self.index_of_timestamp2 = 10
self.index_of_isBuy = 9
self.index_of_price = 11
self.index_of_volume = 12
self.index_of_order_id = 13
self.index_of_delivery_product = 18
self.index_of_zone = 3
elif (len(bid_array) == 28):
# Indices
self.index_of_timestamp = 8
self.index_of_timestamp2 = 11
self.index_of_isBuy = 10
self.index_of_price = 13
self.index_of_volume = 14
self.index_of_order_id = 15
self.index_of_delivery_product = 21
self.index_of_zone = 3
elif (len(bid_array) == 29):
# Indices
self.index_of_timestamp = 6
self.index_of_timestamp2 = 9
self.index_of_isBuy = 11
self.index_of_price = 14
self.index_of_volume = 15
self.index_of_order_id = 16
self.index_of_delivery_product = 22
self.index_of_zone = 3
# Error checking
if (bid_array[self.index_of_isBuy] not in ["0", "1"]):
raise ValueError("Not legal bid is buy",
bid_array[self.index_of_isBuy], bid_array,
"length:", len(bid_array))
# Check the length of bid array
if (len(bid_array) not in [22, 28, 29, 30, 31]):
raise ValueError(
"NBNB: Bid array does not have a supported length.")
# Setting the bid features
bid_array_timestamp = bid_array[
self.index_of_timestamp] + " " + bid_array[
self.index_of_timestamp + 1]
bid_array_timestamp2 = bid_array[
self.index_of_timestamp2] + " " + bid_array[
self.index_of_timestamp2 + 1]
bid_array_is_buy = bid_array[self.index_of_isBuy]
bid_array_price = float(bid_array[self.index_of_price]) / 100.0
bid_array_volume = float(bid_array[self.index_of_volume]) / 1000.0
bid_array_order_id = bid_array[self.index_of_order_id]
bid_array_zone = bid_array[self.index_of_zone]
# Based on the bid features, add the bid_array to one of the bid lists
if (bid_array_zone not in [
"10YFR-RTE------C", "10YAT-APG------L", "10YCH-SWISSGRIDZ",
"10YBE----------2", "10YNL----------L"
]):
# Identify and set the bid array delivery product
if (len(bid_array[self.index_of_delivery_product]) == 27):
bid_array_dp = bid_array[self.index_of_delivery_product]
elif (len(bid_array[self.index_of_delivery_product +
1]) == 27):
bid_array_dp = bid_array[self.index_of_delivery_product +
1]
elif (":" in bid_array[self.index_of_delivery_product + 1]):
bid_array_dp = bid_array[
self.index_of_delivery_product] + " " + bid_array[
self.index_of_delivery_product + 1]
elif (":" in bid_array[self.index_of_delivery_product]):
bid_array_dp = bid_array[
self.index_of_delivery_product -
1] + " " + bid_array[self.index_of_delivery_product]
else:
raise ValueError(
"Don't know where to find delivery product attribute")
# Identify and set the bid array timestamp
if (len(bid_array[self.index_of_timestamp]) == 27):
bid_array_dp = bid_array[self.index_of_timestamp]
elif (len(bid_array[self.index_of_timestamp + 1]) == 27):
bid_array_dp = bid_array[self.index_of_timestamp + 1]
elif (":" in bid_array[self.index_of_timestamp + 1]):
bid_array_timestamp = bid_array[
self.index_of_timestamp] + " " + bid_array[
self.index_of_timestamp + 1]
elif (":" in bid_array[self.index_of_timestamp]):
bid_array_timestamp = bid_array[
self.index_of_timestamp -
1] + " " + bid_array[self.index_of_timestamp]
print("Got B", len(bid_array_dp), bid_array_dp, bid_array)
elif (":" in bid_array[self.index_of_timestamp + 1]):
bid_array_timestamp = bid_array[
self.index_of_timestamp +
1] + " " + bid_array[self.index_of_timestamp + 2]
else:
raise ValueError(
"Don't know where to find timestamp attribute")
try:
bid_array_dp = dt.strptime(
bid_array_dp.split(".")[0], '%Y-%m-%d %H:%M:%S')
bid_array_timestamp = dt.strptime(
bid_array_timestamp.split(".")[0], '%Y-%m-%d %H:%M:%S')
except:
bid_array_dp = dt.strptime(
bid_array_dp.split(".")[0], '%m/%d/%Y %H:%M:%S')
bid_array_timestamp = dt.strptime(
bid_array_timestamp.split(".")[0], '%m/%d/%Y %H:%M:%S')
if (True or not (float(bid_array_price) > 19899.0
or float(bid_array_price) < -19899.0)):
#print(bid_array_is_buy, bid_array_is_buy == "0")
if (bid_array_is_buy == "1"):
buy_count += 1
# Price Volume Timestamp Timestamp2 isBuy Order ID Placed by Customer
self.bidsB.append(
Bid(float(bid_array_price),
float(bid_array_volume), bid_array_timestamp,
bid_array_timestamp2, bid_array_is_buy,
bid_array_order_id, customer_bids,
bid_array_zone))
elif (bid_array_is_buy == "0"):
sell_count += 1
self.bidsS.append(
Bid(float(bid_array_price),
float(bid_array_volume), bid_array_timestamp,
bid_array_timestamp2, bid_array_is_buy,
bid_array_order_id, customer_bids,
bid_array_zone))
else:
raise ValueError("Is buy: " + str(bid_array_is_buy) +
str(type(bid_array_is_buy)))
else:
junk += 1
if (self.printing_mode == True):
self.print_elapsed_time(self.start_time)
return self.bidsB, self.bidsS
def bid(self, auction, amount):
Bid(self, auction, amount)
def query_latest_summary_for_item(self, item_name):
item = Item.one(item_name)
if item is None:
return {
"status": "error",
"errors": ["Item does not exist."],
}
item_info = {
"name": item.name,
"reserved_price": item.reserved_price,
"status_code": item.status,
"status_name": const.ITEM_STATUS_NAMES[item.status],
"created_at": item.created_at,
"updated_at": item.updated_at,
}
auction = None
auction_info = None
if item.status > const.ITEM_STATUS_AVAILABLE:
# We will exclude any past failed auctions in summary because
# presumably that's not good for auction.
def filter_func(auc_record):
item_name_met = auc_record.get("item_name") == item_name
auc_status_met = auc_record.get("status") != const.AUCTION_STATUS_CALLED_FAIL
return item_name_met and auc_status_met
ret = Auction.all(filter_func)
if ret:
auction = ret[0]
auction_info = {
"id": auction.id,
"status_code": auction.status,
"status_name": const.AUCTION_STATUS_NAMES[auction.status],
"highest_bid_id": auction.highest_bid_id,
"winning_bid_id": auction.winning_bid_id,
"created_at": auction.created_at,
"started_at": auction.started_at,
"closed_at": auction.closed_at,
}
bid_id = None
if auction and auction.winning_bid_id:
bid_id = auction.winning_bid_id
elif auction and auction.highest_bid_id:
bid_id = auction.highest_bid_id
bid_info = None
if bid_id:
prevailing_bid = Bid.one(bid_id)
if prevailing_bid:
bid_info = {
"id": prevailing_bid.id,
"offer_price": prevailing_bid.offer_price,
"participant_id": prevailing_bid.participant_id,
"submitted_at": prevailing_bid.submitted_at,
}
return {
"status": "success",
"item": item_info,
"auction": auction_info,
"prevailing_bid": bid_info,
}
def filter_data(self, data, customer_bids=False):
if (self.printing_mode == True):
print("Filter data...")
for xx, bid_array in enumerate(data):
# If the timestamps were splitted, indices must be changed
# To do: Is this done correctly?
if (bid_array[-1] == "\n"):
bid_array = bid_array[:-1]
if (len(bid_array) == 30):
# Indices
self.index_of_timestamp = 10
self.index_of_timestamp2 = 13
self.index_of_isBuy = 9
self.index_of_price = 15
self.index_of_volume = 16
self.index_of_order_id = 17
self.index_of_delivery_product = 23
self.index_of_zone = 3
elif (len(bid_array) == 31):
# Indices
self.index_of_timestamp = 8
self.index_of_timestamp2 = 11
self.index_of_isBuy = 13
self.index_of_price = 16
self.index_of_volume = 17
self.index_of_order_id = 18
self.index_of_delivery_product = 24
self.index_of_zone = 3
if (bid_array[self.index_of_isBuy] not in ["0", "1"]):
raise ValueError("Not legal bid is buy")
# Check the length of bid array
if (len(bid_array) != 31 and len(bid_array) != 30):
print("NBNB: Bid array does not have a supported length.")
print(len(bid_array))
print(bid_array)
#print(xx, bid_array)
bid_array_timestamp = bid_array[
self.index_of_timestamp] + " " + bid_array[
self.index_of_timestamp + 1]
bid_array_timestamp2 = bid_array[
self.index_of_timestamp2] + " " + bid_array[
self.index_of_timestamp2 + 1]
bid_array_is_buy = bid_array[self.index_of_isBuy]
bid_array_price = float(bid_array[self.index_of_price]) / 100.0
bid_array_volume = float(bid_array[self.index_of_volume]) / 1000.0
bid_array_order_id = bid_array[self.index_of_order_id]
bid_array_zone = bid_array[self.index_of_zone]
if (bid_array_zone not in [
"10YFR-RTE------C", "10YAT-APG------L", "10YCH-SWISSGRIDZ",
"10YBE----------2", "10YNL----------L"
]):
if (":" in bid_array[self.index_of_delivery_product + 1]):
bid_array_dp = bid_array[
self.index_of_delivery_product] + " " + bid_array[
self.index_of_delivery_product + 1]
#print("Got A", len(bid_array_dp), bid_array_dp)
elif (":" in bid_array[self.index_of_delivery_product]):
bid_array_dp = bid_array[
self.index_of_delivery_product -
1] + " " + bid_array[self.index_of_delivery_product]
print("Got B", len(bid_array_dp), bid_array_dp)
else:
raise ValueError(
"Don't know where to find delivery product attribute")
if (":" in bid_array[self.index_of_timestamp + 1]):
bid_array_timestamp = bid_array[
self.index_of_timestamp] + " " + bid_array[
self.index_of_timestamp + 1]
#print("Got A", len(bid_array_dp), bid_array_dp)
elif (":" in bid_array[self.index_of_timestamp]):
bid_array_timestamp = bid_array[
self.index_of_timestamp -
1] + " " + bid_array[self.index_of_timestamp]
print("Got B", len(bid_array_dp), bid_array_dp)
elif (":" in bid_array[self.index_of_timestamp + 1]):
bid_array_timestamp = bid_array[
self.index_of_timestamp +
1] + " " + bid_array[self.index_of_timestamp + 2]
else:
print(bid_array)
raise ValueError(
"Don't know where to find timestamp attribute")
try:
bid_array_dp = dt.strptime(
bid_array_dp.split(".")[0], '%Y-%m-%d %H:%M:%S')
bid_array_timestamp = dt.strptime(
bid_array_timestamp.split(".")[0], '%Y-%m-%d %H:%M:%S')
except:
bid_array_dp = dt.strptime(
bid_array_dp.split(".")[0], '%m/%d/%Y %H:%M:%S')
bid_array_timestamp = dt.strptime(
bid_array_timestamp.split(".")[0], '%m/%d/%Y %H:%M:%S')
if (True or not (float(bid_array_price) > 19899.0
or float(bid_array_price) < -19899.0)):
if (bid_array_is_buy == "1"):
# Price Volume Timestamp Timestamp2 isBuy Order ID Placed by Customer
self.bidsB.append(
Bid(float(bid_array_price),
float(bid_array_volume), bid_array_timestamp,
bid_array_timestamp2, bid_array_is_buy,
bid_array_order_id, customer_bids,
bid_array_zone))
elif (bid_array_is_buy == "0"):
self.bidsS.append(
Bid(float(bid_array_price),
float(bid_array_volume), bid_array_timestamp,
bid_array_timestamp2, bid_array_is_buy,
bid_array_order_id, customer_bids,
bid_array_zone))
else:
raise ValueError("Is buy: " + str(bid_array_is_buy) +
str(type(bid_array_is_buy)))
if (False and self.printing_mode):
print("Number of buy bids: " + str(len(self.bidsB)))
print("Number of sell bids: " + str(len(self.bidsS)))
print("Total number of bids: " +
str(len(self.bidsS) + (len(self.bidsB))))
if (self.printing_mode == True):
self.print_elapsed_time(self.start_time)
return self.bidsB, self.bidsS
async def eval_move(self,
move,
challenge_possible=True,
reveal_possible=True):
parts = move.split(' ')
if parts[0] == 'BID':
try:
bid = Bid(int(parts[1]), int(parts[2]))
assert 1 <= bid.number <= 6
assert bid > self.bid
assert bid.quantity <= self.n_dice + 1
except:
await self.eval_move(await self.invalid_move(move),
challenge_possible, reveal_possible)
return
self.bid = bid
self.cp().bid = bid
await self.broadcast('PLAYER_BIDS')
await self.record('bids ' + str(bid.quantity) +
DICE_DICT[bid.number])
elif parts[0] == 'REVEAL':
try:
assert reveal_possible
assert len(parts) > 1
dice = [int(x) for x in parts[1:]]
hidden_dice = self.cp().hidden_dice.copy()
for die in dice:
hidden_dice.remove(die)
except:
await self.eval_move(await self.invalid_move(move),
challenge_possible, reveal_possible)
return
for die in dice:
self.cp().hidden_dice.remove(die)
self.cp().revealed_dice.append(die)
self.cp().roll()
await self.broadcast_state()
await self.broadcast('PLAYER_REVEALS')
await self.record('reveals ' + ' '.join(DICE_DICT[x]
for x in dice))
await self.eval_move(await self.cp().play(), False, False)
elif parts[0] == 'CHALLENGE':
if not challenge_possible:
await self.eval_move(await self.invalid_move(move),
challenge_possible, reveal_possible)
return
self.finished_round = True
await self.broadcast_state()
dice_table = '<br><pre>'
for i in range(self.n_players):
dice_table += f'{self.cp().nickname.ljust(12)}{" ".join(DICE_DICT[x] for x in self.cp().revealed_dice + self.cp().hidden_dice)}<br>'
self.shift_cpi()
dice_table += '</pre><br>'
await self.broadcast('PLAYER_CHALLENGES')
await self.record('challenges', dice_table)
await asyncio.sleep(max(5, 0.7 * self.n_dice))
all_dice = []
for p in self.players:
all_dice.extend(p.revealed_dice)
all_dice.extend(p.hidden_dice)
diff = self.bid.quantity - sum(
[1 for die in all_dice if die == self.bid.number or die == 1])
if diff < 0:
self.cp().n_dice += diff
elif diff > 0:
self.players[self.ppi].n_dice -= diff
self.cpi = self.ppi
else:
self.cp().n_dice -= 1
self.players[self.ppi].n_dice += 1
await self.check_if_loses()
elif parts[0] == '_BID+1':
if self.bid.quantity > self.n_dice:
await self.eval_move('_SURRENDER')
else:
bid = Bid(self.bid.quantity + 1, self.bid.number)
self.bid = bid
self.cp().bid = bid
await self.broadcast('PLAYER_BIDS')
await self.record('bids ' + str(bid.quantity) +
DICE_DICT[bid.number])
elif parts[0] == '_SURRENDER':
self.finished_round = True
self.cp().n_dice = 0
await self.record('surrenders')
await self.check_if_loses()
await asyncio.sleep(4)
else:
await self.eval_move(await self.invalid_move(move),
challenge_possible, reveal_possible)
def bid_history(self):
from bid import Bid
return Bid.select().join(Product,
on=(Bid.product_id == Product.id)).where(
(Product.id == self.id)).order_by(
Bid.created_at.desc()).limit(3)
