def add_block(self, type_, col, row): if type_ == 'wall': self.walls.append(block.Block('wall.png', col, row)) elif type_ == 'box': self.boxs.append(block.Block('box.png', col, row)) else: self.targets.append(block.Block('target.png', col, row))
def initGrid(): clearGrid() wall = block.Block("wall", "[ ]", (80, 80, 80, 255)) for y in range(0, grid_dim[1]): for x in range(0, grid_dim[0]): if x == 0 or x == grid_dim[0] - 1 or y == 0 or y == grid_dim[1] - 1: if not (x == int(grid_dim[0] / 2) and (y == 0 or y == grid_dim[1] - 1)): grid[x][y] = wall else: if random.random() < 0.12 and not x == int(grid_dim[0] / 2): grid[x][y] = wall #SPECIAL ITEM: PI (Increases heart spawn rate) if random.random() < 0.03 or (random.random() < 0.06 and getCurrentItemName() == "Pie"): grid[x][y] = block.Block("heart", "❤", (255, 0, 0, 255), True) #SPECIAL ITEM: Gammos (Increases chest spawn rate) if random.random() < 0.015 or (random.random() < 0.01 and getCurrentItemName() == "Gammos"): grid[x][y] = block.Block("chest", "[?]", (0, 255, 0, 255)) pl_pos[0] = int(grid_dim[0] / 2) pl_pos[1] = 0
def __init__(self, mc, position=minecraft.Vec3(0, 0, 0)): #set defaults self.mc = mc #start position self.startposition = position #set turtle position self.position = position #set turtle angles self.heading = 0 self.verticalheading = 0 #set pen down self._pendown = True #set pen block to black wool self._penblock = block.Block(block.WOOL.id, 15) #flying to true self.flying = True #set speed self.turtlespeed = 6 #create turtle self.showturtle = True # create drawing object self.mcDrawing = MinecraftDrawing(self.mc) # set turtle block self.turtleblock = block.Block(block.DIAMOND_BLOCK.id) # draw turtle self._drawTurtle(int(self.position.x), int(self.position.y), int(self.position.y))
def __init__(self, _width, _height, posX, posY, _level, _levelSpeed, _itemsEnabled): self.height = _height self.width = _width self.fieldPosX = posX * configs.zoom self.fieldPosY = posY * configs.zoom self.field = [] self.score = 0 self.state = "running" self.goDownCounter = 1 self.series = 0 self.pressingRight = False self.pressingRightCounter = 0 self.pressingRightFirstUpdate = 0 self.pressingLeft = False self.pressingLeftCounter = 0 self.pressingLeftFirstUpdate = 0 self.level = _level self.itemEnabled = _itemsEnabled self.nextLevel = configs.levelUp[_level - 1] * _levelSpeed self.levelSpeed = _levelSpeed self.block = block.Block(3, 0) self.nextBlock = block.Block(3, 0) self.updateDropSpeed() # create the field lines and values for i in range(_height): new_line = [] for j in range(_width): new_line.append(0) self.field.append(new_line)
def validate_pow(bch, num): miners = bch[num - 1].powminers miners.sort(reverse=True) i = ((int(bch[num - 1].txs[num - 1].hash) + int(bch[num - 1].txs[-3].hash)) % int(len(miners)**0.5))**2 i1 = i bl = block.Block(miners[i][1], [miners[i][2]], bch, [], [], miners[i][3]) while True: bl = block.Block(miners[i][1], [miners[i][2]], bch, [], [], miners[i][3]) bl.prevhash = bch[i - 1].h if int(bl.calc_pow_hash()) <= miners[i][0] <= pow_max: print('i167', i) break else: miners.remove(miners[i]) if i == i1: raise NoValidMinersError if i == len(bch): i = i - len(bch) + 1 if not miners[i][2] == bch[num].creators[0] or not bch[ num].timestamp == miners[i][3] or not bch[num].n == miners[i][1]: print( hash(miners[i][2]) % 100, hash(bch[num].creators[0]) % 100, bch[num].timestamp, miners[i][3], bch[num].n, miners[i][1], i) return False return True
def load(self,filename): ####################################################################################### # Programmer Name: Alec # Date: 5/20/17 # Purpose: to load the level's elements from a file # Input: self, filename # Output: element_list attribute, height attribute ####################################################################################### file=open("data/level/"+filename,"r") # open file lines=file.readlines() # list of lines pos=[0,0] # origin position for line in lines: # for each line go through each character: for char in line: # for each character: if char=="#": # determine the block it creates b=block.Block(self.player,(pos),"brick") self.element_list.append(b) elif char=="D": self.exit=[pos[0],pos[1]] elif char=="F": b=block.Block(self.player,(pos),"door") self.element_list.append(b) elif char=="B": b=block.Block(self.player,(pos),"bookshelf") self.element_list.append(b) elif char=="S": self.start=[pos[0]+25,pos[1]+25] pos[0]+=50 # move the x position for the next block pos[0]=0 # reset x coordinate pos[1]+=50 # move the y position for the next row self.height=pos[1] # assign the height as the final y position file.close() # close the file
def test_blockchain(self): t = tn.CoinbaseTransaction(wt.pubToAddress(wt.privToPub(pk))) t.sign(pk) genesis_block = bk.Block(time.time(), '0' * 64, s.Serializer.serialize(t)) genesis_block.mine(2) bv.validate(genesis_block) '''genesis''' tr = tn.Transaction(wt.pubToAddress(wt.privToPub(pk)), '12pULxeW59imr1mWs8AjQogji8H77KD3KT', 5) tr.sign(pk) sr = s.Serializer.serialize(tr) lst = [] lst.append(s.Serializer.serialize(t)) lst.append(sr) lst.append(sr) lst.append(sr) b1 = bk.Block(time.time(), genesis_block.hash, lst) b1.mine(2) bv.validate(b1) b2 = bk.Block(time.time(), b1.hash, lst) b2.mine(2) bv.validate(b2) chain = [] chain.append(genesis_block) chain.append(b1) chain.append(b2) #b2.timestamp = "1241" self.assertTrue(is_valid_chain(chain)) chain
def add_block(self, data): if (len(self.blocks) == 0): new_block = block.Block(data, genesis_block=True) else: most_recent_block = self.get_most_recent() new_block = block.Block(data, previous_block=most_recent_block) self.blocks.append(new_block)
def __init__(self): self.donkey = block.Block(donkeyImage, 20, 20) self.donkey.rect.x = 10 self.donkey.rect.y = 80 self.player = block.Block(playerImage, 15, 15) self.score = 0 self.player.rect.x = 15 self.player.rect.y = 475
def compute_blocks(self, test=False): """Put repeats into MPPHB form.""" self.blocks = [] print("There are {} repeats".format(len(self.repeats))) counter = 0 for repeat in self.repeats: if counter % 1000 == 0: if len(self.repeats) > 1000: print("Processed {} repeats".format(counter)) counter += 1 # get repeat info starts = repeat[0] length = repeat[1] start = starts[0] # print("Length of this repeat is {}".format(length)) # print("-----Processing repeats at starts {}".format(starts)) occ, one_left, one_right = self.\ get_occ_from_long_string(start, length) # check that these repeats are all valid self.check_repeats_while_processing(starts, length, occ) # figure out which paths are involved in the repeat indices, names = self.get_path_indices_and_names(starts, length, occ) # figure out which snps snps = self.decode_snps(occ) # if this is actually a block (at least 1 snp and at least two # paths): if len(snps) > 0 and len(set(indices)) > 1: # create Block differently based on r_method if self.r_method == "distance": # figure out location on the genome of first and last snp distance = self.get_distance(names, snps) # create block with these snps, these path indices and # names, and computed length and overall genome length self.blocks.append(block.Block(snps, list(set(indices)), list(set(names)), self.r_method, self.y_0, distance, self.genome_length)) elif self.r_method == "frequency": # we have a dictoinary with keys [(startsnp, endsnp)] # pointing to a list of frequencies for this pair snp1 = snps[0].split(":")[0] snp2 = snps[-1].split(":")[0] distance = self.get_distance(names, snps) self.blocks.append(block.Block(snps, list(set(indices)), list(set(names)), self.r_method, self.y_0, freqs=self.freqs[(snp1, snp2)], length=distance))
def fillBlocks(self): ### blocks import vector import block self.blocks.append(block.Block(vector.Vector(0.0, 1.75), 1.0, 3.5)) self.blocks.append(block.Block(vector.Vector(self.field_width / 2.0 + 0.25, self.field_height / 2.0 - 0.5), 0.5, self.field_height + 1.0)) self.blocks.append(block.Block(vector.Vector(-self.field_width / 2.0 - 0.25, self.field_height / 2.0 - 0.5), 0.5, self.field_height + 1.0)) self.blocks.append(block.Block(vector.Vector(0.0, -0.5), self.field_width, 1.0)) self.blocks.append(block.Block(vector.Vector(0.0, self.field_height - 0.25), self.field_width, 0.5))
def read(self, address, current_step): r = None #Check if this is main memory #Main memory is always a hit if not self.next_level: r = response.Response({self.name: True}, self.hit_time) else: #Parse our address to look through this cache block_offset, index, tag = self.parse_address(address) #Get the tags in this set in_cache = list(self.data[index].keys()) #If this tag exists in the set, this is a hit if tag in in_cache: r = response.Response({self.name: True}, self.hit_time) else: #Read from the next level of memory r = self.next_level.read(address, current_step) r.deepen(self.write_time, self.name) if self.policy == 'Inclusive': print('Inclusive cache') #TODO: your code here elif self.policy == 'Exclusive': print('Exclusive cache') #TODO: your code here else: #If there's space in this set, add this block to it if len(in_cache) < self.associativity: self.data[index][tag] = block.Block( self.block_size, current_step, False, address) else: #Find the oldest block and replace it oldest_tag = in_cache[0] for b in in_cache: if self.data[index][b].last_accessed < self.data[ index][oldest_tag].last_accessed: oldest_tag = b #Write the block back down if it's dirty and we're using write back if self.write_back: if self.data[index][oldest_tag].is_dirty(): self.logger.info('\tWriting back block ' + address + ' to ' + self.next_level.name) temp = self.next_level.write( self.data[index][oldest_tag].address, True, current_step) r.time += temp.time #Delete the old block and write the new one del self.data[index][oldest_tag] self.data[index][tag] = block.Block( self.block_size, current_step, False, address) return r
def add_block(): if len(blockchain) == 0: inp = input("Please enter the Data of your choice : ") blk_obj = block.Block('3kj13j4hbjh243b4hj23', inp) print('Block created with hash :', blk_obj.get_hash()) blockchain.append(blk_obj) else: data = input("Please enter the Data of your choice : ") b_obj = block.Block(blockchain[-1].get_hash(), data) print('Block created with hash :', b_obj.get_hash()) blockchain.append(b_obj)
def generateNewblock(self, lastBlock, stop=False): while True: if self.type == 'PoW': new_hash, nonce, timestamp, tx = self.POW(lastBlock, stop) if not nonce: return None if new_hash: return block.Block(lastBlock.index + 1, lastBlock.hash, nonce, new_hash, timestamp, tx) elif self.type == 'PoS': new_hash, nonce, timestamp, tx = self.POS(lastBlock, stop) if new_hash: return block.Block(lastBlock.index + 1, lastBlock.hash, nonce, new_hash, timestamp, tx)
def initcastle(self, screen): self.castleblocks = [ block.Block("Images/castle.png", "Images/castle.png", (110, 50), 180, 10), block.Block("Images/castlepillar.png", "Images/castlepillar.png", (100, 20), 20, 40), block.Block("Images/castlepillar.png", "Images/castlepillar.png", (280, 20), 20, 40), ] self.castle_block_group = pygame.sprite.RenderPlain(*self.castleblocks) if (self.MODE == 1): self.castle_block_group.draw(screen)
def __init__(self, center, surface, board): Form.__init__(self, center, cst.CYAN, surface, board) self.blocks.append( block.Block(self.color, center, False, surface, board)) center[0] += 1 self.blocks.append( block.Block(self.color, center, False, surface, board)) center[0] += 1 self.blocks.append( block.Block(self.color, center, False, surface, board)) center[0] -= 3 self.blocks.append( block.Block(self.color, center, False, surface, board))
def __init__(self, center, surface, board): Form.__init__(self, center, cst.ORANGE, surface, board) self.blocks.append( block.Block(self.color, center, False, surface, board)) center[0] -= 1 self.blocks.append( block.Block(self.color, center, False, surface, board)) center[0] += 2 self.blocks.append( block.Block(self.color, center, False, surface, board)) center[1] -= 1 self.blocks.append( block.Block(self.color, center, False, surface, board))
def create_shape(self): if len(self.shape_group) < 1: new_shape = block.Block(self) self.shape_group.append(new_shape) elif len(self.shape_group) < 2: p1 = self.shape_group[-1].shape new_shape = block.Block(self, p1) self.shape_group.append(new_shape) else: p1 = self.shape_group[-1].shape p2 = self.shape_group[-2].shape new_shape = block.Block(self, p1, p2) self.shape_group.append(new_shape)
def test_blockEquals(): transaction.Transaction.id = 0 block.Block.id = 0 t = [transaction.Transaction(i, i + 1, 0) for i in range(10)] a = block.Block(t[:3]) b = block.Block([t[2], t[1], t[0]]) c = block.Block(t[-3:]) assert a == b assert a != c assert b != c
def mine(last_block): nonce = 0 this_index = last_block.index + 1 this_timestamp = date.datetime.now() this_data = "This is the #" + str(this_index) + " block!" this_hash = last_block.hash this_nonce = nonce new_block = block.Block(this_index, this_timestamp, this_data, this_hash, nonce) while new_block.hash[:2] != "00": nonce += 1 new_block = block.Block(this_index, this_timestamp, this_data, this_hash, nonce) return new_block
def squaremaker(x,y,game_objects): for i in range(x,x+150,50): game_objects.append(block.Block(x=i, y=y, batch=main_batch)) game_objects.append(finish.Finish(x=x+50, y=y+50, batch=main_batch)) for i in range (y,y+150,50): game_objects.append(block.Block(x=x, y=i, batch=main_batch)) for i in range(x,x+150,50): game_objects.append(block.Block(x=i, y=y+100, batch=main_batch)) for i in range (y,y+150,50): game_objects.append(block.Block(x=x+100, y=i, batch=main_batch))
def test(): # tester function to test/demo basic blockchain functionality blockchain = generateNewBlockchain() # generate new blockchain # add two blocks to the newblockchain paper1 = "There has been a recent resurgence in the area of explainable artificial intelligence as researchers and practitioners seek to provide more transparency to their algorithms. Much of this research is focused on explicitly explaining decisions or actions to a human observer, and it should not be controversial to say that looking at how humans explain to each other can serve as a useful starting point for explanation in artificial intelligence. However, it is fair to say that most work in explainable artificial intelligence uses only the researchers’ intuition of what constitutes a ‘good’ explanation. There exist vast and valuable bodies of research in philosophy, psychology, and cognitive science of how people define, generate, select, evaluate, and present explanations, which argues that people employ certain cognitive biases and social expectations to the explanation process. This paper argues that the field of explainable artificial intelligence can build on this existing research, and reviews relevant papers from philosophy, cognitive psychology/science, and social psychology, which study these topics. It draws out some important findings, and discusses ways that these can be infused with work on explainable artificial intelligence." block1 = block.Block(paper1) blockchain.add(block1) paper2 = "Recently, the notion of explainable artificial intelligence has seen a resurgence, after having slowed since the burst of work on explanation in expert systems over three decades ago; for example, see Chandrasekaran et al. [23], [168], and Buchanan and Shortliffe [14]. Sometimes abbreviated XAI (eXplainable artificial intelligence), the idea can be found in grant solicitations [32] and in the popular press [136]. This resurgence is driven by evidence that many AI applications have limited take up, or are not appropriated at all, due to ethical concerns [2] and a lack of trust on behalf of their users [166,101]. The running hypothesis is that by building more transparent, interpretable, or explainable systems, users will be better equipped to understand and therefore trust the intelligent agents [129,25,65]. While there are many ways to increase trust and transparency of intelligent agents, two complementary approaches will form part of many trusted autonomous systems: (1) generating decisions1 in which one of the criteria taken into account during the computation is how well a human could understand the decisions in the given context, which is often called interpretability or explainability; and (2) explicitly explaining decisions to people, which we will call explanation. Applications of explanation are considered in many sub-fields of artificial intelligence, such as justifying autonomous agent behaviour [129,65], debugging of machine learning models [89], explaining medical decision-making [45], and explaining predictions of classifiers [157]." block2 = block.Block(paper2) blockchain.add(block2) blockchain.print() # print the blockchain blockchain.save() # save it to local file bc = loadBlockchain() # load the blockchain bc.print() # print the loaded blockchain
def new(self): # Starts a new game self.allSprites = pg.sprite.Group() self.balls = pg.sprite.Group() self.blocks = pg.sprite.Group() # Add Player Sprites self.player = player.Player() self.allSprites.add(self.player) # Add Enemy Sprites self.ball = ball.Ball() self.allSprites.add(self.ball) self.balls.add(self.ball) # Add any other sprites for row in range(self.noOfRows): for column in range(0, self.blockCount): block1 = block.Block(settings.RED, column * (settings.BLOCK_WIDTH + 2) + 1, self.top) self.blocks.add(block1) self.allSprites.add(block1) # Move the top of the next row down self.top += settings.BLOCK_HEIGHT + 2 self.run()
def create_and_append_block(self, block_tx): """Create a block from a list of transactions""" new_block = block.Block(block_tx) # Lock block creation so that the blocks form a consistent chain # Only lock a small part of the creation so that multiple blocks # can be created at once and a small part is synchronised self.create_block_lock.acquire() new_block.set_prev_block(self.prev_block) new_block.calc_and_set_block_hash() self.prev_block = new_block self.blocks_created += 1 # If the block cap has been reached, change the cleaning interval to # a predefined fixed value if self.blocks_created > self.block_cap: self.cleaning_interval = self.interval_after_cap store_block_thread = threading.Thread(target=self.store_block, args=[new_block]) store_block_thread.start() self.last_n_blocks.append(new_block.block_hash) if len(self.last_n_blocks) > self.n_blocks_stored: self.last_n_blocks = self.last_n_blocks[1:] store_block_thread.join() self.check_block_tx_types(new_block.block_hash, block_tx) self.create_block_lock.release() # If we are benchmarking and the number of blocks created is the number # of blocks we are expecting based off the number of transactions # expected, then start the thread where it waits to kill this process if self.benchmark and self.blocks_created >= self.num_blocks \ and not self.check_to_kill: self.check_to_kill = True kill_thread = threading.Thread(target=self.wait_to_kill) kill_thread.start()
def erasure_decoder(pkg_name): """when there is enough block for decoding """ block_manager = block.Block("{}/{}_donut.zip".format( os.getcwd(), pkg_name)) block_manager.erasure_decode() print("donut--> decode done!!!")
def genesis_block(self): self.height = 0 genesis = block.Block() genesis.GetMerkleRoot() genesis.MineBlock(self.complexity) self.chain.clear() self.chain.append(genesis)
def __init__(self, num_txs=None, block_cap=1000000, num_stored=1000, post_cap_interval=10): self.transactions = [] self.running_threads = [] # Synchronisation for block creation and list of running threads self.create_sync_vars() self.blocks_created = 0 # How many blocks can be reached before using a fixed cleaning interval # This can be set to zero or one to always use a fixed cleaning interval self.block_cap = block_cap # How many block hashes to store when using a fixed cleaning interval # More blocks = longer fixed cleaning interval but higher possibility # of remove succeeding self.n_blocks_stored = num_stored # The fixed cleaning interval in seconds when using a fixed interval self.interval_after_cap = post_cap_interval try: # Try to open an existing database first self.db = plyvel.DB("/home/ben/mof-bc") last_tuple = pickle.loads(self.db.get('last'.encode('utf-8'))) # Get the details of the existing database # (last block created and number of blocks) if last_tuple: self.prev_block = pickle.loads(self.db.get(last_tuple[0])) self.blocks_created = last_tuple[1] else: self.blocks_created = 0 except plyvel.Error: # Database doesn't exist - create a new one self.db = plyvel.DB("/home/ben/mof-bc", create_if_missing=True) self.genesis = block.Block() self.genesis.calc_and_set_block_hash() self.prev_block = self.genesis self.store_block(self.genesis) self.sock = socket.socket() self.start_socket() self.key_hash_map = {} self.create_new_key() self.prev_tx = 'first' self.init_optimisation_variables() self.tx_per_block = 10 # Create up to 5 threads that will create new blocks from transactions self.num_create_block_threads = 5 # Spin up a thread that accepts new connections from users self.listen_thread = threading.Thread(target=self.accept_conn) self.listen_thread.start() # Spin up a new thread that checks the number of transactions received # and create new blocks if there are enough transactions self.check_tx_thread = threading.Thread(target=self.check_num_tx) self.check_tx_thread.start() # Spin up a new thread that will run cleaning period operations self.cleaning_thread = threading.Thread(target=self.clean_bc) self.cleaning_thread.start() # Used to terminate the miner when benchmarking self.check_to_kill = False self.benchmark = False if num_txs: self.benchmark = True self.start_time = None self.num_blocks = num_txs / self.tx_per_block
def nextRound(self, heartbeat): """Simulates the next round""" self.heartbeat = heartbeat # if start of round, reset validator, proposer set & update common blockchain if heartbeat % Solver.N_HEARTBEATS_IN_ROUND == 0: self.propSet = self.chooseProposers() # choose proposer set # update common blockchain among players currBlock = self.players[0].blockchain same = True for i in self.players: if currBlock != i.blockchain: same = False break if same and currBlock != None: currBlock = block.Block(currBlock.txs, id=currBlock.id, proposer=currBlock.proposer) currBlock.next = self.blockchain self.blockchain = currBlock for i in self.players: i.action(heartbeat)
def gen_state(self, states): """ Generate the current state as a useable dictonary and save it in the list of states. """ # generate current block list new_block_list = [] for blk in self.blk_list: # copy block b = block.Block(copy.deepcopy(blk.shape), blk.x, blk.y, blk.screen, blk.color, blk.rotate_en, blk.letter, True) new_block_list.append(b) #depending on the representation, update it if (constants.REPRESENTATION_COMPLEX): r = RepresentationComplex.RepresentationComplex() else: r = representation.Representation() r.update(self.blk_list) formatted_r = r.format() gen_state = { "blk_list": new_block_list, "score": self.score, "representation": r, "formatted_representation": formatted_r } states.append(gen_state)
def mine(): # 获取区块链中最后一个区块的证明数字 last_block = blockchain[-1] last_proof = last_block.data['proof_of_work'] # 计算即将被挖掘区块的证明数字 proof = proof_of_work(last_proof) # 一旦挖到新区块,则奖励矿工一笔交易 this_nodes_transactions.append({ 'from': 'network', 'to': miner_address, 'amount': 1 }) # 收集交易信息等,生成新区块 new_block_data = { "transactions": list(this_nodes_transactions), "proof_of_work": proof } this_block_index = last_block.index + 1 this_block_timestamp = date.datetime.now() last_block_hash = last_block.hash # 清空本node交易信息列表 this_nodes_transactions[:] = [] # 创建新区块 mined_block = block.Block(this_block_index, this_block_timestamp, new_block_data, last_block_hash) # 加入到区块链 blockchain.append(mined_block) # 让客户端知道我们挖到了新的区块 return json.dumps({ "index": this_block_index, "timestamp": str(this_block_timestamp), "data": new_block_data, "hash": last_block_hash }) + '\n'