home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_805 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  6.1 KB  |  222 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __license__ = 'GPL v3'
  5. __copyright__ = '2008, Kovid Goyal <kovid at kovidgoyal.net>'
  6. import sys
  7. import os
  8. import re
  9. from threading import RLock
  10. from calibre import iswindows, isosx, plugins, islinux
  11. osx_scanner = None
  12. win_scanner = None
  13. linux_scanner = None
  14. if iswindows:
  15.     
  16.     try:
  17.         win_scanner = plugins['winutil'][0].get_usb_devices
  18.     raise RuntimeError('Failed to load the winutil plugin: %s' % plugins['winutil'][1])
  19.  
  20. elif isosx:
  21.     
  22.     try:
  23.         osx_scanner = plugins['usbobserver'][0].get_usb_devices
  24.     raise RuntimeError('Failed to load the usbobserver plugin: %s' % plugins['usbobserver'][1])
  25.  
  26.  
  27.  
  28. class Drive(str):
  29.     
  30.     def __new__(self, val, order = 0):
  31.         typ = str.__new__(self, val)
  32.         typ.order = order
  33.         return typ
  34.  
  35.  
  36.  
  37. class WinPNPScanner(object):
  38.     
  39.     def __init__(self):
  40.         self.scanner = None
  41.         if iswindows:
  42.             self.scanner = plugins['winutil'][0].get_removable_drives
  43.             self.lock = RLock()
  44.         
  45.  
  46.     
  47.     def drive_is_ok(self, letter, debug = False):
  48.         import win32api
  49.         import win32file
  50.         self.lock.__enter__()
  51.         
  52.         try:
  53.             oldError = win32api.SetErrorMode(1)
  54.             
  55.             try:
  56.                 ans = True
  57.                 
  58.                 try:
  59.                     win32file.GetDiskFreeSpaceEx(letter + ':\\')
  60.                 except:
  61.                     self.lock.__exit__
  62.                     self.lock
  63.                     ans = False
  64.  
  65.                 return ans
  66.             finally:
  67.                 win32api.SetErrorMode(oldError)
  68.  
  69.         finally:
  70.             pass
  71.  
  72.  
  73.     
  74.     def drive_order(self, pnp_id):
  75.         order = 0
  76.         match = re.search('REV_.*?&(\\d+)', pnp_id)
  77.         if match is not None:
  78.             order = int(match.group(1))
  79.         
  80.         return order
  81.  
  82.     
  83.     def __call__(self, debug = False):
  84.         if self.scanner is None:
  85.             return { }
  86.         
  87.         try:
  88.             drives = self.scanner(debug)
  89.         except:
  90.             self.scanner is None
  91.             drives = { }
  92.             if debug:
  93.                 import traceback
  94.                 traceback.print_exc()
  95.             
  96.  
  97.         remove = set([])
  98.         for letter in drives:
  99.             if not self.drive_is_ok(letter, debug = debug):
  100.                 remove.add(letter)
  101.                 continue
  102.             self.scanner is None
  103.         
  104.         for letter in remove:
  105.             drives.pop(letter)
  106.         
  107.         ans = { }
  108.         for key, val in drives.items():
  109.             val = [ x.upper() for x in val ]
  110.             val = _[2]
  111.             if val:
  112.                 ans[Drive(key + ':\\', order = self.drive_order(val[-1]))] = val[-1]
  113.                 continue
  114.             []
  115.         
  116.         return ans
  117.  
  118.  
  119. win_pnp_drives = WinPNPScanner()
  120.  
  121. class LinuxScanner(object):
  122.     SYSFS_PATH = os.environ.get('SYSFS_PATH', '/sys')
  123.     
  124.     def __init__(self):
  125.         self.base = os.path.join(self.SYSFS_PATH, 'subsystem', 'usb', 'devices')
  126.         if not os.path.exists(self.base):
  127.             self.base = os.path.join(self.SYSFS_PATH, 'bus', 'usb', 'devices')
  128.         
  129.         self.ok = os.path.exists(self.base)
  130.  
  131.     
  132.     def __call__(self):
  133.         ans = set([])
  134.         if not self.ok:
  135.             raise RuntimeError('DeviceScanner requires the /sys filesystem to work.')
  136.         self.ok
  137.         for x in os.listdir(self.base):
  138.             base = os.path.join(self.base, x)
  139.             ven = os.path.join(base, 'idVendor')
  140.             prod = os.path.join(base, 'idProduct')
  141.             bcd = os.path.join(base, 'bcdDevice')
  142.             man = os.path.join(base, 'manufacturer')
  143.             serial = os.path.join(base, 'serial')
  144.             prod_string = os.path.join(base, 'product')
  145.             dev = []
  146.             
  147.             try:
  148.                 dev.append(int('0x' + open(ven).read().strip(), 16))
  149.             except:
  150.                 continue
  151.  
  152.             
  153.             try:
  154.                 dev.append(int('0x' + open(prod).read().strip(), 16))
  155.             except:
  156.                 continue
  157.  
  158.             
  159.             try:
  160.                 dev.append(int('0x' + open(bcd).read().strip(), 16))
  161.             except:
  162.                 continue
  163.  
  164.             
  165.             try:
  166.                 dev.append(open(man).read().strip())
  167.             except:
  168.                 dev.append('')
  169.  
  170.             
  171.             try:
  172.                 dev.append(open(prod_string).read().strip())
  173.             except:
  174.                 dev.append('')
  175.  
  176.             
  177.             try:
  178.                 dev.append(open(serial).read().strip())
  179.             except:
  180.                 dev.append('')
  181.  
  182.             ans.add(tuple(dev))
  183.         
  184.         return ans
  185.  
  186.  
  187. linux_scanner = None
  188. if islinux:
  189.     linux_scanner = LinuxScanner()
  190.  
  191.  
  192. class DeviceScanner(object):
  193.     
  194.     def __init__(self, *args):
  195.         if isosx and osx_scanner is None:
  196.             raise RuntimeError('The Python extension usbobserver must be available on OS X.')
  197.         osx_scanner is None
  198.         if iswindows:
  199.             pass
  200.         elif isosx:
  201.             pass
  202.         
  203.         self.scanner = linux_scanner
  204.         self.devices = []
  205.  
  206.     
  207.     def scan(self):
  208.         self.devices = self.scanner()
  209.  
  210.     
  211.     def is_device_connected(self, device, debug = False, only_presence = False):
  212.         return device.is_usb_connected(self.devices, debug = debug, only_presence = only_presence)
  213.  
  214.  
  215.  
  216. def main(args = sys.argv):
  217.     return 0
  218.  
  219. if __name__ == '__main__':
  220.     sys.exit(main())
  221.  
  222.