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)