def calc_fitness(individual): fitness = 0 json_file = os.path.dirname(os.path.realpath(__file__)) + '/test.json' with open(json_file, 'w') as fp: json.dump(individual, fp, ensure_ascii=False) bot1 = os.path.dirname(os.path.realpath(__file__)) + '/xouba.py' bot2 = os.path.dirname(os.path.realpath(__file__)) + '/../stockfishbot.py' # bot3 = os.path.dirname(os.path.realpath(__file__)) + '/../randombot.py' p1 = Pool(bot1=[bot1, '-j', json_file], bot2=[bot2], debug=True) p2 = Pool(bot1=[bot1, '-j', json_file], bot2=[bot2, '-l', '2'], debug=True) # p2 = Pool(bot1=[bot1, '-j', json_file], bot2=bot2, debug=True) # p3 = Pool(bot1=[bot1, '-j', json_file], bot2=bot3, debug=True) matches = [p1, p2] for p in matches: for _ in range(15): p.match() if p.last_result == p.RESULT_WIN_WHITE: fitness += 5 elif p.last_result == p.RESULT_DRAW: fitness += 1 p.reset_chess_board() del p return fitness
def get_blockchain_info(self): try: data = {'pool': Pool(self.pool_id_or_sym, invert=self.invert)} data['pool_object'] = data['pool']['object'] data['pool_name'] = Asset(data['pool_object']['share_asset']).symbol data['asset_x'] = Asset(data['pool_object']['asset_a']) data['asset_y'] = Asset(data['pool_object']['asset_b']) data['amount_x'] = Amount(int(data['pool_object']['balance_a'])/10**data['asset_x'].precision, data['asset_x']) data['amount_y'] = Amount(int(data['pool_object']['balance_b'])/10**data['asset_y'].precision, data['asset_y']) self.amount_x = data['amount_x'] self.amount_y = data['amount_y'] data['market_ticker_object'] = Market( # python bitshares reverses base and quote base=data['asset_y'], quote=data['asset_x'] ).ticker() data['market_orderbook'] = Market( base=data['asset_y'], quote=data['asset_x'] ).orderbook(50) data['pool_invariant'] = int(data['pool_object']['virtual_value'])/(10**(data['asset_x'].precision + data['asset_y'].precision)) #print(f"Invariant: {data['pool_invariant']}") # python bitshares reverses base and quote data['price_xy'] = Price(base=data['amount_y'], quote=data['amount_x']) data['price_yx'] = Price(base=data['amount_x'], quote=data['amount_y']) pub.sendMessage('update_gui', data=data) except Exception as err: print('Invalid pool selected. Error: {}'.format(err)) pub.sendMessage('invalid_pool')
def bestchallenge_comics(): logger = logging.getLogger(__name__ + '.bestchallenge_comics') url_format = BESTCHALLENGE_LIST_URL + '?page={0}' last_url = url_format.format(999999) with urlfetch.fetch(last_url, cache, 120) as f: html = lxml.html.parse(f) logger.info(last_url) last = html.xpath('//*[@id="content"]//*[contains(concat(" ", @class,' '" "), " paginate ")]//strong[@class="page"]/em/text()') last_html = html last = int(last[0]) def get_html(page): if page == last: return last_html url = url_format.format(page) with urlfetch.fetch(url, cache, 120) as f: logger.info(url) html = lxml.html.parse(f) return html pool = Pool(POOL_SIZE) htmls = pool.map(get_html, xrange(1, last + 1)) for html in htmls: links = html.xpath('//*[@id="content"]//table[@class="challengeList"]' '//td/*[@class="fl"]/a') for a in links: href = a.attrib['href'] query = href[href.index('?') + 1:] title_id = int(werkzeug.urls.url_decode(query)['titleId']) yield title_id, a.xpath('./img/@title')[0]
def __init__(self, pool_path, dfs_site=constants.dk, lineups=[]): self.dfs_site = DFS_Site(dfs_site) self.pool = Pool(pool_path) self.lineups = lineups self.memoized = {} self.start_logging()
class Root(RestController): config = Config() crush = Crush() doc = Doc() mon = Mon() osd = Osd() pool = Pool() request = Request() server = Server() @expose(template='json') def get(self, **kwargs): """ Show the basic information for the REST API This includes values like api version or auth method """ return { 'api_version': 1, 'auth': 'Use "ceph tell mgr restful create_key <key>" to create a key pair, ' 'pass it as HTTP Basic auth to authenticate', 'doc': 'See /doc endpoint', 'info': "Ceph Manager RESTful API server", }
def _given_pool_of_size(self, size: int): self.pool: Pool[int] = Pool( source=MockSource(), mutator=MockMutator(), evaluator=MockEvaluator(), size=size, )
def __init__(self, layer): """Creates renderer for provided map layer. :param layer: The image. :type layer: layer.Layer :param concurrent: The number of tiles to render concurrently. :type concurrent: int """ self.max_zoom = 22 self.size = 256 self.buffer_size = 128 if layer.concurrent: pool_size = multiprocessing.cpu_count() else: pool_size = 1 self.pool = Pool(layer, map_size=self.size, pool_size=pool_size) map = mapnik.Map(256, 256, '+init=epsg:3857') layer.append_to(map) map.zoom_all() self.envelope = map.envelope() self.empty_tile = mapnik.Image(self.size, self.size) self.mercator = SphericalMercator(levels=self.max_zoom + 1, size=self.size)
def __init__( self, job_file="test_job.yaml", client=None, config=None, pool=None, job_config=None, options=[], job_id=None, ): self.config = config or IntegrationTestConfig() self.client = client or Client() self.pool = pool or Pool(self.config, self.client) self.job_id = job_id if job_config is None: job_config_dump = load_test_config(job_file) job_config = job.JobConfig() json_format.ParseDict(job_config_dump, job_config) # apply options for o in options: o(job_config) self.job_config = job_config
def process(self, url): """ Downloads all requested files from specified server """ self.ignored = 0 self.not_selected = 0 self.processed = 0 api = API(url, self.user, self.password) if self.recording_id: recording = api.get(self.recording_id).get("recording") self._download(recording, api, Path(self.out_folder)) return print("Querying server {0}".format(url)) print("Limit is {0}".format(self.limit)) print("Tag mode {0}".format(self.tag_mode)) print("Dates are {0} - {1}".format(self.start_date, self.end_date)) print("Required tags are {0}".format(self.only_tags)) print("Ignore tags are {0}".format(self.ignore_tags)) rows = api.query( limit=self.limit, startDate=self.start_date, endDate=self.end_date, tagmode=self.tag_mode, tags=self.only_tags, ) if self.auto_delete: self.update_file_locations() pool = Pool(self.workers, self._downloader, api, Path(self.out_folder)) for row in rows: pool.put(row) pool.stop()
def test_pool(): pool = Pool(5) logging.debug('queueing work') for i in range(10): pool.add_task(test, i) logging.debug('starting work') pool.start_workers(True) logging.debug('waiting') sleep(5) for result in pool.results(): logging.debug('got result %s', str(result)) logging.debug('cancel unstarted workers') pool.abort() logging.debug('waiting and restarting') pool.start_workers(True) logging.debug('restarted waiting for results') wait_for_results(pool) logging.debug('adding additional workers') for i in range(10, 15): pool.add_task(test, i) wait_for_results(pool) pool.done() """
def _RunInternal(self, jobs): pool = Pool(jobs) test_map = {} # TODO(machenbach): Instead of filling the queue completely before # pool.imap_unordered, make this a generator that already starts testing # while the queue is filled. queue = [] queued_exception = None for test in sorted(self.tests, key=lambda t: t.duration, reverse=True): assert test.id >= 0 test_map[test.id] = test try: command = self.GetCommand(test) except Exception, e: # If this failed, save the exception and re-raise it later (after # all other tests have had a chance to run). queued_exception = e continue timeout = self.context.timeout if ("--stress-opt" in test.flags or "--stress-opt" in self.context.mode_flags or "--stress-opt" in self.context.extra_flags): timeout *= 4 if test.dependency is not None: dep_command = [ c.replace(test.path, test.dependency) for c in command ] else: dep_command = None job = Job(command, dep_command, test.id, timeout, self.context.verbose) queue.append([job])
def __init__( self, job_file="test_stateless_job_spec.yaml", client=None, config=None, pool=None, job_config=None, job_id=None, ): self.config = config or IntegrationTestConfig( pool_file='test_stateless_respool.yaml') self.client = client or Client() self.pool = pool or Pool(self.config, client=self.client) self.job_id = job_id self.entity_version = None self.job_spec = None if job_config is not None: self.job_spec = job_config if job_id is not None: self.job_spec = self.get_spec() if self.job_spec is None: job_spec_dump = load_test_config(job_file) job_spec = stateless.JobSpec() json_format.ParseDict(job_spec_dump, job_spec) self.job_spec = job_spec
def get_object_connection(obj, connection, partition, parser): """ get an object specific connection @param obj - the object type @param connection - the f5 connection to use @param partition - the partition to work with @param parser - our args parser for object specifc items """ if obj == "pool": object_connection = Pool(connection, partition, parser) elif obj == "node": object_connection = Node(connection, partition, parser) elif obj == "virtual_server": object_connection = Virtual_server(connection, partition, parser) elif obj == "ssl_file": object_connection = Ssl_file(connection, partition, parser) elif obj == "ssl_profile": object_connection = Ssl_profile(connection, partition, parser) elif obj == "profile": object_connection = Profile(connection, partition, parser) else: raise Exception("Unknown object {}".format(obj)) return object_connection
def __init__(self, job, updated_job_file=None, client=None, config=None, pool=None, batch_size=None, updated_job_spec=None, roll_back_on_failure=None, max_instance_attempts=None, max_failure_instances=None, start_paused=None, ): self.config = config or IntegrationTestConfig() self.client = client or Client() self.pool = pool or Pool(self.config) if updated_job_spec is None: job_config_dump = load_test_config(updated_job_file) updated_job_spec = JobSpec() json_format.ParseDict(job_config_dump, updated_job_spec) self.updated_job_spec = updated_job_spec self.batch_size = batch_size or 0 self.roll_back_on_failure = roll_back_on_failure or False self.max_instance_attempts = max_instance_attempts or 0 self.max_failure_instances = max_failure_instances or 0 self.start_paused = start_paused or False self.job = job
def create_pool(self, miner): """ miner - instance of Miner that is creating a pool """ assert isinstance(miner, Miner) miner.pool = Pool(miner) self.P.append(miner.pool)
def __insertPools(self): teamCount = 1 interval = self.__getTeamLst(0) for i in range(self.__pools): tmpPool = Pool() tmpPool.createSchedule(self.__games, interval[i], teamCount) self.poolBracket.append(tmpPool) teamCount += interval[i]
def parse(self, diceString): def raiseValueError(): raise ValueError("Invalid diceString value: {0}".format(diceString)) if not diceString: raiseValueError() match = re.match(r"(\d*)d(\d+)([\+\-]\d+)?\s*(?:\(([\+\-]?\d+)\))?", diceString.strip()) if not match: raiseValueError() dice, sides, modifier, showing = match.groups() sides = int(sides) if not dice: dice = 1 else: dice = int(dice) if not modifier: modifier = 0 else: modifier = int(modifier) if showing: showing = int(showing) if showing > sides * dice + modifier: raiseValueError() if showing < dice + modifier: raiseValueError() if sides > 1: numberAtMax = (showing - modifier - dice) / (sides - 1) remainder = (showing - modifier) - (numberAtMax * sides) - (dice - numberAtMax - 1) def getShowing(index): if index < numberAtMax: return sides if index == numberAtMax: return remainder return 1 return Pool([Die(sides=int(sides), showing=getShowing(index)) for index in range(dice)], modifier=modifier, rolled=True) return Pool([Die(sides=int(sides)) for d in range(dice)], modifier=modifier)
def __init__(self, gameClass, opponents, rW, nWorkers=1, nSeeds=None): self._pool = Pool([EvalWorker(gameClass, opponents, rW) for _ in range(nWorkers)]) self._pool.start() if nSeeds is not None: self._seeds = np.random.randint(np.iinfo(np.int32).max, size=(nSeeds,)) else: self._seeds = [None] self._nSeeds = len(self._seeds)
def search(keywords): pool = Pool() while pool.pool: for name, pos in pool.items(): if matchKey(getSoup(name, pos).text, keywords): print(getRootUrl(name, post)) next_pos = getNextPos(name, pos) pool.update(name, next_pos)
def read_csv_file(file_name): pools = [] with open(file_name, 'r') as file: reader = csv.reader(file) for row in reader: pools.append(Pool(row[0], int(row[1]), int(row[2]))) return pools
def fullPool(spec): """Creates a pool and fills it with the world drawn from the provided specification, before returning it.""" pool = Pool() data = sampleWorld(spec) for pair in data: pool.store(pair[0], pair[1]) return pool
def respool(request, pool_file): pool = Pool(config=IntegrationTestConfig(pool_file=pool_file)) # teardown def delete_pool(): pool.delete() request.addfinalizer(delete_pool) return pool
def testAdd(self): results = set() pool = Pool(3) for result in pool.imap_unordered(Run, [[x] for x in range(0, 10)]): results.add(result.value) if result.value < 30: pool.add([result.value + 20]) self.assertEquals(set(range(0, 10) + range(20, 30) + range(40, 50)), results)
def testException(self): results = set() pool = Pool(3) for result in pool.imap_unordered(Run, [[x] for x in range(0, 12)]): # Item 10 will not appear in results due to an internal exception. results.add(result) expect = set(range(0, 12)) expect.remove(10) self.assertEquals(expect, results)
def get_html(url): pool = Pool() proxies = pool.pool() headers={'User-Agent':'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.100 Safari/537.36'} while True: try: req=requests.get(url,headers=headers, proxies = proxies, timeout=5) req.encoding='UTF-8' return html_str_util.filter_tags(req.text) except requests.exceptions.RequestException: pass
def __init__(self, app, **kwargs): self.app = app or self.app super(Guard, self).init(**kwargs) self.rpc_server = PyroServer(GUARD_PORT) self.rpc_client = PyroClient(self.app.conf['HUB_IP'], HUB_PORT) self.pool = Pool(self.app) self.machine = Machine(healthy_mock=app.conf['HEALTHY_MOCK'], labels=self.labels) self.__shutdown_guard = threading.Event() self.LOOP_INTERVAL = 10 # second self.alive = False
def __init__(self, sub, loo): self.sub = sub self.loo = loo self.data_file = './sub{}/pca_loo_tr{}'.format(self.sub, self.loo) self.data = pd.read_pickle(self.data_file) self.data_val = pd.read_pickle(self.data_file) self.costs = pd.Series(np.ones(32)) self.pool = Pool(POOL_SIZE) # 1.000.000 self.env = Environment(self.data, self.costs, FEATURE_FACTOR) self.brain = Brain(self.pool) self.agent = Agent(self.env, self.pool, self.brain) self.log = Log(self.data_val, self.costs, FEATURE_FACTOR, self.brain)
def load_config(self): for pool_name in Config().get('pools').keys(): if Config().get('pools.%s.enable' % (pool_name)): try: self.pools[pool_name] = eval("%s.%s()" % (pool_name, pool_name.title())) except NameError: self.pools[pool_name] = Pool(pool_name) self.pools[pool_name].refresh_data() if len(self.pools) == 0: Log().add('fatal', 'no pools enabled - the config file format for pools has changed, please see minotaur.conf.example')
def _ReturnConnection(self): """ Returns a connection back to the pool @author: Nick Verbeck @since: 9/7/2008 """ if self.conn is not None: if self.connInfo.commitOnEnd is True or self.commitOnEnd is True: self.conn.Commit() Pool().returnConnection(self.conn) self.conn = None
def run(IP, PORT): # Simulated "event queue" eventQueue = deque() # Process queue used for async rpc system. processQ = Queue() sessionManager = MasterSessionManager(IP, PORT, processQ) rpcManager = RPCManager(sessionManager, processQ) containerAllocator = RMContainerAllocator(eventQueue, sessionManager) committerEventHandler = CommitterEventHandler(eventQueue) printed = False; serverList = [] assignedServers = [] serverAssignments = defaultdict(list) pool = Pool() job = Job(work, pool, rpcManager, eventQueue) # Simulate Delayed Job init and start. eventQueue.append(("JOB_INIT", job)) eventQueue.append(("JOB_START", job)) while True: # Simulate "event delivery" containerAllocator.pushNewEvents(eventQueue) committerEventHandler.pushNewEvents(eventQueue) pool.pushNewEvents(eventQueue) eventQueue.clear() # Simulate async mechanisums sessionManager.poll() rpcManager.poll() containerAllocator.heartbeat() committerEventHandler.heartbeat() # For server failure for locator in serverList: if (locator not in sessionManager.serverList()): eventQueue.append(("JOB_UPDATED_NODES", locator)) if serverList != sessionManager.serverList(): print "serverList change" serverList = sessionManager.serverList() # Run tasks pool.poll() if job.getStatus() == "SUCCEEDED" and not printed: print "Job Complete" print job printed = True