Python drive.Drive类代码示例

 def __init__(self,mode,device,calibrationSpeeds):
     baud = 9600
     if mode == Mode.SIM:
         self.drive = Drive(device,baud,simulate=1,calibration=calibrationSpeeds)
     elif mode == Mode.LIVE:
         self.drive = Drive(device,baud,simulate=0,calibration=calibrationSpeeds, persist=False)
     self.pos = self.azalt()
     self.getCurrentPos()
     self.location = self.drive.location  #TODO - use this
     self.status = Status.INIT
     self.mode = mode

 def __init__(self):
     super().__init__()
     self.loader = Loader()
     self.shooter = Shooter()
     self.drive = Drive(config.robotDrive, config.leftJoy, config.hsButton,
                        config.alignButton)
     self.componets = [ self.loader, self.shooter, self.drive ]

    def mount(drive_name):
        '''
        Reconnects a drive as a volume.
        Any data on the drive is preserved.
        Returns the volume.
        '''
        drive = Drive.reconnect(drive_name)
        vol = Volume()

        block = drive.read_block(0).split(b'\n')
        volinfosize= int(bytes.decode(block[0]))
        volinfo =b''
        volinfo+=drive.read_block(0)
        if volinfosize!=1:
            for i in range (1,volinfosize+1):
                volinfo+=drive.read_block(i)
        vol.setSize(int(bytes.decode(block[2])))
        vol.setDrive(drive)

        bmpArr =[]
        
        bmp = bytes.decode(volinfo.split(b'\n')[3])

        for i,v in enumerate(bmp):
            if v == 'x':
                bmpArr.append(1)
            else:
                bmpArr.append(0)
        vol.setVolInfo(volinfo)
        vol.setBitmapArray(bmpArr)
        return vol

	def mount(drive_name):
		'''
		Reconnects a drive as a volume.
		Any data on the drive is preserved.
		Returns the volume.
		'''
		drive = Drive.reconnect(drive_name)
		inputt = drive.read_block(0)
		data = inputt.splitlines()
		length = int(data[0])
		i = 1
		while i < length:
			inputt = drive.read_block(i)
			data.extend(inputt.splitlines())
			i+=1
		i = 1
		outcome = False
		
		data[len(data)-1] = data[len(data)-1].rstrip()
	
		while len(data) > (i+1):
			while len(data) > (i+1) and data[i+1].isdigit() == outcome:
				data[i] += data[i+1]
				data.pop(i+1)
			i+=1
			outcome = not outcome
		
		volume = Volume(drive, data[1])
		for i in range(len(data[3])):                #TODO Needs better fix
			if data[3][i] == 120:
				volume.bmap[i] = b'x'
		volume.import_files()

		return volume

class Upload(object):
    """
    TODO interface or abstract class for upload services
    """

    def __init__(self, config, service_type):
        self.__config = config
        if service_type == SERVICE_DRIVE:
            self.service = Drive(config)
        elif service_type == SERVICE_DROPBOX:
            raise NotImplementedError('not implemented yet!')

    def run(self, paths):
        """
        """
        for path in paths:
            self.service.upload(path)
            log_dict(self.service.info)

 def __init__(self, config, service_type):
     self.__config = config
     self.info = {
         'details': []
     }
     if service_type == SERVICE_DRIVE:
         self.service = Drive(config)
     elif service_type == SERVICE_DROPBOX:
         raise NotImplementedError('not implemented yet!')

 def test_long_volume_name(self):
     blocks = 100
     drive_name = 'driveH.txt'
     disk = Drive.format(drive_name, blocks)
     name = b'long volume name' * 100
     volume = Volume.format(disk, name)
     self.assertEqual(name, volume.name())
     self.assertEqual(blocks, volume.size())
     self.assertEqual(99, volume.root_index())
     volume.unmount()

    def mount(drive_name):
        drive = Drive.reconnect(drive_name)
        allVolumeData = drive.read_block(0).decode()
        numOfBlocksUsed = allVolumeData.split('\n',1)[0]
        if int(numOfBlocksUsed)>1:
            for i in range(1,int(numOfBlocksUsed)):
                allVolumeData+=drive.read_block(i).decode() 
                
        data = allVolumeData.split('\n')
        numOfBlocksUsed=int(data[0])
        name = data[1]
        #dont need this
        numOfBlocksInDrive = int(data[2])
        bitmap = data[3]
        rootIndex = int(data[4])
        usedDrives=[False]*numOfBlocksInDrive
        Volume.calculate_volume_data_blocks(name, drive, rootIndex)
        numOfDataBlocks = Volume.calculate_volume_data_blocks(name, drive, rootIndex )
        for i in range(numOfDataBlocks):
            usedDrives[i]=True
        usedDrives[rootIndex]=True
        volume = Volume(drive, name.encode(), rootIndex, usedDrives, numOfBlocksUsed)
        #read the rootdirectory
        rootString = drive.read_block(rootIndex).decode()
        root= rootString.split('\n')
        for i in range(len(root)):
            if root[i].isdigit():
                if int(root[i])!=0:

                    fileData =  volume.drive.read_block(int(root[i])).decode().split('\n')
                    for i in range(0,len(fileData)-1,3):
                        fileName = fileData[i]
                        fileDataLength =  fileData[i+1]
                        fileStart = fileData[i + 2]
                        #then go into the fileStart
                        fileDirectory = volume.drive.read_block(int(fileStart))
                        fileDirectory = fileDirectory.decode().split('\n')
                        dataLocations = []
                        for j in range(len(fileDirectory)):
                            if fileDirectory[j].isdigit():
                                dataLocations.append(fileDirectory[j])
                        #now that we have all the locations of the data, we can read all the locations and concatinate them
                        dataOnFile = b''
                        for k in range(len(dataLocations)):
                            dataOnFile+=volume.drive.read_block(int(dataLocations[k]))
                        #only want the first n bits
                        dataOnFile = dataOnFile[:int(fileDataLength)]    
                        file = volume.open(fileName.encode())
                        file.write(0, dataOnFile)
                        print (file.data)
                    
        #print (root)
        
        return volume
        '''

 def test_reconnect_drive(self):
      blocks = 10
      drive_name = 'driveC.txt'
      drive = Drive.format(drive_name, blocks)
      drive.disconnect()
      with self.assertRaises(IOError):
          Drive.reconnect('badname')
      drive = Drive.reconnect(drive_name)
      self.assertEqual(blocks * Drive.BLK_SIZE, drive.num_bytes())
      name = b'reconnect volume'
      volume = Volume.format(drive, name)
      volume.unmount()
      with self.assertRaises(IOError):
          Volume.mount('driveZ')
      volume = Volume.mount(drive_name)
      self.assertEqual(1, volume.volume_data_blocks())
      self.assertEqual(name, volume.name())
      self.assertEqual(blocks, volume.size())
      self.assertEqual(b'x--------x', volume.bitmap())
      self.assertEqual(9, volume.root_index())
      volume.unmount()

 def test_long_volume_name(self):
      blocks = 10
      drive_name = 'driveB.txt'
      drive = Drive.format(drive_name, blocks)
      name = b'long volume name' * 10
      volume = Volume.format(drive, name)
      self.assertEqual(3, volume.volume_data_blocks())
      self.assertEqual(name, volume.name())
      self.assertEqual(blocks, volume.size())
      self.assertEqual(b'xxx------x', volume.bitmap())
      self.assertEqual(9, volume.root_index())
      volume.unmount()

 def test_file_reads(self):
      volume = Volume.format(Drive.format('driveE.txt', 8), b'file read volume')
      file = volume.open(b'fileA')
      data = b'A different fileA'
      file.write(0, data)
      with self.assertRaises(IOError):
          file.read(30, 1)
      with self.assertRaises(IOError):
          file.read(0, 50)
      self.assertEqual(data, file.read(0, len(data)))
      self.assertEqual(b'if', file.read(3, 2))
      file.write(file.size(), b'Aaargh' * 10)
      self.assertEqual(b'arghAaarghAaargh', file.read(61, 16))
      volume.unmount()

 def test_file_reads(self):
     volume = Volume.format(Drive.format("driveK.txt", 100), b'file read volume')
     file = volume.open(b'fileA')
     data = b'A different fileA' * 10
     file.write(0, data)
     with self.assertRaises(IOError):
         file.read(300, 1)
     with self.assertRaises(IOError):
         file.read(0, 500)
     self.assertEqual(data, file.read(0, len(data)))
     self.assertEqual(b'if', file.read(71, 2))
     file.write(file.size(), b'Aaargh' * 100)
     self.assertEqual(b'AaarghAaargh', file.read(500, 12))
     volume.unmount()

 def test_reconnect_drive_with_files(self):
     drive_name = 'driveF.txt'
     volume = Volume.format(Drive.format(drive_name, 12), b'reconnect with files volume')
     filenames = [b'file1', b'file2', b'file3', b'file4']
     files = [volume.open(name) for name in filenames]
     for i, file in enumerate(files):
         file.write(0, bytes(str(i).encode()) * 64)
     files[0].write(files[0].size(), b'a')
     volume.unmount()
     volume = Volume.mount(drive_name)
     file4 = volume.open(b'file4')
     self.assertEqual(b'3333', file4.read(0, 4))
     file1 = volume.open(b'file1')
     self.assertEqual(65, file1.size())
     self.assertEqual(b'0a', file1.read(63, 2))
     volume.unmount()

 def test_simple_file_creation(self):
     # the Volume didn't call format in the original
     volume = Volume.format(Drive.format('driveD.txt', 8), b'file creation volume')
     with self.assertRaises(ValueError):
      volume.open(b'fileA\n')
     file = volume.open(b'fileA')
     self.assertEqual(0, file.size())
     data = b'Hello from fileA'
     file.write(0, data)
     self.assertEqual(len(data), file.size())
     file.write(file.size(), data)
     self.assertEqual(2 * len(data), file.size())
     file = volume.open(b'fileB')
     data = b'Welcome to fileB'
     file.write(50, data)
     self.assertEqual(50 + len(data), file.size())
     volume.unmount()

 def test_new_volume(self):
     blocks = 10
     drive_name = 'driveA.txt'
     drive = Drive.format(drive_name, blocks)
     with self.assertRaises(ValueError):
         Volume.format(drive, b'')
     with self.assertRaises(ValueError):
         Volume.format(drive, b'Volume\nA')
     with self.assertRaises(ValueError):
         Volume.format(drive, b'a' * blocks * Drive.BLK_SIZE)
     name = b'new volume test'
     volume = Volume.format(drive, name)
     self.assertEqual(1, volume.volume_data_blocks())
     self.assertEqual(name, volume.name())
     self.assertEqual(blocks, volume.size())
     self.assertEqual(b'x--------x', volume.bitmap())
     self.assertEqual(9, volume.root_index())
     volume.unmount()