def disk(self):
try:
if os.name == "nt":
import win32file
disk_path_data = os.popen("wmic logicaldisk get name").read()
disklist = disk_path_data.split()
disklist.remove('Name')
diskinfoall = {}
for path in disklist:
res_list = win32file.GetDiskFreeSpace(str(path + "\\"))
disk_dict = {}
res_list = win32file.GetDiskFreeSpace(path)
disk_ava = res_list[0] * res_list[1] * res_list[2]
disk_sum = res_list[0] * res_list[1] * res_list[3]
disk_use = disk_sum - disk_ava
disk_use_per = disk_use / (disk_sum * 1.0)
disk_dict['disk_use'] = disk_use
disk_dict['disk_ava'] = disk_ava
disk_dict['disk_sum'] = disk_sum
disk_dict['disk_use_per'] = disk_use_per
diskinfoall[path] = disk_dict
elif os.name == "posix":
mount = commands.getoutput('mount -v')
lines = mount.split('\n')
mount_list = map(lambda line: line.split()[2], lines)
mount_list_dit = [
'/proc', '/sys', '/dev/pts', '/proc/sys/fs/binfmt_misc'
]
for i in mount_list_dit:
mount_list.remove(i)
diskinfoall = {}
for path in mount_list:
diskinfo = os.statvfs(path)
disk_dict = {}
disk_use = (diskinfo.f_blocks -
diskinfo.f_bfree) * diskinfo.f_bsize / 1024
disk_ava = (diskinfo.f_bavail) * diskinfo.f_bsize / 1024
disk_sum = (diskinfo.f_blocks) * diskinfo.f_bsize / 1024
disk_use_per = (diskinfo.f_blocks - diskinfo.f_bfree) * 100.00 / \
(diskinfo.f_blocks - diskinfo.f_bfree + diskinfo.f_bavail) + 1
if disk_use == 0:
disk_use_per = 0
disk_dict['disk_use'] = disk_use
disk_dict['disk_ava'] = disk_ava
disk_dict['disk_sum'] = disk_sum
disk_dict['disk_use_per'] = disk_use_per
diskinfoall[path] = disk_dict
except BaseException, e:
msg = 'This Is Exception,(%s)' % e
logging.info(msg)
def collectData(self):
"""Collect disk usage data.
"""
self.data.datahash = {}
self.data.mounthash = {}
drives = win32perf.getDriveNames(filter=(win32perf.DRIVE_FIXED,
win32perf.DRIVE_REMOVABLE))
drives = [d[:-1] for d in drives
if d not in ('A:\\', 'B:\\')] # remove '\'; ignore A: & B:
for fs in drives:
try:
fsinfo = win32file.GetDiskFreeSpace(fs + '\\')
except pywintypes.error, err:
log.log(
"<df>dfList.collectData(): pywintypes.error, %s" % (err),
7)
continue # skip invalid drives
assert len(fsinfo) == 4
p = df(fs, fsinfo)
self.data.datahash[fs] = p # dictionary of filesystem devices
self.data.mounthash[
fs] = p # dictionary of mount points (hmm, same)
def FreeSpace(driverootpath):
"return approx free bytes left"
try:
t=win32file.GetDiskFreeSpace(driverootpath)
return t[2]*t[1]*t[0]
except:
return -1
def diskFreeSpace(path):
import win32file
ppath = path.parent
while ppath != ppath.parent:
ppath = ppath.parent
secPerClu, bytePerSec, freeClu, totClu = win32file.GetDiskFreeSpace(ppath)
return secPerClu * bytePerSec * freeClu
def get_fs_info(caption="D:"):
'''
获取磁盘信息
'''
if uname != 'Windows':
return True
try:
# 有可能不在 d:
sectorsPerCluster, bytesPerSector, numFreeClusters, totalNumClusters = win32file.GetDiskFreeSpace(
caption)
freespace = (numFreeClusters * sectorsPerCluster *
bytesPerSector) / (1024 * 1024 * 1024)
except:
log("can't stat disk space of %s" % caption,
project='recording',
level=2)
freespace = 16
log('get_fs_info ret free space %d' % freespace,
project='recording',
level=4)
if freespace < 15: #小于10G的时候开始清理空间
return True
else:
return False
def get_drivestats():
#This retrieves the amount of free space on the drive in bytes
drive = os.path.splitdrive(os.getcwd())[0].rstrip(':')
sectPerCluster, bytesPerSector, freeClusters, totalClusters = \
win32file.GetDiskFreeSpace(drive + ":\\")
free_space = freeClusters*sectPerCluster*bytesPerSector
return free_space, drive
def freespace(p):
"""
Returns the number of free bytes on the drive that p is on
"""
secsPerClus, bytesPerSec, nFreeClus, totClus = win32file.GetDiskFreeSpace(
p)
return secsPerClus * bytesPerSec * nFreeClus
def _windows_space(cls, prefix):
if not prefix:
return 0, 0
prefix = prefix[:-1]
import win32file, winerror
try:
sectors_per_cluster, bytes_per_sector, free_clusters, total_clusters = \
win32file.GetDiskFreeSpace(prefix)
except Exception as err:
if getattr(err, 'args', [None])[0] == winerror.ERROR_NOT_READY:
# Disk not ready
time.sleep(3)
sectors_per_cluster, bytes_per_sector, free_clusters, total_clusters = \
win32file.GetDiskFreeSpace(prefix)
else: raise
mult = sectors_per_cluster * bytes_per_sector
return total_clusters * mult, free_clusters * mult
def total_blocks():
'''
Return the total number of blocks remaining.
'''
if sys.platform == "win32":
sectPerCluster, bytesPerSector, freeClusters, totalClusters = win32file.GetDiskFreeSpace(
get_base_dir())
return totalClusters
else:
return os.statvfs(get_base_dir()).f_blocks
def getWindowsDiskInfo(filePath):
import win32file
if not os.path.isdir(filePath): filePath = os.path.dirname(filePath)
filePath = getShortPath(filePath)
sectorsPer, bytesPer, numFree, totalNum = win32file.GetDiskFreeSpace(
filePath)
disk_space = (sectorsPer * bytesPer * numFree) / 1024
max_space = (sectorsPer * bytesPer * totalNum) / 1024
used_space = max_space - disk_space
return disk_space, used_space, max_space
def freespace(p):
"""Returns the number of bytes free under directory `p`"""
if sys.platform == 'win32': # pragma: no cover
# os.statvfs doesn't work on Windows
import win32file # pylint: disable=import-error
secsPerClus, bytesPerSec, nFreeClus, _ = win32file.GetDiskFreeSpace(p)
return secsPerClus * bytesPerSec * nFreeClus
r = os.statvfs(p) # os.statvfs is Unix-only pylint: disable=no-member
return r.f_frsize * r.f_bavail
def bytes_remaining():
'''
Return the number of bytes available on the system.
'''
if sys.platform == "win32":
sectPerCluster, bytesPerSector, freeClusters, totalClusters = win32file.GetDiskFreeSpace(
get_base_dir())
return sectPerCluster * bytesPerSector * totalClusters
else:
stats = os.statvfs(get_base_dir())
return stats.f_frsize * stats.f_bavail
def total_bytes():
'''
Return the size of the file system in bytes.
'''
if sys.platform == "win32":
sectPerCluster, bytesPerSector, freeClusters, totalClusters = win32file.GetDiskFreeSpace(
get_base_dir())
return sectPerCluster * bytesPerSector * totalClusters
else:
stats = os.statvfs(get_base_dir())
return stats.f_frsize * stats.f_blocks
def __init__(self, main_window, company_name, software_name):
QDialog.__init__(self)
self.setWindowTitle("Open Drive")
self.setWindowFlags(Qt.CustomizeWindowHint | Qt.WindowTitleHint
| Qt.WindowCloseButtonHint)
self.main_window = main_window
# Set up UI
loader = QtUiTools.QUiLoader()
this_dir = os.path.dirname(__file__)
self.ui = loader.load(os.path.join(this_dir, 'drives.ui'), self)
layout = QVBoxLayout()
layout.addWidget(self.ui)
self.setLayout(layout)
QMetaObject.connectSlotsByName(self)
# Size constraints
self.setMinimumSize(self.ui.minimumSize())
self.setMaximumSize(self.ui.maximumSize())
# Read settings
self.settings = QSettings(company_name, software_name)
self.restoreGeometry(self.settings.value("Drives/geometry"))
self.ui.driveTree.setColumnCount(2)
self.ui.driveTree.setHeaderLabels(['Drive', 'Description'])
main_window.get_tree_header_width(self.ui.driveTree, 'drives')
self.view = None
# Populate drive list
if win32file is not None:
drives = win32api.GetLogicalDriveStrings()
drive_list = drives.strip('\x00').split('\x00')
for drive in drive_list:
try:
space = win32file.GetDiskFreeSpace(drive)
size = space[0] * space[1] * space[3]
newItem = QTreeWidgetItem(
[drive, "{0:.2f} GB".format(size / 1024**3)])
except pywintypes.error as err:
newItem = QTreeWidgetItem([drive, err.strerror])
newItem.drive = drive
self.ui.driveTree.addTopLevelItem(newItem)
else:
QtGui.QMessageBox.critical(
self, "pywin32 not found",
"""Pywin32 is required to be able to use this feature.
Install it (if you are using Windows) and try again.""")
# If we call close directly, the dialog will remain open.
invoke_in_main_thread(self.close)
def freespace(p):
"Returns the number of bytes free under directory `p`"
if sys.platform == 'win32': # pragma: no cover
# os.statvfs doesn't work on Windows
import win32file
secsPerClus, bytesPerSec, nFreeClus, totClus = win32file.GetDiskFreeSpace(
p)
return secsPerClus * bytesPerSec * nFreeClus
else:
r = os.statvfs(p)
return r.f_frsize * r.f_bavail
def get_drivestats(drive=None):
'''
drive for instance 'C'
returns total_space, free_space and drive letter
'''
# if no drive given, pick the current working directory's drive
if drive == None:
drive = os.path.splitdrive(os.getcwd())[0].rstrip(':')
sectPerCluster, bytesPerSector, freeClusters, totalClusters = \
win32file.GetDiskFreeSpace(drive + ":\\")
total_space = totalClusters * sectPerCluster * bytesPerSector
free_space = freeClusters * sectPerCluster * bytesPerSector
return total_space, free_space, drive
def percent_remaining():
'''
Return the percent (as a number between 0 and 1)
available for writing on the file system.
'''
if sys.platform == "win32":
return 1.0
# simulated
sectPerCluster, bytesPerSector, freeClusters, totalClusters = win32file.GetDiskFreeSpace(
get_base_dir())
return sectPerCluster * bytesPerSector * totalClusters
else:
stats = os.statvfs(get_base_dir())
return 1.0 * stats.f_bavail / stats.f_blocks
def getDriveInfo(driveletter):
drivepath = driveletter + ":\\"
sectPerCluster, bytesPerSector, freeClusters, totalClusters = win32file.GetDiskFreeSpace(
drivepath)
total_space = totalClusters * sectPerCluster * bytesPerSector
free_space = freeClusters * sectPerCluster * bytesPerSector
label = win32api.GetVolumeInformation(drivepath)[0]
if label == "":
label = "NO_LABEL"
return (label, driveletter, drivepath, round(total_space * 1e-9),
round(free_space * 1e-9))
def GetWinDriveSpace(drive):
"""
For Windows.
Return a tuple (<free space in bytes>, <total space in bytes>) or
(None, None). Call system method ``win32file.GetDiskFreeSpace``.
"""
try:
sectorsPerCluster, bytesPerSector, numFreeClusters, totalNumClusters = win32file.GetDiskFreeSpace(
drive + ":\\")
sectorsPerCluster = int(sectorsPerCluster)
bytesPerSector = int(bytesPerSector)
numFreeClusters = int(numFreeClusters)
totalNumClusters = int(totalNumClusters)
except:
return None, None
return float(numFreeClusters * sectorsPerCluster * bytesPerSector), float(
totalNumClusters * sectorsPerCluster * bytesPerSector)
def get_disk_free_space(filepath):
"""
Returns the number of free bytes on the drive that filepath is on
"""
if os.name == 'nt':
import win32file
secs_per_cluster, bytes_per_sector, free_clusters, total_clusters = win32file.GetDiskFreeSpace(filepath) #pylint: disable=no-member
return secs_per_cluster * bytes_per_sector * free_clusters
else:
# like shutil
def disk_usage(path):
# pylint: disable=no-member
# no error
st = os.statvfs(path)
free = st.f_bavail * st.f_frsize
total = st.f_blocks * st.f_frsize
used = (st.f_blocks - st.f_bfree) * st.f_frsize
return (total, used, free)
total, used, free = disk_usage(filepath)
return free
def win32_detect_removable_drives(self):
for drive in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
try:
drive = drive + ':'
if win32file.GetDriveType(
drive) != win32file.DRIVE_REMOVABLE: #will be changed
r = win32file.GetDiskFreeSpace(drive)
capacity = r[3] * r[0] * r[1] / (
1024**2
) #capacity = totalClusters*sectPerCluster*bytesPerSector as MegaByte
print capacity
print r
self.drives[drive] = {
'label': 'label',
'mount': drive,
'size': capacity,
'device': drive,
'is_mount': 1 # will be edited
}
except:
pass
def free_space(path):
"""
Gets the free space available at 'path'
:param path: the path to check
:type path: string
:returns: the free space at path in bytes
:rtype: int
:raises InvalidPathError: if the path is not valid
"""
if not os.path.exists(path):
raise InvalidPathError("%s is not a valid path" % path)
if windows_check():
import win32file
sectors, bytes, free, total = map(long, win32file.GetDiskFreeSpace(path))
return (free * sectors * bytes)
else:
disk_data = os.statvfs(path.encode("utf8"))
block_size = disk_data.f_bsize
return disk_data.f_bavail * block_size
def read_into_buffer(self, pos):
space = win32file.GetDiskFreeSpace(self.drive_name)
self.bytes_per_sector = space[1]
self.file_size = space[0] * space[1] * space[3]
#print("Reading file block: ", pos)
#print("-- {0} bytes per sector".format(self.bytes_per_sector))
#print("-- drive size : {0:.2f} GB".format(self.file_size / 1024**3))
try:
drive_device_name = "\\\\.\\" + self.drive_name.strip("\\")
hfile = win32file.CreateFile(
drive_device_name, win32file.GENERIC_READ,
win32file.FILE_SHARE_READ
| win32file.FILE_SHARE_WRITE, None, win32file.OPEN_EXISTING,
win32file.FILE_ATTRIBUTE_NORMAL
| win32file.FILE_FLAG_RANDOM_ACCESS, None)
# Set the read position. It is important that
# we read a multiple of the sector size.
win32file.SetFilePointer(hfile, pos, win32file.FILE_BEGIN)
self.buffer_length = self.buffer_max_length
if pos + self.buffer_length > self.file_size:
self.buffer_length = self.file_size - pos
result = win32file.ReadFile(hfile, self.buffer_length)
win32file.CloseHandle(hfile)
except pywintypes.error as err:
if err.winerror == 5:
raise Exception("Access denied.\n\nAdministrator privileges "
"are required to open drives.\nUse File->"
"Elevate Process.")
else:
raise Exception(err.strerror)
self.buffer = result[1]
self.view = memoryview(self.buffer)
self.buffer_start = pos
def getDiskSize(self):
import win32file
try:
freespace = 0
disksize = 0
drives=[]
sign=win32file.GetLogicalDrives()
drive_all=["A:\\","B:\\","C:\\","D:\\","E:\\","F:\\","G:\\","H:\\","I:\\","J:\\","K:\\","L:\\","M:\\","N:\\","O:\\","P:\\","Q:\\","R:\\","S:\\","T:\\","U:\\","V:\\","W:\\","X:\\","Y:\\","Z:\\"]
for i in range(25):
if (sign & 1<<i):
if win32file.GetDriveType(drive_all[i]) == 3:
space = win32file.GetDiskFreeSpace(drive_all[i])
#print space
freespace += space[0]*space[1]*space[2]
disksize += space[0]*space[1]*space[3]
return (freespace,disksize)
except Exception as myException:
self.logger.error(myException)
return (0,0)
def freespace(p):
secsPerClus, bytesPerSec, nFreeClus, totClus = win32file.GetDiskFreeSpace(
p)
return secsPerClus * bytesPerSec * nFreeClus
def win32_get_total_size(drive=None):
r = win32file.GetDiskFreeSpace('C:')
capacity = r[3] * r[0] * r[1] / (
1024**2
) #capacity = totalClusters*sectPerCluster*bytesPerSector as MegaByte
return capacity
def getfreespace(path):
[spc, bps, nfc, tnc] = win32file.GetDiskFreeSpace(path)
return long(nfc) * long(spc) * long(bps)
def get_free_disk_space(path):
spc, bps, fc, tc = win32file.GetDiskFreeSpace(
os_path.splitdrive(os_path.abspath(path))[0])
return spc * bps * fc // 1048576
def process2(self):
drivetype = {
0: 'DRIVE_UNKNOWN',
1: 'DRIVE_NO_ROOT_DIR',
2: 'DRIVE_REMOVABLE',
3: 'DRIVE_FIXED',
4: 'DRIVE_REMOTE',
5: 'DRIVE_CDROM',
6: 'DRIVE_RAMDISK'
}
FILE_NAMED_STREAMS = 262144
FILE_PERSISTENT_ACLS = 0x00000008
FILE_READ_ONLY_VOLUME = 0x00080000
FILE_SEQUENTIAL_WRITE_ONCE = 0x00100000
FILE_SUPPORTS_ENCRYPTION = 0x00020000
FILE_SUPPORTS_EXTENDED_ATTRIBUTES = 0x00800000
FILE_SUPPORTS_HARD_LINKS = 0x00400000
FILE_SUPPORTS_OBJECT_IDS = 0x00010000
FILE_SUPPORTS_OPEN_BY_FILE_ID = 0x01000000
FILE_SUPPORTS_REPARSE_POINTS = 0x00000080
FILE_SUPPORTS_SPARSE_FILES = 0x00000040
FILE_SUPPORTS_TRANSACTIONS = 0x00200000
FILE_SUPPORTS_USN_JOURNAL = 0x02000000
FILE_UNICODE_ON_DISK = 0x00000004
FILE_VOLUME_IS_COMPRESSED = 0x00008000
FILE_VOLUME_QUOTAS = 0x00000020
drives = win32api.GetLogicalDriveStrings()
drives = drives.split('\000')[:-1]
# 2print(drives[0])
choose = input()
for drive in drives:
if choose in drive:
choose = drive
type = win32file.GetDriveType(choose)
print(drivetype[type], "\n")
volume = win32api.GetVolumeInformation(choose)
print('serial number: ', volume[1])
print('name of fail system: ', volume[4], '\n')
if (volume[3] & FILE_CASE_PRESERVED_NAMES):
print("The specified volume supports preserved case of file names when it places a name on disk.")
if (volume[3] & FILE_CASE_SENSITIVE_SEARCH):
print("The specified volume supports casesensitive file names.")
if (volume[3] & FILE_FILE_COMPRESSION):
print("The specified volume supports file-based compression.")
if (volume[3] & FILE_NAMED_STREAMS):
print("The specified volume supports named streams.")
if (volume[3] & FILE_PERSISTENT_ACLS):
print("The specified volume preserves and enforces access control lists (ACL).")
if (volume[3] & FILE_READ_ONLY_VOLUME):
print("The specified volume is read-only.")
if (volume[3] & FILE_SEQUENTIAL_WRITE_ONCE):
print("The specified volume supports a single sequential write.")
if (volume[3] & FILE_SUPPORTS_ENCRYPTION):
print("The specified volume supports the Encrypted File System (EFS).")
if (volume[3] & FILE_SUPPORTS_EXTENDED_ATTRIBUTES):
print("The specified volume supports extended attributes.")
if (volume[3] & FILE_SUPPORTS_HARD_LINKS):
print("The specified volume supports hard links")
if (volume[3] & FILE_SUPPORTS_OBJECT_IDS):
print("The specified volume supports object identifiers.")
if (volume[3] & FILE_SUPPORTS_OPEN_BY_FILE_ID):
print("The file system supports open by FileID.")
if (volume[3] & FILE_SUPPORTS_REPARSE_POINTS):
print("The specified volume supports reparse points.")
if (volume[3] & FILE_SUPPORTS_SPARSE_FILES):
print("The specified volume supports sparse files.")
if (volume[3] & FILE_SUPPORTS_TRANSACTIONS):
print("The specified volume supports transactions.")
if (volume[3] & FILE_SUPPORTS_USN_JOURNAL):
print("The specified volume supports update sequence number (USN) journals.")
if (volume[3] & FILE_UNICODE_ON_DISK):
print("The specified volume supports Unicode in file names as they appear on disk.")
if (volume[3] & FILE_VOLUME_IS_COMPRESSED):
print("The specified volume is a compressed volume, for example, a DoubleSpace volume.")
if (volume[3] & FILE_VOLUME_QUOTAS):
print("The specified volume supports disk quotas.")
space = win32file.GetDiskFreeSpace(choose)
free_space = space[0] * space[1] * space[2] #/ 1024 / 1024
total_space = space[0] * space[1] * space[3] #/ 1024 / 1024
print('free space:', free_space, '\n')
print('total space:', total_space, '\n')
def freespace(disk):
sectorsPerCluster, bytesPerSector, numFreeClusters, totalNumClusters = \
win32file.GetDiskFreeSpace(disk)
mbytes = (numFreeClusters * sectorsPerCluster * bytesPerSector) / (
1024 * 1024) #get free space
return str(int(mbytes)) + 'MBytes'
