Python BitArray.invert方法代码示例

# 需要导入模块: from bitstring import BitArray [as 别名]
# 或者: from bitstring.BitArray import invert [as 别名]
def accbits_for_blocknum(accbits_str, blocknum):
    '''
    Decodes the access bit string for block "blocknum".
    Returns the three access bits for the block or False if the
    inverted bits do not match the access bits.
    '''
    bits = BitArray([0])
    inverted = BitArray([0])

    # Block 0 access bits
    if blocknum == 0:
        bits = BitArray([accbits_str[11], accbits_str[23], accbits_str[19]])
        inverted = BitArray([accbits_str[7], accbits_str[3], accbits_str[15]])

    # Block 0 access bits
    elif blocknum == 1:
        bits = BitArray([accbits_str[10], accbits_str[22], accbits_str[18]])
        inverted = BitArray([accbits_str[6], accbits_str[2], accbits_str[14]])
    # Block 0 access bits
    elif blocknum == 2:
        bits = BitArray([accbits_str[9], accbits_str[21], accbits_str[17]])
        inverted = BitArray([accbits_str[5], accbits_str[1], accbits_str[13]])
    # Sector trailer / Block 3 access bits
    elif blocknum in (3, 15):
        bits = BitArray([accbits_str[8], accbits_str[20], accbits_str[16]])
        inverted = BitArray([accbits_str[4], accbits_str[0], accbits_str[12]])

    # Check the decoded bits
    inverted.invert()
    if bits.bin == inverted.bin:
        return bits
    else:
        return False

# 需要导入模块: from bitstring import BitArray [as 别名]
# 或者: from bitstring.BitArray import invert [as 别名]
def hamming_search(b, bit, radius, current_radius, H):
    if current_radius == 0:
        H[current_radius].append(b.copy())

    if current_radius == radius:
        return
    for i in range(bit+1, b.length):
        b2 = BitArray(b.copy())
        b2.invert(i)
        H[current_radius+1].append(b2.copy())
        hamming_search(b2, i, radius, current_radius+1, H)

# 需要导入模块: from bitstring import BitArray [as 别名]
# 或者: from bitstring.BitArray import invert [as 别名]
 def _mutate(self):
     new_val = BitArray(self._default_value).copy()
     start, end = self._start_end()
     new_val.invert(range(start, end))
     self.set_current_value(Bits(new_val))

# 需要导入模块: from bitstring import BitArray [as 别名]
# 或者: from bitstring.BitArray import invert [as 别名]
def change_one_bit(input):
    bitarray = BitArray(hex=input)
    bitarray.invert(0)
    newinput = bitarray.hex
    return newinput, bitarray

# 需要导入模块: from bitstring import BitArray [as 别名]
# 或者: from bitstring.BitArray import invert [as 别名]

#.........这里部分代码省略.........
        logging.info('dividing up file into %s pieces', self.num_pieces)
        self.bitfield = BitArray(self.num_pieces)
        last_piece_length = self.file_length - (self.num_pieces - 1) * length
        for i in range(self.num_pieces):
            if i == self.num_pieces - 1:
                length = last_piece_length
            pieces.append(Piece(self, i, length, hash_list[i], self.dload_dir))
        self.pieces = pieces
        self.piece_queue = PieceQueue(pieces)

    def setup_download_directory(self):
        dir_name = self.torrent
        if dir_name.endswith('.torrent'):
            dir_name = dir_name[:-8]
        self.dload_dir = os.path.join(os.path.abspath(os.curdir), dir_name)
        try:
            os.makedirs(self.dload_dir)
        except OSError:
            if not os.path.isdir(self.dload_dir):
                raise SystemExit('Cannot create directory to download torrent files into. Please check if a file named ' + dir_name + ' exists') 
                # raise OSError('Cannot create directory to download torrent files to.')

    def check_if_dload_file_exists(self):
        file_path = os.path.join(self.dload_dir, self.file_name)
        if os.path.exists(file_path):
            raise SystemExit('This file has already been downloaded.')
            # Do something to cancel the rest of the setup

    def add_piece_to_queue(self, piece):
        self.piece_queue.put(piece)

    def add_piece_to_bitfield(self, index):
        if not self.bitfield[index]:
            self.bitfield.invert(index)
            self.manage_requests()
        else:
            logging.warning('Should never get save same piece more than once!')

    def add_peer_to_piece_peer_list(self, piece_index, peer):
        # print 'Adding piece', piece_index, 'to peer', peer
        self.pieces[piece_index].add_peer_to_peer_list(peer)

    def manage_requests(self, num_pieces=1):
        logging.info('Sending more piece requests')
        logging.info('Piece queue has %s pieces', self.piece_queue.length())
        if not self.piece_queue.empty():
            self.manage_piece_queue_state();
            for i in xrange(num_pieces):
                self.request_next_piece();
            logging.info('Cleaning up piece queue')
        else:
            # Count outstanding requests to decide when to go into endgame
            self.torrent_state = 'endgame'
            self.start_endgame()

    def start_endgame(self):
        self.blasted_requests = []
        for i in xrange(ENDGAME_MAX_BLASTS):
            self.send_endgame_request()
            
    def send_endgame_request(self):
        block_info = self.select_outstanding_request()
        if block_info:
            self.blasted_requests.append(block_info)
            self.pieces(block_info[0]).request_block_endgame(block_info)

# 需要导入模块: from bitstring import BitArray [as 别名]
# 或者: from bitstring.BitArray import invert [as 别名]

#.........这里部分代码省略.........
    def peer_stops_choking_client(self):
        self.peer_is_choking_client = False
        if self.am_interested:
            logging.info('Peer unchoked, sending requests now')
            if len(self.request_q) > 0:
                self.flush_request_queue()
            else:
                # TODO: Trace code path here
                self.client.manage_requests(REQUESTS_PER_PEER)

    def peer_is_now_interested(self):
        self.peer_is_interested = True
        # Assuming we always unchoke when receiving interested message
        self.am_choking_peer = False
        self.add_to_message_queue(UnchokeMsg())

    def peer_is_no_longer_interested(self):
        self.peer_is_interested = False
        # TODO: Update request q based on this information

    # When receiving bitfield
    def setup_bitfield(self, bitfield_buf):
        # TODO implement non-naive function for updating interested status
        bitfield = BitArray(bytes=bitfield_buf)
        self.bitfield = bitfield
        for piece_index, bit in enumerate(bitfield):
            if bit:
                self.client.add_peer_to_piece_peer_list(piece_index, self)
        self.am_interested = True
        self.add_to_message_queue(InterestedMsg())
        self.client.manage_requests(1)

    # When receiving have message
    def update_bitfield(self, piece_index):
        if not self.bitfield[piece_index]:
            self.bitfield.invert(piece_index)
            self.client.add_peer_to_piece_peer_list(piece_index, self)
        else:
            raise PeerCommunicationError('Redundant "Have" message.')

    # After request
    def queue_up_block(self, block_info):
        assert not self.am_choking_peer
        block = self.client.get_block(block_info)
        self.add_to_message_queue(BlockMsg(block_info=block_info, block=block))

    # After block message
    def update_and_store_block(self, block_info, block):
        self.outstanding_requests.remove(block_info)
        self.flush_request_queue()
        logging.debug('Storing block length %s beginning at index %s for piece %s',
                block_info[2], block_info[1], block_info[0])
        logging.debug('Actual length of block: %s', len(block))
        if self.client.torrent_state == 'endgame':
            piece = self.client.pieces[block_info[0]]
            piece.cancel_block(block_info, self)
        self.client.add_block(block_info, block)

    # After cancel message
    def clear_requests(self, block_info):
        pass

    def add_request_to_queue(self, block_info):
        if not self.peer_is_choking_client and \
        len(self.outstanding_requests) < REQUESTS_PER_PEER:
            self.send_request_message(block_info)
        else:
            logging.info('Adding block %s to request q', block_info)
            self.request_q.insert(0, block_info)

    def send_cancel_message(self, block_info):
        self.add_to_message_queue(CancelMsg(block_info))

    def send_request_message(self, block_info):
        self.outstanding_requests.append(block_info)
        logging.info('Sending request for block %s', block_info)
        self.add_to_message_queue(RequestMsg(block_info))

    def flush_request_queue(self):
        '''Move requests from holding queue to reactor message queue'''
        logging.info('Can flush up to %s requests', REQUESTS_PER_PEER - len(self.outstanding_requests))
        logging.info('Request q has %s blocks', len(self.request_q))
        while len(self.outstanding_requests) < REQUESTS_PER_PEER and \
            len(self.request_q) > 0:
            next_block_info = self.request_q.pop()
            logging.info('popped block %s off request q', next_block_info)
            self.send_request_message(next_block_info)

    # MESSAGE QUEUE
    def add_to_message_queue(self, msg):
        logging.info('adding message %s to queue', msg)
        self.msg_queue.put(msg)
        # TODO: Make time last msg sent update when its sent, not added to queue
        self.update_time_last_msg_sent()

    def get_from_message_queue(self):
        if self.msg_queue.empty():
            raise Queue.Empty
        else:
            return self.msg_queue.get_nowait()

# 需要导入模块: from bitstring import BitArray [as 别名]
# 或者: from bitstring.BitArray import invert [as 别名]
def main():
	#parser = argparse.ArgumentParser()
	#parser.add_argument('-d', dest='device', action='store', default="/dev/ttyAMA0", help="Serial device path", required=True)
	#parser.add_argument('-o', dest='output', action='store', default=None, help="Output file", required=False)
	#parser.add_argument('-s', dest='stdout', default=1, required=False, help="Print output to stdout")
	#args = parser.parse_args() 

	#if args.device == None:
	if 1:
 		GPIO.setmode(GPIO.BOARD)
		GPIO.setup(bcda0,GPIO.IN)  #AZ0 Red    BCD0 
		GPIO.setup(bcda1,GPIO.IN)  #AZ1 Blue   BCD1
		GPIO.setup(bcda2,GPIO.IN)  #AZ2 Green  BCD2
		GPIO.setup(bcda3,GPIO.IN)  #AZ3 Yellow BCD3
		
		GPIO.setup(bcdb0,GPIO.IN)  #AZ0 Red    BCD0 
		GPIO.setup(bcdb1,GPIO.IN)  #AZ1 Blue   BCD1
		GPIO.setup(bcdb2,GPIO.IN)  #AZ2 Green  BCD2
		GPIO.setup(bcdb3,GPIO.IN)  #AZ3 Yellow BCD3
		
		GPIO.setup(bcdc0,GPIO.IN)  #AZ0 Red    BCD0 
		GPIO.setup(bcdc1,GPIO.IN)  #AZ1 Blue   BCD1
		GPIO.setup(bcdc2,GPIO.IN)  #AZ2 Green  BCD2
		GPIO.setup(bcdc3,GPIO.IN)  #AZ3 Yellow BCD3
		
		
		digit1 = 0
		digit2 = 0
		digit3 = 0

		while (1):
			bcd = BitArray('0b0000')
			if GPIO.input(bcda0):
				bcd.invert(3)
			if GPIO.input(bcda1):
				bcd.invert(2)
			if GPIO.input(bcda2):
				bcd.invert(1)
			if GPIO.input(bcda3):
				bcd.invert(0)
			digit1=bcd.uint
			if digit1 > 9:
				digit1=0

			bcd = BitArray('0b0000')
			if GPIO.input(bcdb0):
				bcd.invert(3)
			if GPIO.input(bcdb1):
				bcd.invert(2)
			if GPIO.input(bcdb2):
				bcd.invert(0)
			if GPIO.input(bcdb3):
				bcd.invert(1)
			digit2=bcd.uint
			if digit2 > 9:
				digit2=0
		
			bcd = BitArray('0b0000')
			if GPIO.input(bcdc0):
				bcd.invert(3)
			if GPIO.input(bcdc1):
				bcd.invert(2)
			if GPIO.input(bcdc2):
				bcd.invert(0)
			if GPIO.input(bcdc3):
				bcd.invert(1)
			digit3=bcd.uint
			if digit3 > 9:
				digit3=0

			bearing = digit1*100 + digit2*10 + digit3
			print bearing

	else:
		print ("Too many parameters")
		parser.print_help()

# 需要导入模块: from bitstring import BitArray [as 别名]
# 或者: from bitstring.BitArray import invert [as 别名]
def element_calulator(Pulses):

    ch1 = [-1]
    ch2 = [-1]
    ch3 = [-1]
    ch4 = [-1]

    for arg in Pulses:
        if (arg.channel == 'ch1'):
            ch1.append(arg.start)
            ch1.append(arg.end)
        elif (arg.channel == 'ch2'):
            ch2.append(arg.start)
            ch2.append(arg.end)
        elif (arg.channel == 'ch3'):
            ch3.append(arg.start)
            ch3.append(arg.end)
        elif (arg.channel == 'ch4'):
            ch4.append(arg.start)
            ch4.append(arg.end)
            
    tot_length = max(max(ch1),max(ch2),max(ch3),max(ch4))
    del ch1[0]
    del ch2[0]
    del ch3[0]
    del ch4[0]
    
    
    channel1 = BitArray(int=0, length=tot_length)
    channel2 = BitArray(int=0, length=tot_length)
    channel3 = BitArray(int=0, length=tot_length)
    channel4 = BitArray(int=0, length=tot_length)
    for x in range(len(ch1)):
        if (x%2 == 0):
            channel1.invert(range(ch1[x],ch1[x+1]))
        else:
            pass
    
    for x in range(len(ch2)):
        if (x%2 == 0):
            channel2.invert(range(ch2[x],ch2[x+1]))
        else:
            pass    
    
    for x in range(len(ch3)):
        if (x%2 == 0):
            channel3.invert(range(ch3[x],ch3[x+1]))
        else:
            pass
        
    for x in range(len(ch4)):
        if (x%2 == 0):
            channel4.invert(range(ch4[x],ch4[x+1]))
        else:
            pass

    channel1 |= channel2
    channel3 |= channel4
    channel1 |= channel3    
    
    channel1.append('0b0')
    result = []
    count = 0    
    test = BitArray(int = 0, length = 1)
    empty = test.find('0b1')
    
    while (channel1.len != 0):
        
        test = channel1.find('0b1')
        if (test == empty):
            break
        else:
            result.append(channel1.find('0b1'))
            result[count] = result[count][0]
            del channel1[0:result[count]]
            count = count + 1
    
        test = channel1.find('0b0')
        if (test == empty):
            break
        else:
            result.append(channel1.find('0b0'))
            result[count] = result[count][0]
            del channel1[0:result[count]]
            count = count + 1

    return result