def __init__(self):
# Initialize window variables and several labels
pygame.init()
self.size = self.width, self.height = screenWidth, screenHeight
self.white = 255, 255, 255
self.screen = pygame.display.set_mode(self.size)
# Various screen fonts and labels
self.byeFont = pygame.font.SysFont("freeserif", 100)
self.winFont = pygame.font.SysFont("freeserif", 50)
self.scoreKeeper = pygame.font.SysFont("freeserif", 25)
self.wait = self.winFont.render(
"Player 2 has not connected, please wait...", 1, (0, 0, 0))
self.bye = self.byeFont.render("Goodbye!", 1, (0, 0, 0))
self.lost = self.winFont.render("Game Server Connection Lost.", 1,
(0, 0, 0))
# Setup game mode and difficulty
self.player_num = 0
self.connected = 0
self.setup = Setup()
self.mode, self.diff, self.player_img, self.ball_img = self.setup.run_setup(
)
### Check chosen mode ###
# If quit occurred, leave game
if self.mode == 0:
self.goodbye()
# If player want to play computer, set that up
elif self.mode == 1:
self.player_num = 1
self.connected = 1
self.player = Player(self.player_num, self.player_img)
spriteGroup.add(self.player)
self.computer = Computer(self.diff, self.player_img)
self.ball = Ball(self.player, self.diff, self.ball_img,
self.computer)
spriteGroup.add(self.computer)
# If mode 2 selected, set a variable for other score
elif self.mode == 2:
self.other_score = 0
self.player = Player(self.player_num, self.player_img)
self.ball = Ball(self.player, self.diff, self.ball_img)
spriteGroup.add(self.player)
# Initialize other player attributes
self.barWidth = 30
self.barHeight = 80
self.other_img = pygame.image.load(self.player_img)
self.other_img = pygame.transform.scale(
self.other_img, (self.barWidth, self.barHeight))
self.other_rect = self.other_img.get_rect()
self.other_rect.x = -50
self.other_rect.y = 900
def update(self, particle, w, c1, c2):
for i in range(len(self.position)):
val = w * self._velocity[i] + c1 * random() * Setup.xor(
self._bestGlobal[i], self.position[i]) + c2 * random(
) * Setup.xor(particle.position[i], particle.bestPersonal[i])
self._velocity[i] = val
for i in range(len(self._velocity)):
if random() < Setup.sigmoid(self._velocity[i]).real:
self.position[i] = particle.position[i]
def __init__(self,
playerId,
board,
players,
setup='random',
discard='random',
rob='random',
trade='none',
build='best'):
self.Setup = Setup(setup, playerId, board, players)
self.Discard = Discard(discard, playerId, board, players)
self.Rob = Rob(rob, playerId, board, players)
self.Trade = Trade(trade, playerId, board, players)
self.Build = Build(build, playerId, board, players)
def __init__(self):
self._s = Setup()
length = len(self._s.getSet())
# randomly generate byte array
self.position = []
for i in range(length):
if random() > 0.5:
self.position.append(0)
else:
self.position.append(1)
# generate the velocity
self._velocity = [random() for i in range(length)]
# define best global,best neighbor and best personal
self._bestGlobal = None
self.bestPersonal = self.position
self._bestFitness = self.fitness()
def __init__(self, imgFName='img', parent=None):
QWidget.__init__(self, parent=None)
self.palette = QPalette()
self.cwd = os.getcwd()
self.setup = Setup(os.path.join(self.cwd, 'SetupData'))
self.detectors = self.setup.detectors
self.motors = self.setup.motors
self.scalers = self.setup.scalers
self.imgFName = imgFName
self.vblayout = QVBoxLayout(self)
self.mainDock = DockArea(self, parent)
self.vblayout.addWidget(self.mainDock)
self.imageFlag = 0
self.pdIn = False
self.beamIn = False
self.mirrorIn = False
self.align = True
self.delay = 0.1
self.detPV = 'None'
self.detParDock = Dock('Detector Parameters', size=(1, 1))
self.imgDock = Dock('Image', size=(1, 10))
self.mainDock.addDock(self.imgDock, 'left')
self.mainDock.addDock(self.detParDock, 'left')
self.mainDock.moveDock(self.imgDock, 'bottom', self.detParDock)
self.create_imgDock()
self.create_detParDock()
self.fileWatcher = FileWatcher()
def main():
print "---------Iniciando Dragon Ball Z Beat'm All--------------"
Setup()
print "-----------Configuracion inicial, Terminada--------------"
diccionarioEstados = {
"PantallaInicio": States.PantallaInicio("Pantalla de Inicio", "Menu"),
"Menu": States.MenuPrincipal("Menu principal", "Prologo"),
"Prologo": States.Prologo("Prologo", "Tutorial"),
"Tutorial": States.LevelTutorial("Tutorial", "Level1"),
"Level1": States.Level1("Level 1", "QUIT"),
"Interludio1": None,
"LevelFinal": States.LevelFinal("Level Final", "Menu"),
"Interludio2": None,
"Level3": None,
"Interludio3": None,
"Creditos": None,
"GameOver": None,
"Victoria": None
}
diccionarioEstados["Tutorial"].setup()
controlador = Control()
controlador.preparar_estados(diccionarioEstados,
diccionarioEstados["LevelFinal"])
print "-----------Sistema de estados, Inicializado--------------"
controlador.main()
print "-----------------Aplicaion Finalizada--------------------"
def initUI(self):
# Add the widgets
self._setup = Setup()
self._negf_para = Negf_para()
self._species = species()
self._misc = Misc()
self._grids = Grids()
self._mdscf = Mdscf()
self._io = IOcontrol()
self._configuration = Configuration()
self._default_input = default_input_para()
#self._widgets = [self._setup, self._misc, self._mdscf, self._io,
# self._species, self._grids, self._default_input,
# self._configuration, self._negf_para]
self._widgets = [
self._setup, self._misc, self._mdscf, self._io, self._species,
self._grids, self._default_input, self._negf_para
]
# Main layout
#layout = QtGui.QVBoxLayout()
layout = QtGui.QGridLayout()
layout.setSpacing(10)
self.setLayout(layout)
# Setup Groupbox
savebtn = QtGui.QPushButton('Save')
self.savedir = QtGui.QLineEdit(os.getcwd())
choosedir = QtGui.QPushButton('...')
choosedir.clicked.connect(self.selectdir)
savebtn.clicked.connect(self.save)
layout.addWidget(savebtn, 1, 0, 1, 1)
layout.addWidget(self.savedir, 1, 1, 1, 4)
layout.addWidget(choosedir, 1, 5, 1, 1)
form_layout = QtGui.QTabWidget()
layout.addWidget(form_layout, 2, 0, 1, 10)
#form_layout = QtGui.QTabWidget(group_box)
form_layout.addTab(self._setup, self.tr('Setup'))
form_layout.addTab(self._mdscf, self.tr('MD SCF'))
form_layout.addTab(self._grids, self.tr('Grids'))
form_layout.addTab(self._negf_para, self.tr('NEGFctrl'))
form_layout.addTab(self._species, self.tr('Species'))
form_layout.addTab(self._misc, self.tr('Misc'))
form_layout.addTab(self._io, self.tr('IO'))
form_layout.addTab(self._configuration, self.tr('Configuration'))
form_layout.currentChanged.connect(self.configurationChanged)
# self.connect(form_layout, QtCore.SIGNAL("currenChanged(int)"), self.configurationChanged)
self.setGeometry(2000, 2000, 750, 750)
self.setWindowTitle('NCSU RMG-NEGF GUI')
self.show()
def main():
# Create Setup object
bus = Setup()
# Create Sensor object
sense = Sensor()
# Setup the SPI bus
bus.busSetup()
while True:
# Retrieve the SPI bus
channel_1, channel_2 = bus.getBus()
# Setup the sensors
sense.setTemperatureInC(channel_1)
sense.setTemperatureInF(channel_1)
sense.setLuminosity(channel_2)
# Fetch temperature in degrees C
temperatureC = sense.getTemperatureInC()
# Fetch temperature in degrees F
temperatureF = sense.getTemperatureInF()
# Fetch luminosity as a percentage
luminosity = sense.getLuminosity()
# print output
print(
"Temperature in degrees Celsius: {:5.2f} deg".format(temperatureC))
print("Temperature in degrees Fahrenheit: {:5.2f} deg".format(
temperatureF))
print("Luminosity as a percentage: {:6.2f} %".format(luminosity))
print("\n")
# time delay between readings
sleep(1)
def main():
# Create Setup object
bus = Setup()
# Create Sensor object
sense = Sensor()
# Setup the SPI bus
bus.busSetup()
while True:
# Retrieve the SPI bus
channel_1, channel_2 = bus.getBus()
# Setup the sensors
sense.setTemperatureInC(channel_1)
sense.setTemperatureInF(channel_1)
sense.setLuminosity(channel_2)
# Fetch temperature in degrees C
temperatureC = sense.getTemperatureInC()
# Fetch temperature in degrees F
temperatureF = sense.getTemperatureInF()
# Fetch luminosity as a percentage
luminosity = sense.getLuminosity()
# Open file for output
outfile = open(r"/home/pi/share/data.txt", "a")
# Write temperature and luminosity readings to file
outfile.write("\n{:5.2f}\t\t{:6.2f}\t\t{}".format(
temperatureC, luminosity, datetime.now()))
# Close file stream
outfile.close() # Close the input file
# time delay between readings
sleep(30)
class Strategy:
Setup = None
# 'random' - randomly places initial settlements and roads
Discard = None
# 'random' - randomly discard floor(half) cards when over 8 cards when 7 rolls
Rob = None
# 'random' - randomly places robber and robs randomly from enemy if able
Trade = None
# 'none' - never trades with anyone
Build = None
# 'best' - builds something that leaves the players total points highest
def __init__(self,
playerId,
board,
players,
setup='random',
discard='random',
rob='random',
trade='none',
build='best'):
self.Setup = Setup(setup, playerId, board, players)
self.Discard = Discard(discard, playerId, board, players)
self.Rob = Rob(rob, playerId, board, players)
self.Trade = Trade(trade, playerId, board, players)
self.Build = Build(build, playerId, board, players)
def play(self, do):
do = do.lower()
if do == 'setup':
self.Setup.go()
elif do == 'discard':
self.Discard.go()
elif do == 'rob':
self.Rob.go()
elif do == 'trade':
self.Trade.go()
elif do == 'build':
self.Build.go()
def __init__(self):
super().__init__()
self.actions = [acpc.ActionType.FOLD, acpc.ActionType.CALL, acpc.ActionType.RAISE]
self.action_probabilities = [0] * 3
self.action_probabilities[0] = 0.3 # fold probability
self.action_probabilities[1] = (1 - self.action_probabilities[0]) * 0.5 # call probability
self.action_probabilities[2] = (1 - self.action_probabilities[0]) * 0.5 # raise probability
self.bets = None
self.contrib = None
self.state_controller = ESMCCFRPlusTraining(rules=Leduc(),
setup=Setup(stack_size=10, big_blind=1, small_blind=1),
blueprint='strategy-leduc-10-1-1.csv', abstracting=False)
self.startingplayer = 0
self.player = None
def main():
rules = Leduc()
setup = Setup(small_blind=1, big_blind=1, stack_size=10)
pov = Human(rules, setup)
opponent = ESMCCFRPlusTraining(rules, setup, 'strategy-leduc-10-1-1.csv')
contest = Contest(rules=rules,
setup=setup,
logger=Logger(rules=rules, setup=setup, players=(pov, opponent)),
players=(pov, opponent))
games = 0
total = 0
for _ in range(100):
total += contest.play()
games += 1
print("@%d %s Total: (%.2f avg) %d" % (
games, pov, (1.0 *total) / games, total))
def scan():
from Config import Config
from Setup import Setup
import Params as params
table = 'hlt2_mon'
config = Config(top=params.home,have_archive=True)
Setup(config.config(),credentials=params.credentials,table=table) \
.createDirectories().createTables().printSummary()
hlt2 = Scanner(config.config(),mondb=params.mondb,rundb=params.rundb,table=table)
hlt.prepareWork = makeXML
log(INFO, 'last Run Ready: %d'%(hlt2.lastRunReady(),))
while 1:
hlt2.populateFromConditions()
hlt2.createWork()
hlt2.checkDone()
hlt2.checkFailed()
hlt2.dump()
time.sleep(5)
def main():
parser = argparse.ArgumentParser(
description='Determine PacBio read support for gaps in scaffolds',
usage=usage())
# Main arguments
parser.add_argument('scaffolds',
action='store',
help='The input scaffolds in Fasta format')
parser.add_argument('subreads',
action='store',
help='The PacBio subreads in BAM format')
parser.add_argument('-t', '--threads', dest='threads', type=int, \
help='Number of threads to use for multi-threaded processes, default=1', default=1)
# Arguments for Setup
setup_args = parser.add_argument_group('Setup')
setup_args.add_argument('-n', '--min_gap', dest='min_gap', type=int, default=200, \
help='Minimum number of consecutive Ns to be considered a gap, default=200')
setup_args.add_argument('-x', '--max_gap', dest='max_gap', type=int, default=1000000, \
help='Maximum number of consecutive Ns to be considered a gap, default=Inf')
setup_args.add_argument('-f', '--flank_size', dest='flank_size', type=int, default=1000, \
help='Number of extracted bases flanking gaps and scaffold ends, default=1000')
# Arguments for Support
support_args = parser.add_argument_group('Support')
support_args.add_argument('-b', '--blasr', dest='blasr', type=str, \
help='Parameters to pass to BLASR', default='')
support_args.add_argument('-d', '--min_reads', dest='min_reads', type=int, \
help='The minimum number of reads required to support a gap', default=5)
support_args.add_argument('-w', '--wiggle', dest='wiggle', type=int, \
help='The percent deviation allowed from predicted gap size', default=0.5)
# Arguments for Assembly
assembly_args = parser.add_argument_group('Assembly')
assembly_args.add_argument('-m', '--minimap', dest='minimap', \
help='Parameters to pass to Minimap', default='-Sw5 -L100 -m0')
assembly_args.add_argument('-a', '--miniasm', dest='miniasm', \
help='Parameters to pass to Miniasm', default='')
assembly_args.add_argument('-r', '--racon', dest='racon', \
help='Parameters to pass to Racon', default='')
# Parse the arguments
args = parser.parse_args()
# Initialize classes
setup = Setup()
support = Support()
assembly = Assembly()
placement = Placement()
# Check for save point
try:
save = open('jelly2.save', 'r').read()
print "Found save point:", save
except IOError:
write_save('setup')
# Run Setup
if check_save('setup'):
setup.run(args)
write_save('mapping')
# Run Support
if check_save('mapping'):
support.mapping(args)
write_save('sorting')
if check_save('sorting'):
support.sorting(args)
write_save('indexing')
if check_save('indexing'):
support.indexing(args)
write_save('support')
if check_save('support'):
support.find_support(args)
write_save('assembly')
# Run Assembly
if check_save('assembly'):
assembly.assemble_gaps(args)
write_save('placement')
# Run Placement
if check_save('placement'):
placement.load_data(args)
placement.fill_gaps()
from Setup import Setup
from Game import Game
import sys
if __name__ == '__main__':
config_file = sys.argv[1]
ship_info = {}
with open(config_file) as config:
size = config.readline()
row, col = size.split()
for line in config:
(key, val) = line.split()
ship_info[key] = val
s = Setup(row, col, ship_info)
# Game setup
rows, cols, ship_info, p1_name, p1_board, p2_name, p2_board = s.setup()
# Game begins
battle = Game(p1_name, p1_board, p2_name, p2_board, rows, cols,
**ship_info)
battle.play()
class gameSpace(object):
# Initializes all necessary variable
def __init__(self):
# Initialize window variables and reactor
pygame.init()
self.size = self.width, self.height = screenWidth, screenHeight
self.white = 255, 255, 255
self.screen = pygame.display.set_mode(self.size)
# Various screen fonts and labels
self.byeFont = pygame.font.SysFont("freeserif", 100)
self.winFont = pygame.font.SysFont("freeserif", 50)
self.scoreKeeper = pygame.font.SysFont("freeserif", 25)
self.wait = self.winFont.render(
"Player 2 has not connected, please wait...", 1, (0, 0, 0))
self.bye = self.byeFont.render("Goodbye!", 1, (0, 0, 0))
self.lost = self.winFont.render("Game Server Connection Lost.", 1,
(0, 0, 0))
# Setup game mode, difficulty, chosen sprite images
self.player_num = 0
self.connected = 0
self.setup = Setup()
self.mode, self.diff, self.player_img, self.ball_img = self.setup.run_setup(
)
### Check chosen mode ###
# If quit occurred, leave game
if self.mode == 0:
self.goodbye()
# If player want to play computer, set 1 player up
elif self.mode == 1:
self.player_num = 1
self.connected = 1
self.player = Player(self.player_num, self.player_img)
spriteGroup.add(self.player)
self.computer = Computer(self.diff, self.player_img)
spriteGroup.add(self.computer)
self.ball = Ball(self.player, self.diff, self.ball_img,
self.computer)
# If mode 2 selected, set a variable for other player
elif self.mode == 2:
# Your player inits
self.player = Player(self.player_num, self.player_img)
self.ball = Ball(self.player, self.diff, self.ball_img)
spriteGroup.add(self.player)
# Initialize other player attributes
self.other_score = 0
self.barWidth = 30
self.barHeight = 80
self.other_img = pygame.image.load(self.player_img)
self.other_img = pygame.transform.scale(
self.other_img, (self.barWidth, self.barHeight))
self.other_rect = self.other_img.get_rect()
# place off screen for the time being
self.other_rect.x = -50
self.other_rect.y = 900
# Runs one game loop
def play(self):
# If playing online but P2 hasn't connected, wait
if self.connected == 0:
self.screen.fill(self.white)
self.wait_screen()
# else, do game loop
else:
# Set white background for pong math
self.screen.fill(self.white)
# check for system exit
event = pygame.event.poll()
if event.type == pygame.QUIT:
if self.mode == 1:
sys.exit()
elif self.mode == 2:
os._exit()
# Draw everything for mode 1
if self.mode == 1:
self.player.keyHandler()
self.ball.move()
self.ball.collision(spriteGroup)
self.ball.draw()
self.player.draw()
self.player.goal()
self.computer.move(self.ball.get_x(), self.ball.get_y())
self.computer.draw()
self.computer.goal()
# Draw everything for mode 2
else:
self.player.keyHandler()
self.ball.move()
self.ball.collision(spriteGroup)
self.ball.draw()
self.player.draw()
self.player.goal()
# Draw other player, blit other score
screen.blit(self.other_img, self.other_rect)
scoreBlit = self.scoreKeeper.render(self.other_score, 1,
(0, 0, 0))
# Blit score in proper place
if self.player_num == 2:
screen.blit(scoreBlit, (32, 16))
else:
screen.blit(scoreBlit, (968, 16))
# Check if other player won
if self.game_over():
self.winner()
# Display all blits
pygame.display.flip()
# Wait Screen
def wait_screen(self):
screen.blit(self.wait, (150, 400))
pygame.display.flip()
# Function receives other player position
def update(self, data):
# If data is P1 message, set to P1
if data == "1":
self.set_player(1)
# If data is P2 message, set to P2
elif data == "2":
self.set_player(2)
# Begin game if player 2 has connected
elif data == "3":
self.connected()
# Otherwise, parse other player data
else:
info = data.split()
self.other_rect.x = int(info[0])
self.other_rect.y = int(info[1])
self.other_score = info[2]
self.ball.set_pos(int(info[3]), int(info[4]), float(info[5]))
# Function sets player number, cannot start mode 2 without this
def set_player(self, num):
self.player_num = num
# If player_num is 2, begin game
if self.player_num == 2:
self.connected = 1
# Set x position according to player number
self.player.set_pos(self.player_num)
# Indicates player 2 is connected
def connected(self):
self.connected = 1
# Function returns current player position to send
def player_pos(self):
return self.ball.get_full_pos()
# Returns game mode for main
def get_mode(self):
return self.mode
# Indicates if game is over
def game_over(self):
# If playing computer, check those scores
if self.mode == 1:
if self.player.get_score() == 10 or self.computer.get_score(
) == 10:
return 1
else:
return 0
# If playing other player, check those scores
elif self.mode == 2:
if self.player.get_score() == 10 or self.other_score == 10:
return 1
else:
return 0
# function displays winner screen
def winner(self):
# Winner variable
winner = 0
# If playing computer, check those scores
if self.mode == 1:
if self.player.get_score() > self.computer.get_score():
winner = 1
else:
winner = 2
# If playing other player, check those scores
elif self.mode == 2:
if self.player.get_score() > self.other_score:
winner = 1
else:
winner = 2
self.screen.fill(self.white)
self.win = self.winFont.render(
"Player " + str(winner) + " won the game!", 1, (0, 0, 0))
screen.blit(self.win, (250, 300))
# Display for 3 seconds then leave
pygame.display.flip()
time.sleep(3)
self.goodbye()
# function displays lost connection screen
def connection_lost(self):
# Lost connection and goodbye
self.screen.fill(self.white)
screen.blit(self.lost, (200, 300))
pygame.display.flip()
time.sleep(3)
self.goodbye()
# Screen say good bye as you exit
def goodbye(self):
self.screen.fill(self.white)
screen.blit(self.bye, (300, 300))
pygame.display.flip()
time.sleep(3)
os._exit()
def __init__(self):
Setup()
Input()
from Setup import Setup
setup = Setup()
#define analysis regions
from StopsDilepton.analysis.regions import regions1D, regions3D
regions = regions3D
from StopsDilepton.analysis.MCBasedEstimate import MCBasedEstimate
from StopsDilepton.analysis.DataDrivenDYEstimate import DataDrivenDYEstimate
from StopsDilepton.analysis.DataDrivenTTZEstimate import DataDrivenTTZEstimate
#from collections import OrderedDict
bkgEstimators = [
#DataDrivenDYEstimate(name='DY-DD', cacheDir=setup.cacheDir),
#DataDrivenTTZEstimate(name='TTZ-DD', cacheDir=setup.cacheDir),
MCBasedEstimate(name='DY', sample=setup.sample['DY'],
cacheDir=None), #setup.defaultCacheDir()),
MCBasedEstimate(name='TTJets',
sample=setup.sample['TTJets'],
cacheDir=None), #setup.defaultCacheDir()),
MCBasedEstimate(name='TTZ', sample=setup.sample['TTZ'],
cacheDir=None), #setup.defaultCacheDir()),
MCBasedEstimate(name='other', sample=setup.sample['other'],
cacheDir=None), #setup.defaultCacheDir()),
]
nList = [e.name for e in bkgEstimators]
assert len(list(set(nList))) == len(
nList), "Names of bkgEstimators are not unique: %s" % ",".join(nList)
class Particle:
def __init__(self):
self._s = Setup()
length = len(self._s.getSet())
# randomly generate byte array
self.position = []
for i in range(length):
if random() > 0.5:
self.position.append(0)
else:
self.position.append(1)
# generate the velocity
self._velocity = [random() for i in range(length)]
# define best global,best neighbor and best personal
self._bestGlobal = None
self.bestPersonal = self.position
self._bestFitness = self.fitness()
def fitness(self):
fit = 0
set1 = set()
set2 = set()
l = list(self._s.getSet())
for i in range(len(self._s.getSet())):
if self.position[i] == 0:
set1.add(l[i])
else:
set2.add(l[i])
for i in self._s.getSubSets():
if i.issubset(set1) or i.issubset(set2):
fit -= 1
return fit
def setBestGlobal(self, particle):
self._bestGlobal = particle.position
def getBestGlobal(self):
return self._bestGlobal
def setBestPersonal(self, particle):
self.bestPersonal = particle.position
def getBestPersonal(self):
return self.bestPersonal
def getPosition(self):
return self.position
def evaluate(self):
f = self.fitness()
if (f > self._bestFitness):
self.bestPersonal = self.position
self._bestFitness = f
def update(self, particle, w, c1, c2):
for i in range(len(self.position)):
val = w * self._velocity[i] + c1 * random() * Setup.xor(
self._bestGlobal[i], self.position[i]) + c2 * random(
) * Setup.xor(particle.position[i], particle.bestPersonal[i])
self._velocity[i] = val
for i in range(len(self._velocity)):
if random() < Setup.sigmoid(self._velocity[i]).real:
self.position[i] = particle.position[i]
def setup():
password = ''
if platform == 'darwin' or platform == 'linux':
password = getpass()
setup = Setup()
setup.setup(password)
from AvailableBets import AvailableBets
from Setup import Setup
# throw error when it's not my turn
available_bets = AvailableBets(Setup(small_blind=2, big_blind=5,
stack_size=11))
exception_thrown = False
try:
available_bets.get_bets_as_numbers(6, 5)
except:
exception_thrown = True
assert exception_thrown
exception_thrown = False
try:
available_bets.get_bets_by_action_type(6, 5)
except:
exception_thrown = True
assert exception_thrown
# throw error when I'm out of chips
available_bets = AvailableBets(Setup(small_blind=2, big_blind=5,
stack_size=11))
exception_thrown = False
try:
available_bets.get_bets_as_numbers(8, 7)
except:
exception_thrown = True
assert exception_thrown
def loadSetup(self, filename):
with open(filename) as f:
return Setup(json.load(f))
subRFileObj = open("Modules/SubredditData/" + subr, 'a')
subRFileObj.write("$" + str(outputFileList))
subRFileObj.close()
Log.SubredditLog(subr)
#Nap for 9 seconds
sleep(9)
#Begin Main Loop
if __name__ == '__main__':
print("\nBegin Bot_REGOD")
print("v1.0.0")
print("IceCereal\n")
sleep(1)
setup = Setup()
subreddits = setup.returnSubreddits()
Log = Log()
Log.Log("BEGIN: Bot_REGOD")
PopularityIndex = Popularity()
reddit = createRedditInstance()
main(reddit, subreddits)
def __init__(self,
id,
author=defaults.author,
version=defaults.version,
license=License(defaults.license),
install_requires=None,
compat_zenoss_vers=">=4.2",
prev_zenpack_name="",
zProperties=None,
deviceClasses=None,
relationships=None,
opts=Opts(),
):
self.id = id
self.opts = opts
self.destdir = DirLayout(self, opts.prefix)
self.namespace = id
self.deviceClasses = {}
self.components = {}
self.relationships = {}
self.componentJSs = {}
self.zproperties = {}
self.author = author
self.version = version
self.license = license
self.prepname = prepId(id).replace('.', '_')
if install_requires:
if isinstance(install_requires, basestring):
self.install_requires = [install_requires]
else:
self.install_requires = list(install_requires)
else:
self.install_requires = []
self.compat_zenoss_vers = compat_zenoss_vers
self.prev_zenpack_name = prev_zenpack_name
packages = []
parts = self.id.split('.')
for i in range(len(parts)):
packages.append('.'.join(parts[:i+1]))
self.packages = packages
self.namespace_packages = packages[:-1]
self.configure_zcml = Configure(self)
self.utils = UtilsTemplate(self)
self.setup = Setup(self)
self.rootinit = RootInit(self)
self.zenpackUI = ZenPackUI(self)
if zProperties:
for zp in zProperties:
self.addZProperty(**zp)
if deviceClasses:
for dc in deviceClasses:
self.addDeviceClass(**dc)
if relationships:
for rel in relationships:
self.addRelation(**rel)
class ZenPack(object):
def __init__(self,
id,
author=defaults.author,
version=defaults.version,
license=License(defaults.license),
install_requires=None,
compat_zenoss_vers=">=4.2",
prev_zenpack_name="",
zProperties=None,
deviceClasses=None,
relationships=None,
opts=Opts(),
):
self.id = id
self.opts = opts
self.destdir = DirLayout(self, opts.prefix)
self.namespace = id
self.deviceClasses = {}
self.components = {}
self.relationships = {}
self.componentJSs = {}
self.zproperties = {}
self.author = author
self.version = version
self.license = license
self.prepname = prepId(id).replace('.', '_')
if install_requires:
if isinstance(install_requires, basestring):
self.install_requires = [install_requires]
else:
self.install_requires = list(install_requires)
else:
self.install_requires = []
self.compat_zenoss_vers = compat_zenoss_vers
self.prev_zenpack_name = prev_zenpack_name
packages = []
parts = self.id.split('.')
for i in range(len(parts)):
packages.append('.'.join(parts[:i+1]))
self.packages = packages
self.namespace_packages = packages[:-1]
self.configure_zcml = Configure(self)
self.utils = UtilsTemplate(self)
self.setup = Setup(self)
self.rootinit = RootInit(self)
self.zenpackUI = ZenPackUI(self)
if zProperties:
for zp in zProperties:
self.addZProperty(**zp)
if deviceClasses:
for dc in deviceClasses:
self.addDeviceClass(**dc)
if relationships:
for rel in relationships:
self.addRelation(**rel)
@memoize
def addDeviceClass(self, *args, **kwargs):
dc = DeviceClass(self, *args, **kwargs)
return dc
@memoize
def addComponentType(self, *args, **kwargs):
c = Component(self, *args, **kwargs)
return c
def addRelation(self, *args, **kwargs):
r = Relationship(self, *args, **kwargs)
return r
def addZProperty(self, name, type='string', default='', Category=None):
if type == 'string':
if not default.startswith('\''):
default = '\'' + default
if len(default) == 1:
default = default + '\''
if not default.endswith('\''):
default = default + '\''
self.zproperties[name] = (name, default, type, Category)
def registerComponent(self, component):
self.components[component.id] = component
def registerRelationship(self, relationship):
self.relationships[relationship.id] = relationship
def registerDeviceClass(self, deviceClass):
self.deviceClasses[deviceClass.id] = deviceClass
#Add the ComponentJS pieces when we are at it.
cjs = ComponentJS(deviceClass)
self.componentJSs[cjs.name] = cjs
def __repr__(self):
return "%s \n\tAUTHOR: %s\n\tVERSION: %s\n\tLICENSE: %s" \
% (self.id, self.author, self.version, self.license)
def updateGitTemplates(self): # pragma: no cover
# Create the git repo
repo = Repo.init(self.destdir .path)
try:
repo.commit()
except:
repo.index.commit('Initial Commit from zpg')
#Update the repo
repo.index.add([self.destdir .path+'/Templates'])
if repo.is_dirty():
repo.index.commit('zpg: Committed Template changes')
def write(self):
# Write the destination folders
self.destdir.write()
# Write the base setup.py
self.setup.write()
# Write configure.zcml
self.configure_zcml.write()
# Create the components
for component in self.components.values():
component.write()
for cjs in self.componentJSs.values():
cjs.write()
self.zenpackUI.write()
#Create the root level __init__.py file
self.rootinit.write()
# Create a utils file.
self.utils.write()
self.updateGitTemplates()
'''Main Prog'''
#Load functions
from Reader import Reader
from Setup import Setup
from Game import Game
from Applier import Applier
from Win import Win
from End import End
Win = 0
Rules = -1
Turn = 0 #Whos Turn is it?
[Card_set, Players, Starting_Hand, Rule_set] = Reader()
while True:
[Player_lst, Master] = Setup(Card_set, Players, Starting_Hand)
while Win == 0:
Game(Master, Player_lst, Turn, Rule_set) #calls Applier
Win() #qick check of Master
End()
# Update the expected value
value += player_strategy[bet_index] * va
for bet_index in range(len(possible_bets)):
# Update the cumulative regret of each bet
strategy.regret_sum[bet_index] += value_bet[bet_index] - value
return value
elif player_turn == other_player:
# Sample one bet and increment bet counter
bet_index = self.get_random_bet(player_strategy)
bet = possible_bets[bet_index]
strategy.count[bet_index] += 1
memento = state.update(bet)
val = self.traverse_ESMCCFR(state, player)
state.reverse_update(memento)
return val
else:
raise Exception('How did we get here? There are no other players')
if __name__ == "__main__":
# cProfile.runctx("ESMCCFR_P(100000)",globals(),locals())
ESMCCFR_P = ESMCCFR_P(rules=Leduc(),
setup=Setup(stack_size=10,
big_blind=1,
small_blind=1),
abstracted=False)
ESMCCFR_P.run(20000)
