usbDisk2.py
Aller à la documentation de ce fichier.
# $Id: usbDisk2.py 36 2014-03-16 19:37:27Z georgesk $
licence={}
licence_en="""
file usbDisk2.py
this file is part of the project scolasync. It is a rewrite of
usbDisk.py to take in account udisks2.
Copyright (C) 2014 Georges Khaznadar <georgesk@ofset.org>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
licence['en']=licence_en
dependances="python3-dbus python3-dbus.mainloop.pyqt5"
import dbus, subprocess, os, os.path, re, time, threading, logging, inspect
from dbus.mainloop.glib import DBusGMainLoop, threads_init
from gi.repository import Gio, GLib, UDisks
from PyQt5.QtWidgets import *
debug=False
def inspectData():
return ""
if debug :
logging.basicConfig(level=logging.DEBUG)
def inspectData():
caller=1
callerframerecord = inspect.stack()[caller]
frame = callerframerecord[0]
info = inspect.getframeinfo(frame)
return " -- file={0}, function={1}, line={2}".format(
info.filename, info.function, info.lineno
)
else:
pass
# logging.basicConfig(level=logging.NOTSET)
def safePath(obj):
if type(obj)==type(""):
path=obj
else:
path= obj.get_object_path()
posUnderscore=path.rfind("_")
posSlash=path.rfind("/")
if posUnderscore > posSlash: # il faut retirer tout après l'underscore final
path=path[:posUnderscore]
return path
def fs_size(device):
try:
stat = os.statvfs(device)
except:
return (0, 0)
free = stat.f_bsize * stat.f_bavail # les blocs réservés sont inclus
total = stat.f_bsize * stat.f_blocks
return (total, free)
no_options = GLib.Variant('a{sv}', {})
not_interesting = (
# boucle
'/org/freedesktop/UDisks2/block_devices/loop',
# disque raid
'/org/freedesktop/UDisks2/block_devices/dm_',
# mémoire vive
'/org/freedesktop/UDisks2/block_devices/ram',
'/org/freedesktop/UDisks2/block_devices/zram',
# disques durs
'/org/freedesktop/UDisks2/drives/',
)
# Cette classe a été inspirée par le projet USBcreator.
# Plusieurs modifications ont été faites au code original.
# Les fonctions de rappel ne tiennent compte que des périphériques USB
#
class UDisksBackend:
def __init__(self, logger=logging, diskClass=object):
self.install_thread = None
self.logger=logger
self.diskClass=diskClass
self.targets = {}
self.modified=False
DBusGMainLoop(set_as_default=True)
threads_init()
self.bus = dbus.SystemBus()
self.udisks = UDisks.Client.new_sync(None)
self.manager = self.udisks.get_object_manager()
self.cbHooks = {
'object-added': {
'profile': ['man', 'obj'],
'hooks' : []
},
'object-removed': {
'profile': ['man', 'obj'],
'hooks' : []
},
'interface-added': {
'profile': ['man', 'obj'],
'hooks' : []
},
'interface-removed': {
'profile': ['man', 'obj'],
'hooks' : []
},
'interface-proxy-properties-changed': {
'profile': ['man', 'obj', 'interface'],
'hooks' : []
},
}
# mise en place des fonctions de rappel à utiliser pour tout changement
self.addHook('object-added',
lambda man, obj: self._udisks_obj_added(obj))
self.addHook('object-removed',
lambda man, obj: self._udisks_obj_removed(obj))
self.addHook('interface-added',
lambda man, obj, iface: self._device_changed(obj))
self.addHook('interface-removed',
lambda man, obj, iface: self._device_changed(obj))
self.addHook('interface-proxy-properties-changed',
lambda man, obj, iface, props, invalid: self._device_changed(obj))
# ajoute une fonction à appeler pour un signal nommé, et enregistre
# cette fonction dans self.cbHooks, après vérification de sa liste
# de paramètres.
# @param signal une chaîne
# @param func une fonction
# @return le résultat de l'appel à self.manager.connect(signal,func)
#
def addHook(self, signal, func):
if inspect.getargspec(func).args == self.cbHooks[signal]['profile']:
cb=self.manager.connect(signal,func)
self.cbHooks[signal]['hooks'].append(cb)
return cb
return None
# voir le fichier integration-test issu des sources de udisks2
# Essaie de monter un système de fichier jusqu'à ce qu'il
# cesse d'échouer avec "Busy", ou que l'erreur soit "déjà monté".
# Échoue si l'erreur est autre que les deux précédentes.
# @param fs un système de fichier à monter
# @param timeout nombre de secondes d'attente au maximum
# @param retryDelay délai entre deux essais
#
def retry_mount(self, fs, timeout=5, retryDelay=0.3):
while timeout >= 0:
try:
return fs.call_mount_sync(no_options, None)
except GLib.GError as e:
if 'UDisks2.Error.AlreadyMounted' in e.message:
m=re.match(r".*already mounted[^/]*([^\']+).*",e.message)
return m.group(1)
elif 'UDisks2.Error.DeviceBusy' in e.message:
pass
else:
raise
time.sleep(retryDelay)
timeout -= retryDelay
return ''
def detect_devices(self):
for obj in self.manager.get_objects():
self._udisks_obj_added(obj)
def _interesting_obj(self, obj):
interesting=False
drive=None
partition=None
# ne tient pas compte des périphériques non débranchables
path = safePath(obj)
for boring in not_interesting:
if path.startswith(boring):
return interesting, drive, partition
# ne considère que les périphériques de type block
block = obj.get_block()
if not block:
return interesting, drive, partition
# initialise drive, nom du disque ?
drive_name = block.get_cached_property('Drive').get_string()
if drive_name == '/':
return interesting, drive, partition
else:
drive = self.udisks.get_object(drive_name).get_drive()
# on ne tient pas compte des CDROMS ni DVDROMS
if drive and drive.get_cached_property('Optical').get_boolean():
return interesting, drive, partition
interesting=True
# détermine si on a un disque ou une partition
partition = obj.get_partition()
return interesting, drive, partition
def _udisks_obj_added(self, obj):
interesting, drive, part = self._interesting_obj(obj)
if part:
self._udisks_partition_added(obj, drive, part)
elif drive:
self._udisks_drive_added (obj, drive, part)
return
def objIsUsb(self,obj):
for s in obj.get_block().get_cached_property('Symlinks'):
if b'/dev/disk/by-id/usb' in bytes(s):
return True
return False
# Fonction de rappel pour l'ajout d'une partition,
# met à jour self.targets
# @param obj une instance de UDisksObjectProxy
# @param drive une instance de ...
# @param partition une instance de ...
#
#
# @protected
def _udisks_partition_added(self, obj, drive, partition):
path = safePath(obj)
block = obj.get_block()
self.logger.debug(QApplication.translate("uDisk","Partition ajoutée %s",None) % path+inspectData())
fstype = block.get_cached_property('IdType').get_string()
parent = partition.get_cached_property('Table').get_string()
total = drive.get_cached_property('Size').get_uint64()
free = -1
mount = ''
fs = obj.get_filesystem()
if fs:
mount_points = fs.get_cached_property('MountPoints').get_bytestring_array()
if len(mount_points)>0:
mount= mount_points[0]
if not mount and fstype == 'vfat':
try:
mount = self.retry_mount(fs)
except:
logging.exception(QApplication.translate("uDisk","Échec au montage du disque : %s",None) % path)
if mount:
total, free = fs_size(mount)
isUsb=self.objIsUsb(obj)
if not isUsb:
self.logger.debug(QApplication.translate("uDisk","On n'ajoute pas le disque : partition non-USB",None)+inspectData())
elif total < 1:
self.logger.debug(QApplication.translate("uDisk","On n'ajoute pas le disque : partition vide",None)+inspectData())
else:
udisk=self.diskClass(
path=path, mp=mount, isUsb=isUsb,
vendor=drive.get_cached_property('Vendor').get_string(),
model=drive.get_cached_property('Model').get_string(),
parent=safePath(parent),
fstype=fstype,
serial=block.get_cached_property('Drive').get_string().split('_')[-1],
uuid=block.get_cached_property('IdUUID').get_string(),
free=free,
capacity=total,
device=block.get_cached_property('Device').get_bytestring().decode('utf-8'),
)
self.targets[path] = udisk
self.modified=True
return
def _udisks_drive_added(self, obj, drive, part):
path = safePath(obj)
block = obj.get_block()
if path in self.targets:
self.logger.debug(QApplication.translate("uDisk","Disque déjà ajouté auparavant : %s",None) % path+inspectData())
return
self.logger.debug(QApplication.translate("uDisk","Disque ajouté : %s",None) % path+inspectData())
size = drive.get_cached_property('Size').get_uint64()
"""
if size <= 0:
self.logger.debug(QApplication.translate("uDisk","On n'ajoute pas le disque : partition à 0 octets.",None)+inspectData())
return
"""
isUsb = self.objIsUsb(obj)
if not isUsb:
self.logger.debug(QApplication.translate("uDisk","On n'ajoute pas le disque : partition non-USB",None)+inspectData())
else:
udisk=self.diskClass(
path=path,
isUsb=isUsb,
parent='',
vendor=drive.get_cached_property('Vendor').get_string(),
model=drive.get_cached_property('Model').get_string(),
serial=block.get_cached_property('Drive').get_string().split('_')[-1],
uuid=block.get_cached_property('IdUUID').get_string(),
capacity=size,
device=block.get_cached_property('Device').get_bytestring().decode('utf-8'),
)
self.targets[path] =udisk
self.modified=True
return
def _device_changed(self, obj):
path = safePath(obj)
self.logger.debug(QApplication.translate("uDisk","Changement pour le disque %s",None) % path+inspectData())
# Fonction de rappel déclenchée par le retrait d'un disque.
# Met à jour self.targets
# @param obj une instance de UDisksObjectProxy
#
#
# @protected
def _udisks_obj_removed(self, obj):
path=safePath(obj)
logging.debug(QApplication.translate("uDisk","Disque débranché du système : %s",None) % path)
if path in self.targets:
self.targets.pop(path)
self.modified=True
class uDisk2:
def __init__(self, path, mp='', isUsb=False, vendor='', model='', parent=None,
fstype='', serial='', uuid='',
free=0, capacity=0, device='', firstFat=None, selected=True):
self.path=path
self.mp=mp
self.isUsb=isUsb
self.vendor=vendor
self.model=model
self.parent=parent
self.fstype=fstype
self.stickid=serial
self.uuid=uuid
self.free=free
self.capacity=capacity
self.devStuff=device
self.firstFat=firstFat
self.selected=selected
self.rlock=threading.RLock()
return
_itemNames={
"1mp":QApplication.translate("uDisk","point de montage",None),
"2capacity":QApplication.translate("uDisk","taille",None),
"3vendor":QApplication.translate("uDisk","marque",None),
"4model":QApplication.translate("uDisk","modèle de disque",None),
"5stickid":QApplication.translate("uDisk","numéro de série",None),
}
_specialItems={"0Check":QApplication.translate("uDisk","cocher",None)}
_ItemPattern=re.compile("[0-9]?(.*)")
# renvoie un identifiant unique. Dans cette classe, cette fonction
# est synonyme de file()
# @return un identifiant unique, garanti par le système de fichiers
#
def uniqueId(self):
return self.file()
# Méthode statique, pour avoir des titres de colonne.
# renvoie des titres pour les items obtenus par __getitem__.
# @param locale la locale, pour traduire les titres éventuellement.
# Valeur par défaut : "C"
# @return une liste de titres de colonnes
#
def headers(locale="C"):
result= list(uDisk2._specialItems.keys())+ list(uDisk2._itemNames.keys())
return sorted(result)
headers = staticmethod(headers)
def __str__(self):
return self.title()+self.valuableProperties()
def title(self):
return self.path
def isDosFat(self):
return self.fstype=="vfat"
def isMounted(self):
return bool(self.mp)
def valuableProperties(self,indent=4):
prefix="\n"+" "*indent
r=""
props=["mp", "parent", "fstype", "stickid", "uuid", "vendor", "model", "devStuff", "free", "capacity"]
for prop in props:
r+=prefix+"%s = %s" %(prop, getattr(self,prop))
return r
def mountPoint(self):
return self.mp
# retire le numéro des en-têtes pour en faire un nom de propriété
# valide pour interroger dbus
# @param n un numéro de propriété qui se réfère aux headers
# @return une propriété renvoyée par dbus, dans un format imprimable
#
def unNumberProp(self,n):
m=uDisk2._ItemPattern.match(self.headers()[n])
try:
return getattr(self, m.group(1))
except:
return ""
def __getitem__(self,n):
propListe=self.headers()
if n==0:
return self.selected
elif n <= len(propListe):
return self.unNumberProp(n-1)
def ensureMounted(self):
mount_paths=self.mp
if mount_paths==None: # le cas où la notion de montage est hors-sujet
return ""
leftTries=5
while len(mount_paths)==0 and leftTries >0:
leftTries = leftTries - 1
path=self.path
if len(path)>0:
subprocess.call("udisks --mount %s > /dev/null" %path,shell=True)
paths=self.mp
print("STILL TO DEBUG: is the mount OK? is self.mp updated?")
if paths:
return paths
else:
time.sleep(0.5)
else:
time.sleep(0.5)
if leftTries==0:
raise Exception ("Could not mount the VFAT after 5 tries.")
else:
return mount_paths
class Available (UDisksBackend):
def __init__(self, access="disk", diskClass=uDisk2):
UDisksBackend.__init__(self, diskClass=diskClass)
self.access=access
self.detect_devices()
self.finishInit()
def finishInit(self):
self.mountFirstFats()
# fabrique la liste des partitions FAT,
# monte les partitions FAT si elles ne le sont pas
#
def mountFirstFats(self):
self.firstFats = self.getFirstFats()
if self.access=="firstFat":
for p in self.firstFats:
uDisk2(p,self).ensureMounted()
def __trunc__(self):
return len(self.firstFats)
# Sert à comparer deux collections de disques, par exemple
# une collection passée et une collection présente.
# @param other une instance de Available
# @return vrai si other semble être la même collection de disques USB
#
def compare(self, other):
result=self.summary()==other.summary()
return result
def contains(self, ud):
return ud.path in self.targets
def disks(self):
return [d for d in self.targets if not self.targets[d].parent]
def parts(self, d):
return [p for p in self.targets if self.targets[p].parent==d]
def disks_ud(self):
return [self.targets[d] for d in self.targets if not self.targets[d].parent]
def parts_ud(self, d):
return [self.targets[p] for p in self.targets if self.targets[p].parent==d]
def summary(self):
r= "Available USB disks\n"
r+= "===================\n"
for d in sorted(self.disks()):
r+="%s\n" %(self.targets[d].devStuff)
partlist=self.parts(d)
if len(partlist)>0:
r+=" Partitions :\n"
for part in partlist:
r+=" %s\n" %(self.targets[part].devStuff,)
return r
def __str__(self):
r= "Available USB disks\n"
r+= "===================\n"
for d in self.disks():
r+="%s\n" %d
partlist=self.parts(d)
if len(partlist)>0:
r+=" Partitions :\n"
for part in sorted(partlist):
r+=" %s\n" %(self.targets[part].devStuff)
r+=self.targets[part].valuableProperties(12)+"\n"
return r
# Renvoye le nième disque. Le fonctionnement dépend du paramètre
# self.access
# @param n un numéro
# @return le nième disque USB connecté sous forme d'instance de uDisk2
#
def __getitem__(self, n):
if self.access=="disk":
path=self.targets.keys()[n]
elif self.access=="firstFat":
path=self.firstFats[n]
return self.targets[path]
# Renseigne sur la longueur de la collection. Le fonctionnement
# dépend du paramètre self.access
# @return la longueur de la collection de disques renvoyée
#
def __len__(self):
if self.access=="disk":
return len(self.targets)
elif self.access=="firstFat":
return len(self.firstFats)
# Facilite l'accès aux partitions de type DOS-FAT, et a des effets
# de bord :
# * marque la première vfat dans chaque instance de disque
# * construit une liste des chemins uDisk des FATs
# @return une liste de partitions, constituée de la première
# partition de type FAT de chaque disque USB connecté
#
def getFirstFats(self):
result=[]
disks=[d for d in self.targets if not self.targets[d].parent]
for d in disks:
parts=[p for p in self.targets if self.targets[p].parent==d]
for p in parts:
if self.targets[p].fstype=="vfat":
result.append(p)
# inscrit l'information dans l'instance du disque, par effet de bord
self.targets[d].firstFat=self.targets[p]
return result
def hasDev(self, dev):
s=str(dev)
for p in self.fatPaths:
if p.split("/")[-1]==s:
return True
return False
if __name__=="__main__":
from PyQt5.QtCore import *
from PyQt5.QtGui import *
import sys
class MainWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
# The only thing in the app is a quit button
quitbutton = QPushButton('Examinez le terminal\nbranchez et débranchez des clés USB, puis\nQuittez', self)
quitbutton.clicked.connect(self.close)
self.setCentralWidget(quitbutton)
machin=Available()
print (machin)
def print_targets_if_modif(man, obj):
if machin.modified:
print([s.split("/")[-1] for s in machin.targets.keys()])
machin.modified=False
machin.addHook('object-added', print_targets_if_modif)
machin.addHook('object-removed', print_targets_if_modif)
app = QApplication(sys.argv)
main = MainWindow()
main.show()
sys.exit(app.exec_())
src.usbDisk2.uDisk2.unNumberProp
def unNumberProp(self, n)
Definition: usbDisk2.py:523
src.usbDisk2.safePath
def safePath(obj)
Récupère de façon sûre le path d'une instance de UDisksObjectProxy.
Definition: usbDisk2.py:59
src.usbDisk2.uDisk2.ensureMounted
def ensureMounted(self)
Permet de s'assurer qu'une partition ou un disque sera bien monté
Definition: usbDisk2.py:548
src.usbDisk2.uDisk2.uuid
uuid
Definition: usbDisk2.py:419
src.usbDisk2.UDisksBackend._interesting_obj
def _interesting_obj(self, obj)
trouve si un objet est intéressant à cataloguer
Definition: usbDisk2.py:219
src.usbDisk2.Available.firstFats
firstFats
Definition: usbDisk2.py:609
src.usbDisk2.Available.getFirstFats
def getFirstFats(self)
Definition: usbDisk2.py:734
src.usbDisk2.uDisk2.rlock
rlock
Definition: usbDisk2.py:425
src.usbDisk2.UDisksBackend.__init__
def __init__(self, logger=logging, diskClass=object)
Le constructeur.
Definition: usbDisk2.py:115
src.usbDisk2.UDisksBackend.bus
bus
Definition: usbDisk2.py:127
src.usbDisk2.uDisk2.stickid
stickid
Definition: usbDisk2.py:418
src.usbDisk2.UDisksBackend._udisks_obj_removed
def _udisks_obj_removed(self, obj)
Definition: usbDisk2.py:373
src.usbDisk2.Available.__getitem__
def __getitem__(self, n)
Definition: usbDisk2.py:708
src.usbDisk2.MainWindow
Definition: usbDisk2.py:765
src.usbDisk2.UDisksBackend._udisks_partition_added
def _udisks_partition_added(self, obj, drive, partition)
Definition: usbDisk2.py:285
src.usbDisk2.MainWindow.__init__
def __init__(self)
Definition: usbDisk2.py:766
src.usbDisk2.inspectData
def inspectData()
Definition: usbDisk2.py:36
src.usbDisk2.Available
une classe pour représenter la collection des disques USB connectés
Definition: usbDisk2.py:583
src.usbDisk2.UDisksBackend.install_thread
install_thread
Definition: usbDisk2.py:116
src.usbDisk2.uDisk2.free
free
Definition: usbDisk2.py:420
src.usbDisk2.Available.summary
def summary(self)
Fournit une représentation imprimable d'un résumé
Definition: usbDisk2.py:673
src.usbDisk2.Available.disks_ud
def disks_ud(self)
Récolte les enregistrements de niveau supérieur de self.targets.
Definition: usbDisk2.py:657
src.usbDisk2.uDisk2.isUsb
isUsb
Definition: usbDisk2.py:413
src.usbDisk2.uDisk2.isDosFat
def isDosFat(self)
Permet de reconnaitre les partitions DOS-FAT.
Definition: usbDisk2.py:490
src.usbDisk2.UDisksBackend.manager
manager
Definition: usbDisk2.py:129
src.usbDisk2.uDisk2.__init__
def __init__(self, path, mp='', isUsb=False, vendor='', model='', parent=None, fstype='', serial='', uuid='', free=0, capacity=0, device='', firstFat=None, selected=True)
Le constructeur.
Definition: usbDisk2.py:410
src.usbDisk2.uDisk2.title
def title(self)
Permet d'obtenir un identifiant unique de disque.
Definition: usbDisk2.py:483
src.usbDisk2.Available.__str__
def __str__(self)
Fournit une représentation imprimable.
Definition: usbDisk2.py:689
src.usbDisk2.UDisksBackend.logger
logger
Definition: usbDisk2.py:117
src.usbDisk2.uDisk2.parent
parent
Definition: usbDisk2.py:416
src.usbDisk2.Available.compare
def compare(self, other)
Definition: usbDisk2.py:626
src.usbDisk2.UDisksBackend
Definition: usbDisk2.py:108
src.usbDisk2.Available.finishInit
def finishInit(self)
Fin de l'initialisation.
Definition: usbDisk2.py:601
src.usbDisk2.Available.__init__
def __init__(self, access="disk", diskClass=uDisk2)
Le constructeur.
Definition: usbDisk2.py:592
src.usbDisk2.UDisksBackend.detect_devices
def detect_devices(self)
Fait un inventaire des disques.
Definition: usbDisk2.py:207
src.usbDisk2.fs_size
def fs_size(device)
Renvoie la taille d'un système de fichier et la place disponible.
Definition: usbDisk2.py:74
src.usbDisk2.uDisk2.mountPoint
def mountPoint(self)
Definition: usbDisk2.py:514
src.usbDisk2.uDisk2.model
model
Definition: usbDisk2.py:415
src.usbDisk2.UDisksBackend.diskClass
diskClass
self.targets est un dictionnaire des disques détectés les clés sont les paths et les contenus des ins...
Definition: usbDisk2.py:120
src.usbDisk2.uDisk2.fstype
fstype
Definition: usbDisk2.py:417
src.usbDisk2.uDisk2.isMounted
def isMounted(self)
Definition: usbDisk2.py:496
src.usbDisk2.Available.mountFirstFats
def mountFirstFats(self)
Definition: usbDisk2.py:608
src.usbDisk2.uDisk2.__str__
def __str__(self)
Fournit une représentation imprimable.
Definition: usbDisk2.py:476
src.usbDisk2.uDisk2.valuableProperties
def valuableProperties(self, indent=4)
Facilite l'accès aux propriétés intéressantes d'une instance.
Definition: usbDisk2.py:503
src.usbDisk2.UDisksBackend._udisks_obj_added
def _udisks_obj_added(self, obj)
Fonction de rappel pour les ajouts de disque.
Definition: usbDisk2.py:257
src.usbDisk2.debug
bool debug
activate debugging #######################
Definition: usbDisk2.py:35
QMainWindow
src.usbDisk2.uDisk2.mp
mp
Definition: usbDisk2.py:412
src.usbDisk2.UDisksBackend.addHook
def addHook(self, signal, func)
Definition: usbDisk2.py:172
src.usbDisk2.uDisk2.vendor
vendor
Definition: usbDisk2.py:414
src.usbDisk2.UDisksBackend.modified
modified
self.modified signifie une modification récente, à prendre en compte par une application au niveau ut...
Definition: usbDisk2.py:124
src.usbDisk2.Available.access
access
Definition: usbDisk2.py:594
src.usbDisk2.uDisk2.firstFat
firstFat
Definition: usbDisk2.py:423
QtCore
src.usbDisk2.Available.__trunc__
def __trunc__(self)
Definition: usbDisk2.py:617
src.usbDisk2.Available.disks
def disks(self)
Récolte les enregistrements de niveau supérieur de self.targets.
Definition: usbDisk2.py:642
src.usbDisk2.uDisk2.path
path
Definition: usbDisk2.py:411
src.usbDisk2.Available.parts
def parts(self, d)
Récolte les partitions d'un disque.
Definition: usbDisk2.py:650
src.usbDisk2.uDisk2
une classe pour représenter un disque ou une partition.
Definition: usbDisk2.py:390
src.usbDisk2.UDisksBackend.cbHooks
cbHooks
Definition: usbDisk2.py:130
src.usbDisk2.uDisk2.headers
headers
Definition: usbDisk2.py:470
src.usbDisk2.Available.hasDev
def hasDev(self, dev)
Definition: usbDisk2.py:750
src.usbDisk2.uDisk2.__getitem__
def __getitem__(self, n)
Renvoie un élément de listage de données internes au disque.
Definition: usbDisk2.py:537
src.usbDisk2.UDisksBackend._device_changed
def _device_changed(self, obj)
Definition: usbDisk2.py:362
src.usbDisk2.uDisk2.uniqueId
def uniqueId(self)
Definition: usbDisk2.py:456
src.usbDisk2.uDisk2.selected
selected
Definition: usbDisk2.py:424
src.usbDisk2.uDisk2.capacity
capacity
Definition: usbDisk2.py:421
src.usbDisk2.UDisksBackend._udisks_drive_added
def _udisks_drive_added(self, obj, drive, part)
Definition: usbDisk2.py:328
QtGui
src.usbDisk2.Available.contains
def contains(self, ud)
Permet de déterminer si un disque est dans la collection.
Definition: usbDisk2.py:635
QtWidgets
src.usbDisk2.Available.__len__
def __len__(self)
Definition: usbDisk2.py:720
src.usbDisk2.uDisk2.devStuff
devStuff
Definition: usbDisk2.py:422
src.usbDisk2.UDisksBackend.udisks
udisks
Definition: usbDisk2.py:128
src.usbDisk2.UDisksBackend.targets
targets
Definition: usbDisk2.py:121
src.usbDisk2.UDisksBackend.retry_mount
def retry_mount(self, fs, timeout=5, retryDelay=0.3)
Definition: usbDisk2.py:188
src.usbDisk2.Available.parts_ud
def parts_ud(self, d)
Récolte les partitions d'un disque.
Definition: usbDisk2.py:666
src.usbDisk2.UDisksBackend.objIsUsb
def objIsUsb(self, obj)
détermine si un périphérique est de type USB
Definition: usbDisk2.py:270
src.usbDisk2.print_targets_if_modif
def print_targets_if_modif(man, obj)
Definition: usbDisk2.py:777