Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.lang.python > #80196 > unrolled thread
| Started by | C Smith <illusiontechniques@gmail.com> |
|---|---|
| First post | 2014-11-04 07:28 -0800 |
| Last post | 2014-11-04 22:23 -0800 |
| Articles | 4 — 3 participants |
Back to article view | Back to comp.lang.python
Code review C Smith <illusiontechniques@gmail.com> - 2014-11-04 07:28 -0800
Re: Code review John Gordon <gordon@panix.com> - 2014-11-04 20:35 +0000
Re: Code review sohcahtoa82@gmail.com - 2014-11-04 16:09 -0800
Re: Code review C Smith <illusiontechniques@gmail.com> - 2014-11-04 22:23 -0800
| From | C Smith <illusiontechniques@gmail.com> |
|---|---|
| Date | 2014-11-04 07:28 -0800 |
| Subject | Code review |
| Message-ID | <mailman.15454.1415115015.18130.python-list@python.org> |
I was wondering if I could get some feedback on the biggest thing I
have done as an amateur Python coder. The sidepots algorithm isn't
correct yet, but I haven't worked on it in a while and thought I would
get some advice before diving back in.
import random, os
##################################################################
class Table(object):
def __init__(self,bigblind=20,PLAYERNUM=0,pot=0,PLAYERORDER=None,
hand_done=0,\
left_to_act=None,cost_to_play=0,in_hand=None,last_raise=0,cards_in_play=None,round='preflop'):
if cards_in_play is None:
cards_in_play = []
if in_hand is None:
in_hand = []
if PLAYERORDER is None:
PLAYERORDER = []
if left_to_act is None:
left_to_act = []
self.hand_done = hand_done
self.round = round
self.cards_in_play = cards_in_play
self.last_raise = last_raise
self.in_hand = in_hand
self.cost_to_play = cost_to_play
self.left_to_act = left_to_act
self.PLAYERORDER = PLAYERORDER
self.bigblind = bigblind
self.PLAYERNUM = PLAYERNUM
self.pot = pot
##################################################################
def fillseats(self,listofplayers, playas):
seating = [x for x in range(1,len(listofplayers)+1)]
random.shuffle(seating)
for y in listofplayers:
playas[y].seatnumber = seating.pop()
for x in listofplayers:
newx = str(playas[x].seatnumber)+x
self.PLAYERORDER.append(newx)
self.PLAYERORDER = sorted(self.PLAYERORDER)
neworder = []
for x in self.PLAYERORDER:
neworder.append(x[1:])
self.PLAYERORDER = neworder
self.PLAYERNUM = len(self.PLAYERORDER)
##########################################################
def postblinds(self,playas,bigblind,deck):
# establish player.start_stack for sidepots
for player in self.PLAYERORDER:
playas[player].start_stack = playas[player].stacksize
# Heads up post blinds
if len(self.PLAYERORDER) == 2:
if bigblind >= playas[self.PLAYERORDER[1]].stacksize:
if bigblind == playas[self.PLAYERORDER[1]].stacksize:
playas[self.PLAYERORDER[1]].stacksize = 0
self.pot += bigblind
playas[self.PLAYERORDER[1]].all_in = 1
playas[self.PLAYERORDER[1]].in_front = bigblind
playas[self.PLAYERORDER[1]].put_in_pot = bigblind
else:
self.pot += playas[self.PLAYERORDER[1]].stacksize
playas[self.PLAYERORDER[1]].in_front =
playas[self.PLAYERORDER[1]].stacksize
playas[self.PLAYERORDER[1]].put_in_pot =
playas[self.PLAYERORDER[1]].stacksize
playas[self.PLAYERORDER[1]].stacksize = 0
playas[self.PLAYERORDER[1]].all_in = 1
if (bigblind/2) >= playas[self.PLAYERORDER[0]].stacksize:
if bigblind == playas[self.PLAYERORDER[0]].stacksize:
playas[self.PLAYERORDER[0]].in_front = bigblind/2
playas[self.PLAYERORDER[0]].put_in_pot = bigblind/2
playas[self.PLAYERORDER[0]].stacksize = 0
self.pot += bigblind/2
playas[self.PLAYERORDER[0]].all_in = 1
else:
playas[self.PLAYERORDER[0]].put_in_pot =
playas[self.PLAYERORDER[0]].stacksize
playas[self.PLAYERORDER[0]].in_front =
playas[self.PLAYERORDER[0]].stacksize
playas[self.PLAYERORDER[0]].stacksize = 0
playas[self.PLAYERORDER[0]].all_in = 1
if playas[self.PLAYERORDER[0]].all_in == 0:
playas[self.PLAYERORDER[0]].stacksize -= bigblind/2
playas[self.PLAYERORDER[0]].in_front = bigblind/2
playas[self.PLAYERORDER[0]].put_in_pot = bigblind/2
self.pot += bigblind/2
if playas[self.PLAYERORDER[1]].all_in == 0:
playas[self.PLAYERORDER[1]].stacksize -= bigblind
playas[self.PLAYERORDER[1]].in_front = bigblind
playas[self.PLAYERORDER[1]].put_in_pot = bigblind
self.pot += bigblind
self.left_to_act = self.PLAYERORDER[:]
self.cost_to_play = bigblind
self.last_raise = bigblind
else: # post blinds for more that 2 players
# player has not enough or just enough for big blind
if playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].stacksize
<= bigblind:
if
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].stacksize <
bigblind:
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].put_in_pot =
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].stacksize
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].in_front =
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].stacksize
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].all_in = 1
self.pot +=
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].stacksize
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].stacksize = 0
elif
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].stacksize ==
bigblind:
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].in_front = bigblind
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].put_in_pot =
bigblind
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].all_in = 1
self.pot += bigblind
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].stacksize = 0
else:
# Normal post bigblind
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].stacksize -=
bigblind
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].in_front = bigblind
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].put_in_pot =
bigblind
self.pot += bigblind
# player has not enough or just enough for small blind
if playas[self.PLAYERORDER[1]].stacksize <= bigblind/2:
if playas[self.PLAYERORDER[1]].stacksize < bigblind/2:
playas[self.PLAYERORDER[1]].all_in = 1
self.pot += playas[self.PLAYERORDER[1]].stacksize
playas[self.PLAYERORDER[1]].in_front =
playas[self.PLAYERORDER[1]].stacksize
playas[self.PLAYERORDER[1]].put_in_pot =
playas[self.PLAYERORDER[1]].stacksize
playas[self.PLAYERORDER[1]].stacksize = 0
elif playas[self.PLAYERORDER[1]].stacksize == bigblind/2:
playas[self.PLAYERORDER[1]].all_in = 1
self.pot += bigblind/2
playas[self.PLAYERORDER[1]].in_front = bigblind/2
playas[self.PLAYERORDER[1]].put_in_pot = bigblind/2
playas[self.PLAYERORDER[1]].stacksize = 0
else: # normal post small blind
playas[self.PLAYERORDER[1]].stacksize -= bigblind/2
playas[self.PLAYERORDER[1]].in_front = bigblind/2
playas[self.PLAYERORDER[1]].put_in_pot = bigblind/2
self.pot += bigblind/2
self.left_to_act =
self.PLAYERORDER[3%len(self.PLAYERORDER):]+self.PLAYERORDER[:3%len(self.PLAYERORDER)]
self.cost_to_play = bigblind
self.last_raise = bigblind
for x in self.PLAYERORDER:
playas[x].drawcard(deck.draw())
for x in self.PLAYERORDER:
playas[x].drawcard(deck.draw())
for x in self.PLAYERORDER:
print x+" stacksize is "+str(playas[x].stacksize)
print x+" is at seat number "+str(playas[x].seatnumber)
print raw_input('to begin, hit any key')
self.get_action(playas, bigblind, deck)
##################################################################
def showdown(self,playas,bigblind,deck):
print "in_hand equals %s" % self.in_hand
handtobeat = 0
for player in self.in_hand:
final_hand = self.cards_in_play + playas[player].hand
ranks = [x[0] for x in final_hand]
suits = [x[1] for x in final_hand]
#ints with Ace as 14 and 2 for straights
straightranks = []
#ints with Ace as 14 for pairs
pairranks = []
for rank in ranks:
if rank == 'T':
straightranks.append(10)
elif rank == 'J':
straightranks.append(11)
elif rank == 'Q':
straightranks.append(12)
elif rank == 'K':
straightranks.append(13)
elif rank == 'A':
straightranks.append(1)
straightranks.append(14)
else:
straightranks.append(int(rank))
pairranks = [x for x in straightranks if x != 1]
straightranks = sorted(list(set(straightranks)),reverse=True)
########### USE straightranks FOR STRAIGHTS
if straight_flush_finder(final_hand)[0] == True:
playas[player].hand_rank =
(9,straight_flush_finder(final_hand))
elif four_of_a_kind_finder(pairranks)[0] == True:
playas[player].hand_rank = (8,four_of_a_kind_finder(pairranks))
elif fullhouse_finder(pairranks)[0] == True:
playas[player].hand_rank = (7,fullhouse_finder(pairranks))
elif flush_finder(final_hand)[0] == True:
playas[player].hand_rank = (6,flush_finder(final_hand))
elif straight_finder(straightranks)[0] == True:
playas[player].hand_rank = (5,straight_finder(straightranks))
elif three_of_a_kind_finder(pairranks)[0] == True:
playas[player].hand_rank = (4,three_of_a_kind_finder(pairranks))
elif two_pair_finder(pairranks)[0] == True:
playas[player].hand_rank = (3,two_pair_finder(pairranks))
elif one_pair_finder(pairranks)[0] == True:
playas[player].hand_rank = (2,one_pair_finder(pairranks))
else:
playas[player].hand_rank = (1,highcard_finder(pairranks))
# check if any player has a different amount in the
pot (sidepot necessary)
one_put_in_pot = playas[self.in_hand[0]].put_in_pot
for player in self.in_hand:
if playas[player].put_in_pot != one_put_in_pot:
bigstack = 0
bigplayer = ''
for player in self.in_hand:
if playas[player].put_in_pot > bigstack:
bigplayer = player
bigstack = playas[player].put_in_pot
in_hand_copy = self.in_hand[:]
in_hand_copy.remove(bigplayer)
lowstack = 999999999999999
lowman = ''
for player in in_hand_copy:
if playas[player].put_in_pot < lowstack:
lowman = player
lowstack = playas[player].put_in_pot
if playas[bigplayer].put_in_pot > playas[lowman].put_in_pot:
print 'bigplayer %s put in pot is %s' %
(bigplayer, playas[bigplayer].put_in_pot)
print 'lowman %s put in pot %s' % (lowman,
playas[lowman].put_in_pot)
for player in self.in_hand:
print '%s is in hand and put %s in pot' %
(player, playas[player].put_in_pot)
raw_input("Sidepot split necessary, hit enter to continue")
sidepot1 = 0
for player in self.PLAYERORDER:
sidepot1 +=
min(playas[player].put_in_pot,playas[lowman].put_in_pot)
sidepot1elig = self.in_hand[:]
self.pot -= sidepot1
sidepot1winners = []
handtobeat = 0
for player in sidepot1elig:
if playas[player].hand_rank[0] >= handtobeat:
handtobeat = playas[player].hand_rank[0]
sidepot1winners.append(player)
for player in sidepot1winners:
if playas[player].hand_rank[0] < handtobeat:
sidepot1winners.remove(player)
sidepot1winners = tie_breaker(sidepot1winners,playas)
for player in sidepot1winners[0]:
print '%s you win %s chips' %
(player,sidepot1/len(sidepot1winners[0]))
playas[player].stacksize +=
(sidepot1/len(sidepot1winners[0]))
showmuck = 'x'
while showmuck not in ['s','m']:
showmuck = raw_input('%s show or muck
hand? (hit s OR m) ' % player)
if showmuck == 's':
playas[player].showhand()
print playas[player].hand_rank
if showmuck == 'm':
playas[player].muckhand()
anothercopy = self.in_hand[:]
for player in anothercopy:
if playas[player].start_stack == playas[lowman].start_stack:
self.in_hand.remove(player)
break
############## rest of showdown
handtobeat = 0
winningplayers = []
for player in self.in_hand:
if playas[player].hand_rank[0] >= handtobeat:
handtobeat = playas[player].hand_rank[0]
winningplayers.append(player)
winnerscopy = winningplayers[:]
for player in winnerscopy:
if playas[player].hand_rank[0] < handtobeat:
winningplayers.remove(player)
# tie_breaker changes winningplayers into nested list
winningplayers = tie_breaker(winningplayers,playas)
for winnerwinner in winningplayers[0]:
self.hand_done = 1
print '%s you win %s chips' %
(winnerwinner,self.pot/len(winningplayers[0]))
playas[winnerwinner].stacksize += (self.pot/len(winningplayers[0]))
showmuck = 'x'
while showmuck not in ['s','m']:
showmuck = raw_input('%s show or muck hand? (hit s OR
m) ' % winnerwinner)
if showmuck == 's':
playas[winnerwinner].showhand()
print playas[winnerwinner].hand_rank
if showmuck == 'm':
playas[winnerwinner].muckhand()
self.end_hand(playas,bigblind,deck)
#################################################################################
def turn_one(self, deck):
self.cards_in_play.append(deck.draw())
print self.cards_in_play[-1] + ' drawn'
raw_input('Hit Enter')
def burn_one(self, deck):
deck.burn()
print 'Card Burnt'
raw_input('Hit Enter')
##################################
def end_hand(self, playas, bigblind, deck):
print 'hand done'
playercopy = self.PLAYERORDER[:]
for x in playercopy:
print '%s stacksize is %s' % (x, playas[x].stacksize)
if playas[x].stacksize == 0:
print '%s you are out of the game.' % x
self.PLAYERORDER.remove(x)
if len(self.PLAYERORDER) == 1:
print 'tournament over, %s wins' % self.PLAYERORDER[0]
exit()
raw_input('Hit enter for the next hand')
for player in self.PLAYERORDER:
playas[player].put_in_pot = 0
playas[player].all_in = 0
buttonmover = self.PLAYERORDER[0]
self.PLAYERORDER = self.PLAYERORDER[1:]
self.PLAYERORDER.append(buttonmover)
self.left_to_act = []
self.in_hand = []
self.hand_done = 0
for x in self.PLAYERORDER:
playas[x].in_front = 0
playas[x].hand = []
self.cards_in_play = []
self.pot = 0
self.round = 'preflop'
self.last_raise = 0
self.cost_to_play = 0
deck.renew()
self.postblinds(playas, bigblind, deck)
##################################################################
def get_action(self,playas,bigblind,deck):
###################### test if folded around to a player (hand done
without showdown) ##################
if len(self.left_to_act) == 0 and len(self.in_hand) == 1:
self.hand_done = 1
print '%s you win %s chips' % (self.in_hand[0],self.pot)
playas[self.in_hand[0]].stacksize += self.pot
showmuck = 'x'
while showmuck not in ['s','m']:
showmuck = raw_input('%s show or muck hand? (hit s OR
m) ' % self.in_hand[0])
if showmuck == 's':
playas[self.in_hand[0]].showhand()
if showmuck == 'm':
playas[self.in_hand[0]].muckhand()
for player in self.in_hand:
print playas[player].put_in_pot
raw_input('Hit enter')
self.end_hand(playas,bigblind,deck)
###########################################################################
################# test if river (last) round is done (SHOWDOWN) ################
if len(self.left_to_act) == 0 and self.round == 'river':
self.hand_done = 1
#return excess chips
bigstack = 0
bigplayer = ''
for player in self.in_hand:
if playas[player].put_in_pot > bigstack:
bigplayer = player
bigstack = playas[player].put_in_pot
in_hand_copy = self.in_hand[:]
in_hand_copy.remove(bigplayer)
nextbigstack = 0
nextbigplayer = ''
for player in in_hand_copy:
if playas[player].put_in_pot > nextbigstack:
nextbigplayer = player
nextbigstack = playas[player].put_in_pot
if playas[bigplayer].put_in_pot > playas[nextbigplayer].put_in_pot:
## ## nextbigstack could have folded
difference = playas[bigplayer].put_in_pot -
playas[nextbigplayer].put_in_pot
playas[bigplayer].stacksize += difference
playas[bigplayer].put_in_pot = playas[nextbigplayer].put_in_pot
self.pot -= difference
self.showdown(playas,bigblind,deck)
print self.cards_in_play
print 'Hand done'
raw_input('hit enter')
self.end_hand(playas,bigblind,deck)
#####################################################################################
################# test if turn (2nd to last round) is done
##################################
if len(self.left_to_act) == 0 and self.round == 'turn':
print self.cards_in_play
print 'Turn done'
raw_input('hit enter')
self.round = 'river'
for x in self.PLAYERORDER:
playas[x].in_front = 0
self.last_raise = bigblind
self.cost_to_play = 0
neworder = self.PLAYERORDER[1:]+self.PLAYERORDER[0:1]
for x in neworder:
if x in self.in_hand:
self.left_to_act.append(x)
self.in_hand = []
self.burn_one(deck)
self.turn_one(deck)
for player in self.in_hand:
playas[player].in_front = 0
self.get_action(playas,bigblind,deck)
#####################################################################################
################# test if flop is done
###################################################
if len(self.left_to_act) == 0 and self.round == 'postflop':
print self.cards_in_play
print 'Postflop done'
raw_input('hit enter')
self.round = 'turn'
for x in self.PLAYERORDER:
playas[x].in_front = 0
self.last_raise = bigblind
self.cost_to_play = 0
neworder = self.PLAYERORDER[1:]+self.PLAYERORDER[0:1]
for x in neworder:
if x in self.in_hand:
self.left_to_act.append(x)
self.in_hand = []
self.burn_one(deck)
self.turn_one(deck)
for player in self.in_hand:
playas[player].in_front = 0
self.get_action(playas,bigblind,deck)
#####################################################################################
################# test if preflop play is done
##################################
if len(self.left_to_act) == 0 and self.round == 'preflop':
for x in self.PLAYERORDER:
playas[x].in_front = 0
print ' stacksize is %s' % playas[x].stacksize
print 'in hand ',self.in_hand
print 'player order ',self.PLAYERORDER
print 'flop done'
print 'pot is '+str(self.pot)
self.last_raise = bigblind
self.cost_to_play = 0
neworder = self.PLAYERORDER[1:]+self.PLAYERORDER[0:1]
for x in neworder:
if x in self.in_hand:
self.left_to_act.append(x)
self.in_hand = []
self.burn_one(deck)
self.turn_one(deck)
self.turn_one(deck)
self.turn_one(deck)
print self.cards_in_play
self.round = 'postflop'
raw_input("hit enter")
self.get_action(playas,bigblind,deck)
###############
turnscreen(self.left_to_act)
###############
# Catch a player all-in and pass their turn
if playas[self.left_to_act[0]].all_in == 1:
raw_input("%s you are all in, hit enter to continue" %
self.left_to_act[0])
if self.left_to_act[0] not in self.in_hand:
self.in_hand.append(self.left_to_act[0])
del self.left_to_act[0]
self.get_action(playas,bigblind,deck)
############# Display for each action prompt
for x in self.PLAYERORDER:
print x +'stacksize is '+ str(playas[x].stacksize)
print self.left_to_act[0] + ' your hand is
'+playas[self.left_to_act[0]].hand[0]+'
'+playas[self.left_to_act[0]].hand[1]
print 'The last raise is '+str(self.last_raise)
print 'The pot is '+str(self.pot)
print 'The cost to play is
'+str(self.cost_to_play-playas[self.left_to_act[0]].in_front)
print 'You have %s in the pot' % playas[self.left_to_act[0]].put_in_pot
print 'You started the hand with %s chips' %
playas[self.left_to_act[0]].start_stack
print 'This round, you have put %s chips in the pot' %
playas[self.left_to_act[0]].in_front
showcards = (', ').join(x for x in self.cards_in_play)
print 'The cards in play are '+showcards
# Check if a player can Check their turn
if playas[self.left_to_act[0]].in_front >= self.cost_to_play:
current_action = 'q'
current_action = raw_input("%s will you check, bet, or
fold? (type c OR b OR f) " % self.left_to_act[0])
#Check your turn, if infront == cost
if current_action == 'c':
if self.left_to_act[0] in self.in_hand:
del self.in_hand[self.left_to_act[0]]
self.in_hand.append(self.left_to_act[0])
self.left_to_act.remove(self.left_to_act[0])
self.get_action(playas,bigblind,deck)
# Bet , after check option
elif current_action == 'b':
currentraise = 3
while currentraise % 10 != 0:
currentraise = int(raw_input('%s what will you
bet? (increments of 10) ' % self.left_to_act[0]))
while currentraise < 2*self.last_raise:
currentraise = int(raw_input('%s what will you
bet? (increments of 10) ' % self.left_to_act[0]))
# Bet with exactly enough chips, after check option
if
self.cost_to_play-playas[self.left_to_act[0]].in_front + currentraise
== playas[self.left_to_act[0]].stacksize:
raw_input("%s you are all in" % self.left_to_act[0])
playas[self.left_to_act[0]].all_in = 1
self.last_raise = playas[self.left_to_act[0]].stacksize
self.pot +=
(self.cost_to_play-playas[self.left_to_act[0]].in_front+playas[self.left_to_act[0]].stacksize)
self.cost_to_play += playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].in_front +=
playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].put_in_pot +=
playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].stacksize = 0
if self.left_to_act[0] in self.in_hand:
self.in_hand.remove(self.left_to_act[0])
for x in self.in_hand:
if x not in self.left_to_act:
self.left_to_act.append(x)
self.in_hand.append(self.left_to_act[0])
self.left_to_act.remove(self.left_to_act[0])
self.get_action(playas,bigblind,deck)
### Bet, not enough chips, after check option
elif
self.cost_to_play-playas[self.left_to_act[0]].in_front + currentraise
> playas[self.left_to_act[0]].stacksize:
raw_input("Not enough to raise that amount, %s put
all in, hit enter" % self.left_to_act[0])
playas[self.left_to_act[0]].all_in = 1
self.pot += playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].put_in_pot +=
playas[self.left_to_act[0]].stacksize
currentraise =
playas[self.left_to_act[0]].stacksize-self.cost_to_play-playas[self.left_to_act[0]].in_front
playas[self.left_to_act[0]].in_front +=
playas[self.left_to_act[0]].stacksize
self.cost_to_play += currentraise
self.last_raise = playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].stacksize = 0
if self.left_to_act[0] in self.in_hand:
self.in_hand.remove(self.left_to_act[0])
for x in self.in_hand:
if x not in self.left_to_act:
self.left_to_act.append(x)
self.in_hand.append(self.left_to_act[0])
self.left_to_act.remove(self.left_to_act[0])
self.get_action(playas,bigblind,deck)
# Rest of Bet, more than enough chips after check option
self.pot += (currentraise +
self.cost_to_play-playas[self.left_to_act[0]].in_front)
playas[self.left_to_act[0]].put_in_pot +=
(currentraise +
self.cost_to_play-playas[self.left_to_act[0]].in_front)
self.last_raise = currentraise
self.cost_to_play += currentraise
playas[self.left_to_act[0]].stacksize -=
(self.cost_to_play - playas[self.left_to_act[0]].in_front)
playas[self.left_to_act[0]].in_front +=
(self.cost_to_play - playas[self.left_to_act[0]].in_front)
if self.left_to_act[0] in self.in_hand:
self.in_hand.remove(self.left_to_act[0])
for x in self.in_hand:
if x not in self.left_to_act:
self.left_to_act.append(x)
self.in_hand.append(self.left_to_act[0])
self.left_to_act.remove(self.left_to_act[0])
self.get_action(playas,bigblind,deck)
# Fold, after check option. Hey, you can do it!
elif current_action == 'f':
if self.left_to_act[0] in self.in_hand:
self.in_hand.remove(self.left_to_act[0])
self.left_to_act.remove(self.left_to_act[0])
self.get_action(playas,bigblind,deck)
# Prompt for action, no check option
current_action = raw_input("%s will you call, raise, or fold?
(type c OR r OR f) " % self.left_to_act[0])
# Call
if current_action == 'c':
# Not enough chips, or just enough chips to call
if self.cost_to_play-playas[self.left_to_act[0]].in_front
>= playas[self.left_to_act[0]].stacksize:
playas[self.left_to_act[0]].all_in = 1
self.pot += playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].put_in_pot +=
playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].in_front +=
playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].stacksize = 0
if self.left_to_act[0] in self.in_hand:
self.in_hand.remove(self.left_to_act[0])
self.in_hand.append(self.left_to_act[0])
self.left_to_act.remove(self.left_to_act[0])
self.get_action(playas,bigblind,deck)
# Call, with more than enough chips
else:
playas[self.left_to_act[0]].stacksize -=
(self.cost_to_play-playas[self.left_to_act[0]].in_front)
self.pot +=
(self.cost_to_play-playas[self.left_to_act[0]].in_front)
playas[self.left_to_act[0]].put_in_pot +=
(self.cost_to_play-playas[self.left_to_act[0]].in_front)
playas[self.left_to_act[0]].in_front +=
(self.cost_to_play-playas[self.left_to_act[0]].in_front)
if self.left_to_act[0] in self.in_hand:
self.in_hand.remove(self.left_to_act[0])
self.in_hand.append(self.left_to_act[0])
self.left_to_act.remove(self.left_to_act[0])
self.get_action(playas,bigblind,deck)
# Raise, no check option
elif current_action == 'r':
currentraise = 3
while currentraise % 10 != 0:
currentraise = int(raw_input('%s what will you raise?
(increments of 10) ' % self.left_to_act[0]))
while currentraise < 2*self.last_raise:
currentraise = int(raw_input('%s what will you raise?
(increments of 10) ' % self.left_to_act[0]))
# Raise with exactly enough chips
if self.cost_to_play-playas[self.left_to_act[0]].in_front
+ currentraise == playas[self.left_to_act[0]].stacksize:
raw_input("%s you are all in" % self.left_to_act[0])
self.pot += playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].put_in_pot +=
playas[self.left_to_act[0]].stacksize
self.cost_to_play += currentraise
self.last_raise = currentraise
playas[self.left_to_act[0]].all_in = 1
playas[self.left_to_act[0]].in_front +=
playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].stacksize = 0
if self.left_to_act[0] in self.in_hand:
self.in_hand.remove(self.left_to_act[0])
for x in self.in_hand:
if x not in self.left_to_act:
self.left_to_act.append(x)
self.in_hand.append(self.left_to_act[0])
self.left_to_act.remove(self.left_to_act[0])
self.get_action(playas,bigblind,deck)
### Raise not enough chips
elif
self.cost_to_play-playas[self.left_to_act[0]].in_front + currentraise
> playas[self.left_to_act[0]].stacksize:
raw_input("%s put all in, hit enter" % self.left_to_act[0])
playas[self.left_to_act[0]].all_in = 1
self.cost_to_play = playas[self.left_to_act[0]].stacksize
self.last_raise = playas[self.left_to_act[0]].stacksize
self.pot += playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].put_in_pot +=
playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].in_front +=
playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].stacksize = 0
if self.left_to_act[0] in self.in_hand:
self.in_hand.remove(self.left_to_act[0])
for x in self.in_hand:
if x not in self.left_to_act:
self.left_to_act.append(x)
self.in_hand.append(self.left_to_act[0])
self.left_to_act.remove(self.left_to_act[0])
self.get_action(playas,bigblind,deck)
# Raise with enough chips
self.pot += (currentraise +
self.cost_to_play-playas[self.left_to_act[0]].in_front)
playas[self.left_to_act[0]].put_in_pot += (currentraise +
self.cost_to_play-playas[self.left_to_act[0]].in_front)
self.last_raise = currentraise
self.cost_to_play += currentraise
playas[self.left_to_act[0]].stacksize -=
(self.cost_to_play - playas[self.left_to_act[0]].in_front)
playas[self.left_to_act[0]].in_front += (self.cost_to_play
- playas[self.left_to_act[0]].in_front)
if self.left_to_act[0] in self.in_hand:
self.in_hand.remove(self.left_to_act[0])
for x in self.in_hand:
if x not in self.left_to_act:
self.left_to_act.append(x)
self.in_hand.append(self.left_to_act[0])
self.left_to_act.remove(self.left_to_act[0])
self.get_action(playas,bigblind,deck)
# Fold, after call option
elif current_action == 'f':
if self.left_to_act[0] in self.in_hand:
self.in_hand.remove(self.left_to_act[0])
self.left_to_act.remove(self.left_to_act[0])
self.get_action(playas,bigblind,deck)
#########################################################################
class Deck(object):
def __init__(self,cards=None):
if cards is None:
cards = []
self.cards = cards
suits = ["S","C","D","H"]
ranks = ["2","3","4","5","6","7","8","9","T","J","Q","K","A"]
for suit in suits:
for rank in ranks:
self.cards.append(rank+suit)
random.shuffle(self.cards)
def draw(self):
return self.cards.pop()
def burn(self):
self.cards = self.cards[0:-1]
def renew(self):
suits = ["S","C","D","H"]
ranks = ["2","3","4","5","6","7","8","9","T","J","Q","K","A"]
self.cards = []
for suit in suits:
for rank in ranks:
self.cards.append(rank+suit)
random.shuffle(self.cards)
##################################################################
class Player(object):
playercount = 0
def __init__(self,stacksize=0,HUMAN=True,hand=None,seatnumber=0,\
in_front=0,hand_rank=0,all_in=0,start_stack=0, put_in_pot=0):
self.all_in = all_in
self.seatnumber = seatnumber
self.start_stack = start_stack
self.hand_rank = hand_rank
self.stacksize = stacksize
self.HUMAN = HUMAN
self.in_front = in_front
self.put_in_pot = put_in_pot
if hand == None:
hand = []
self.hand = hand
Player.playercount += 1
def drawcard(self,card):
self.hand.append(card)
def muckhand(self):
self.hand = []
print 'mucked'
def showhand(self):
print self.hand
##################################################################
def tie_breaker(winningplayers,playas):
ranky = playas[winningplayers[0]].hand_rank[0]
reallywinners = []
reallyreally = []
reallyreallyreally = []
thisisitiswear = []
okaylastone = []
high_int = 0
if ranky == 9 or ranky == 5:
for player in winningplayers:
if playas[player].hand_rank[1][1] > high_int:
reallywinners = []
high_int = playas[player].hand_rank[1][1]
if player not in reallywinners:
reallywinners.append(player)
if playas[player].hand_rank[1][1] == high_int:
if player not in reallywinners:
reallywinners.append(player)
elif ranky == 8 or ranky == 7:
for player in winningplayers:
if playas[player].hand_rank[1][1] > high_int:
reallywinners = []
high_int = playas[player].hand_rank[1][1]
if player not in reallywinners:
reallywinners.append(player)
if playas[player].hand_rank[1][1] == high_int:
if player not in reallywinners:
reallywinners.append(player)
if len(reallywinners) >= 2:
high_int = 0
for player in reallywinners:
if playas[player].hand_rank[1][2] > high_int:
reallyreally = []
high_int = playas[player].hand_rank[1][2]
if player not in reallyreally:
reallyreally.append(player)
if playas[player].hand_rank[1][2] == high_int:
if player not in reallyreally:
reallyreally.append(player)
elif ranky == 6:
for player in winningplayers:
if playas[player].hand_rank[1][1][0] > high_int:
reallywinners = []
high_int = playas[player].hand_rank[1][1][0]
if player not in reallywinners:
reallywinners.append(player)
if playas[player].hand_rank[1][1][0] == high_int:
if player not in reallywinners:
reallywinners.append(player)
elif ranky == 4:
for player in winningplayers:
if playas[player].hand_rank[1][1] > high_int:
reallywinners = []
high_int = playas[player].hand_rank[1][1]
if player not in reallywinners:
reallywinners.append(player)
if playas[player].hand_rank[1][1] == high_int:
if player not in reallywinners:
reallywinners.append(player)
if len(reallywinners) >= 2:
high_int = 0
for player in reallywinners:
if playas[player].hand_rank[1][2][0] > high_int:
reallyreally = []
high_int = playas[player].hand_rank[1][2][0]
if player not in reallyreally:
reallyreally.append(player)
if playas[player].hand_rank[1][2][1] == high_int:
if player not in reallyreally:
reallyreally.append(player)
elif ranky == 3:
for player in winningplayers:
if playas[player].hand_rank[1][1] > high_int:
reallywinners = []
high_int = playas[player].hand_rank[1][1]
if player not in reallywinners:
reallywinners.append(player)
if playas[player].hand_rank[1][1] == high_int:
if player not in reallywinners:
reallywinners.append(player)
if len(reallywinners) >= 2:
high_int = 0
for player in reallywinners:
if playas[player].hand_rank[1][2] > high_int:
reallyreally = []
high_int = playas[player].hand_rank[1][2]
if player not in reallyreally:
reallyreally.append(player)
if playas[player].hand_rank[1][2] == high_int:
if player not in reallyreally:
reallyreally.append(player)
if len(reallyreally) >= 2:
high_int = 0
for player in reallyreally:
if playas[player].hand_rank[1][3] > high_int:
reallyreallyreally = []
high_int = playas[player].hand_rank[1][3]
if player not in reallyreallyreally:
reallyreallyreally.append(player)
if playas[player].hand_rank[1][3] == high_int:
if player not in reallyreallyreally:
reallyreallyreally.append(player)
elif ranky == 2:
for player in winningplayers:
if playas[player].hand_rank[1][1] > high_int:
high_int = playas[player].hand_rank[1][1]
reallywinners = []
if player not in reallywinners:
reallywinners.append(player)
if playas[player].hand_rank[1][1] == high_int:
if player not in reallywinners:
reallywinners.append(player)
if len(reallywinners) >= 2:
high_int = 0
for player in reallywinners:
if playas[player].hand_rank[1][2][0] > high_int:
high_int = playas[player].hand_rank[1][2][0]
reallyreally = []
if player not in reallyreally:
reallyreally.append(player)
if playas[player].hand_rank[1][2][0] == high_int:
if player not in reallyreally:
reallyreally.append(player)
if len(reallyreally) >= 2:
high_int = 0
for player in reallyreally:
if playas[player].hand_rank[1][2][1] > high_int:
high_int = playas[player].hand_rank[1][2][1]
reallyreallyreally = []
if player not in reallyreallyreally:
reallyreallyreally.append(player)
if playas[player].hand_rank[1][2][1] == high_int:
if player not in reallyreallyreally:
reallyreallyreally.append(player)
if len(reallyreallyreally) >= 2:
high_int = 0
for player in reallyreallyreally:
if playas[player].hand_rank[1][2][2] > high_int:
high_int = playas[player].hand_rank[1][2][2]
thisisitiswear = []
if player not in thisisitiswear:
thisisitiswear.append(player)
if playas[player].hand_rank[1][2][2] == high_int:
if player not in thisisitiswear:
thisisitiswear.append(player)
elif ranky == 1:
for player in winningplayers:
if playas[player].hand_rank[1][0] > high_int:
high_int = playas[player].hand_rank[1][0]
reallywinners = []
if player not in reallywinners:
reallywinners.append(player)
if playas[player].hand_rank[1][0] == high_int:
if player not in reallywinners:
reallywinners.append(player)
if len(reallywinners) >= 2:
high_int = 0
for player in reallywinners:
if playas[player].hand_rank[1][1] > high_int:
high_int = playas[player].hand_rank[1][1]
reallyreally = []
if player not in reallyreally:
reallyreally.append(player)
if playas[player].hand_rank[1][1] == high_int:
if player not in reallyreally:
reallyreally.append(player)
if len(reallyreally) >= 2:
high_int = 0
for player in reallyreally:
if playas[player].hand_rank[1][2] > high_int:
high_int = playas[player].hand_rank[1][2]
reallyreallyreally = []
if player not in reallyreallyreally:
reallyreallyreally.append(player)
if playas[player].hand_rank[1][2] == high_int:
if player not in reallyreallyreally:
reallyreallyreally.append(player)
if len(reallyreallyreally) >= 2:
high_int = 0
for player in reallyreallyreally:
if playas[player].hand_rank[1][3] > high_int:
high_int = playas[player].hand_rank[1][3]
thisisitiswear = []
if player not in thisisitiswear:
thisisitiswear.append(player)
if playas[player].hand_rank[1][3] == high_int:
if player not in thisisitiswear:
thisisitiswear.append(player)
if len(thisisitiswear) >= 2:
high_int = 0
for player in thisisitiswear:
if playas[player].hand_rank[1][4] > high_int:
high_int = playas[player].hand_rank[1][4]
okaylastone = []
if player not in okaylastone:
okaylastone.append(player)
if playas[player].hand_rank[1][4] == high_int:
if player not in okaylastone:
okaylastone.append(player)
if len(okaylastone) >= 1:
return [okaylastone,thisisitiswear,reallyreallyreally,reallyreally,reallywinners]
elif len(thisisitiswear) >= 1:
return [thisisitiswear,reallyreallyreally,reallyreally,reallywinners]
elif len(reallyreallyreally) >= 1:
return [reallyreallyreally,reallyreally,reallywinners]
elif len(reallyreally) >= 1:
return [reallyreally,reallywinners]
else:
return [reallywinners]
######################################################################
def turnscreen(listplayrs):
os.system('cls' if os.name=='nt' else 'clear')
raw_input("Turn the screen to %s and hit enter" % listplayrs[0])
os.system('cls' if os.name=='nt' else 'clear')
###############################################################
def straight_finder(ranks):
if len(ranks) < 5:
return (False,0)
if ranks[0] == ranks[1]+1 and ranks[1] == ranks[2]+1 and ranks[2]
== ranks[3]+1\
and ranks[3] == ranks[4]+1:
return (True,ranks[0])
else:
return straight_finder(ranks[1:])
###############################################################################
def four_of_a_kind_finder(ranks):
rankcounter = {14:0,13:0,12:0,11:0,10:0,9:0,8:0,7:0,6:0,5:0,4:0,3:0,2:0}
for rank in ranks:
rankcounter[rank] += 1
if 4 in rankcounter.values():
highcards = []
quads = 0
for card,amount in rankcounter.items():
if amount == 4:
quads = card
if 0 < amount < 4:
highcards.append(card)
return (True,quads,max(highcards))
else:
return (False,0)
################################################################################
def fullhouse_finder(ranks):
rankcounter = {14:0,13:0,12:0,11:0,10:0,9:0,8:0,7:0,6:0,5:0,4:0,3:0,2:0}
for rank in ranks:
rankcounter[rank] += 1
set3s = []
set2s = []
for card,amount in rankcounter.items():
if amount == 3:
set3s.append(card)
if amount == 2:
set2s.append(card)
if len(set3s) == 2:
set2s.append(min(have3))
set3s.remove(min(have3))
if len(set3s) == 1 and len(set2s) >= 1:
return (True,set3s[0],max(set2s))
else:
return (False,0,0)
#################################################
def two_pair_finder(pairranks):
rankcounter = {14:0,13:0,12:0,11:0,10:0,9:0,8:0,7:0,6:0,5:0,4:0,3:0,2:0}
pairsof2 = []
for rank in pairranks:
rankcounter[rank] += 1
if rankcounter[rank] == 2:
pairsof2.append(rank)
highlist = []
for rank,amount in rankcounter.items():
if amount == 1:
highlist.append(rank)
highcard = max(highlist)
if len(pairsof2) >= 2:
overpair = max(pairsof2)
pairsof2.remove(max(pairsof2))
return (True,overpair,max(pairsof2),highcard)
else:
return (False,0,0,0)
#################################################
def flush_finder(final_hand):
flushdict = {'S':0,'C':0,'H':0,'D':0}
for card in final_hand:
flushdict[card[1]] += 1
flushranks = []
for card in final_hand:
if flushdict[card[1]] >= 5:
suit = card[1]
if card[0] == 'A':
flushranks.append(14)
elif card[0] == 'K':
flushranks.append(13)
elif card[0] == 'Q':
flushranks.append(12)
elif card[0] == 'J':
flushranks.append(11)
elif card[0] == 'T':
flushranks.append(10)
else:
flushranks.append(int(card[0]))
if len(flushranks) >= 5:
return (True,sorted(flushranks,reverse=True),suit)
else:
return (False,0,0)
##################################################################
def straight_flush_finder(final_hand):
flushsuits = {'S':0,'C':0,'H':0,'D':0}
for card in final_hand:
flushsuits[card[1]] += 1
flushranks = []
for card in final_hand:
if flushsuits[card[1]] >= 5:
suit = card[1]
if card[0] == 'A':
flushranks.append(14)
elif card[0] == 'K':
flushranks.append(13)
elif card[0] == 'Q':
flushranks.append(12)
elif card[0] == 'J':
flushranks.append(11)
elif card[0] == 'T':
flushranks.append(10)
else:
flushranks.append(int(card[0]))
if len(flushranks) >= 5:
flushrankscopy = flushranks[:]
for rank in flushrankscopy:
if rank == 14:
flushranks.append(1)
newflushranks = sorted(list(set(flushranks)),reverse=True)
while len(newflushranks) >= 5:
if newflushranks[0] == newflushranks[1]+1 and
newflushranks[1] == newflushranks[2]+1 and newflushranks[2] ==
newflushranks[3]+1\
and newflushranks[3] == newflushranks[4]+1:
return (True,newflushranks[0])
else:
newflushranks = newflushranks[1:]
return (False,0,0)
return (False,0,0)
######################################################################
def three_of_a_kind_finder(pairranks):
rankcounter = {14:0,13:0,12:0,11:0,10:0,9:0,8:0,7:0,6:0,5:0,4:0,3:0,2:0}
for rank in pairranks:
rankcounter[rank] += 1
threes = []
highcards = []
for card,amount in rankcounter.items():
if amount == 3:
threes.append(card)
if 0 < amount < 3:
highcards.append(card)
highcards.sort(reverse=True)
if len(threes) >= 1:
return (True,max(threes),highcards[:2])
return (False,0)
######################################################################
def one_pair_finder(pairranks):
rankcounter = {14:0,13:0,12:0,11:0,10:0,9:0,8:0,7:0,6:0,5:0,4:0,3:0,2:0}
for rank in pairranks:
rankcounter[rank] += 1
highcards = []
pairsof2 = []
for card,amount in rankcounter.items():
if amount == 1:
highcards.append(card)
if amount == 2:
pairsof2.append(card)
if len(pairsof2) >=1:
return (True,max(pairsof2),sorted(highcards,reverse=True))
else:
return (False,0,0)
######################################################################
def highcard_finder(pairranks):
highlist = (sorted(pairranks,reverse=True))
return highlist
######################################################################
def main():
playernum = 0
while playernum not in range(2,10):
playernum = int(raw_input("Welcome to Simultron, How Many Players?"))
listofplayers = []
for x in range(int(playernum)):
listofplayers.append("player"+str(x+1))
for x in listofplayers:
print "Welcome "+x
startstack = 0
while startstack not in range(100,1000000,10):
startstack = int(raw_input("What will the starting stack sizes
be? (100-1000000 increments of 10) "))
bigblind = 19
while bigblind not in range(20,1000,20):
bigblind = int(raw_input("What will the big blind start at?
(20-1000, increments of 20) "))
deck1 = Deck()
table1 = Table(bigblind)
playas = dict((name, Player(stacksize=startstack)) for name in
listofplayers)
table1.fillseats(listofplayers,playas)
table1.postblinds(playas,bigblind,deck1)
if __name__ == "__main__":
main()
[toc] | [next] | [standalone]
| From | John Gordon <gordon@panix.com> |
|---|---|
| Date | 2014-11-04 20:35 +0000 |
| Message-ID | <m3bda8$fui$1@reader1.panix.com> |
| In reply to | #80196 |
C Smith <illusiontechniques@gmail.com> writes: > I was wondering if I could get some feedback on the biggest thing I > have done as an amateur Python coder. Comments. You need a *lot* more comments. Like, every line or two of code should have a comment explaining what is being accomplished. Seriously. Every line or two. Some blank lines wouldn't hurt either. Also it would be nice to define some of the terms you're using. What is a blind? What does "in front" mean? What is a "muck hand"? -- John Gordon Imagine what it must be like for a real medical doctor to gordon@panix.com watch 'House', or a real serial killer to watch 'Dexter'.
[toc] | [prev] | [next] | [standalone]
| From | sohcahtoa82@gmail.com |
|---|---|
| Date | 2014-11-04 16:09 -0800 |
| Message-ID | <19b75713-78cd-4dad-976d-096653c058de@googlegroups.com> |
| In reply to | #80232 |
On Tuesday, November 4, 2014 12:35:32 PM UTC-8, John Gordon wrote: > C Smith <illusiontechniques@gmail.com> writes: > > > I was wondering if I could get some feedback on the biggest thing I > > have done as an amateur Python coder. > > Comments. > > You need a *lot* more comments. > > Like, every line or two of code should have a comment explaining what is > being accomplished. Seriously. Every line or two. > > Some blank lines wouldn't hurt either. > > Also it would be nice to define some of the terms you're using. What is > a blind? What does "in front" mean? What is a "muck hand"? > > -- > John Gordon Imagine what it must be like for a real medical doctor to > gordon@panix.com watch 'House', or a real serial killer to watch 'Dexter'. A "blind" is a required bet that the two people sitting to the left of the button have to make before a hand begins. The first player pays the small blind and the second player pays the big blind, which is double the small blind. For tournament games, the blinds increase periodically. Mucking a hand means to throw your cards away without revealing them. In professional Poker, you typically give them to the dealer. "In front" just refers to table position which determines play order.
[toc] | [prev] | [next] | [standalone]
| From | C Smith <illusiontechniques@gmail.com> |
|---|---|
| Date | 2014-11-04 22:23 -0800 |
| Message-ID | <mailman.15478.1415168622.18130.python-list@python.org> |
| In reply to | #80236 |
>Jean-Michel wrote: >replace > if left_to_act is None: > left_to_act = [] > self.left_to_act = left_to_act >by > self.left_to_act = left_to_act or [] I read that with 2.7 that I had to initialize class variables to immutable types. I think because I was working with the lists before they had been altered and were still empty lists. I will mess around tomorrow with the classes you suggested as I have yet to make use of decorators. Thanks. I will work on putting some more comments in as well. On Tue, Nov 4, 2014 at 4:09 PM, <sohcahtoa82@gmail.com> wrote: > On Tuesday, November 4, 2014 12:35:32 PM UTC-8, John Gordon wrote: >> C Smith <illusiontechniques@gmail.com> writes: >> >> > I was wondering if I could get some feedback on the biggest thing I >> > have done as an amateur Python coder. >> >> Comments. >> >> You need a *lot* more comments. >> >> Like, every line or two of code should have a comment explaining what is >> being accomplished. Seriously. Every line or two. >> >> Some blank lines wouldn't hurt either. >> >> Also it would be nice to define some of the terms you're using. What is >> a blind? What does "in front" mean? What is a "muck hand"? >> >> -- >> John Gordon Imagine what it must be like for a real medical doctor to >> gordon@panix.com watch 'House', or a real serial killer to watch 'Dexter'. > > A "blind" is a required bet that the two people sitting to the left of the button have to make before a hand begins. The first player pays the small blind and the second player pays the big blind, which is double the small blind. For tournament games, the blinds increase periodically. > > Mucking a hand means to throw your cards away without revealing them. In professional Poker, you typically give them to the dealer. > > "In front" just refers to table position which determines play order. > -- > https://mail.python.org/mailman/listinfo/python-list
[toc] | [prev] | [standalone]
Back to top | Article view | comp.lang.python
csiph-web