def __init__(self,skipNIAs):
     self.VENDOR_ID = 0x1234 #: Vendor Id
     self.PRODUCT_ID = 0x0000 #: Product Id for the bridged usb cable
     self.TIME_OUT = 100
     self.handle = None
     self.device = None
     buses = usb.busses()
     found = False
     for bus in buses :
         for device in bus.devices :
             if device.idVendor == self.VENDOR_ID and device.idProduct == self.PRODUCT_ID:
                 if skipNIAs ==0:
                     self.device = device 
                     self.config = self.device.configurations[0]
                     self.interface = self.config.interfaces[0][0]
                     self.ENDPOINT1 = self.interface.endpoints[0].address
                     self.ENDPOINT2 = self.interface.endpoints[1].address
                     self.PACKET_LENGTH1 = self.interface.endpoints[0].maxPacketSize
                     self.PACKET_LENGTH2 = self.interface.endpoints[1].maxPacketSize
                     found = True
                     break
                 else:
                     skipNIAs -= 1
         if found:
             break

 def get_device(self):
     for bus in usb.busses():
         for device in bus.devices:
             if (device.idVendor == self.VENDOR_ID and
                 device.idProduct in self.POSSIBLE_PRODUCTS):
                 return device
     raise NoBuddyFound

    def devices(vendor_id=None, product_id=None):
        usb_devices = [d for b in usb.busses() for d in b.devices
                       if d.deviceClass == USB_CLASS_PER_INTERFACE
                       and d.idVendor == vendor_id
                       and d.idProduct == product_id]

        return [HIDDevice(u) for u in usb_devices]

def search_usb(device):
    '''
    Takes either None, specifying that any USB device in the
    global vendor and product lists are acceptable, or takes
    a string that identifies a device in the format
    <BusNumber>:<DeviceNumber>, and returns the pyUSB objects
    for bus and device that correspond to the identifier string.
    '''
    if device == None:
        busNum = None
        devNum = None
    else:
        if ':' not in device:
            raise KBInterfaceError("USB device format expects <BusNumber>:<DeviceNumber>, but got {0} instead.".format(device))
        busNum, devNum = map(int, device.split(':', 1))
    if USBVER == 0:
        busses = usb.busses()
        for bus in busses:
            dev = search_usb_bus_v0x(bus, busNum, devNum)
            if dev != None:
                return (bus, dev)
        return None #Note, can't expect a tuple returned
    elif USBVER == 1:
        return usb.core.find(custom_match=findFromListAndBusDevId(busNum, devNum, usbVendorList, usbProductList)) #backend=backend, 
    else:
        raise Exception("USB version expected to be 0.x or 1.x.")

def find_sixaxes():
  res = []
  for bus in usb.busses():
    for dev in bus.devices:
      if dev.idVendor == vendor and dev.idProduct == product:
        res.append(dev)
  return res

 def get_device(self) :
     buses = usb.busses()
     for bus in buses :
         for device in bus.devices :
             if device.idVendor == self.idVendor and device.idProduct == self.idProduct :
                     return device
     return None

 def is_available():
     for bus in usb.busses():
         for device in bus.devices:
             if (device.idVendor == ID_VENDOR_GTEC and
                 device.idProduct == ID_PRODUCT_GUSB_AMP):
                 return True
     return False

 def __init__(self):
     self.dh = None
     footswitch = None
     self.iface = None
     self.location = None
     for bus in usb.busses():
         for dev in bus.devices:
             if dev.idVendor == VENDOR_ID and dev.idProduct == PRODUCT_ID:
                 footswitch = dev
                 self.location = (bus.dirname, dev.filename)
                 break
     if footswitch is None:
         raise BackendError("Device not found")
     for intf in footswitch.configurations[0].interfaces:
         if intf[0].interfaceNumber == INTERFACE_NUMBER:
             self.iface = intf
     self.dh = footswitch.open()
     # TODO: flaky after an ACPI suspend
     self.dh.reset()
     # This sometimes fails, and then errno doesn't get reset
     # so subsequent errors are still populated with this.
     try:
         self.dh.detachKernelDriver(self.iface[0])
     except usb.USBError as e:
         if 'Operation not permitted' in e.message:
             raise BackendError("Permission denied while removing kernel driver")
     self.dh.claimInterface(self.iface[0])

def find_device(vendor, product):
    for bus in usb.busses():
        for device in bus.devices:
            if device.idVendor == vendor \
                    and device.idProduct == product:
                        return device
    return None

	def JobTask(self):
		LinkState = 0
		if fileExists('/sys/class/net/wlan0/operstate'):
			LinkState = open('/sys/class/net/wlan0/operstate').read()
			if LinkState != 'down':
				LinkState = open('/sys/class/net/wlan0/operstate').read()
		elif fileExists('/sys/class/net/eth0/operstate'):
			LinkState = open('/sys/class/net/eth0/operstate').read()
			if LinkState != 'down':
				LinkState = open('/sys/class/net/eth0/carrier').read()
		LinkState = LinkState[:1]
		if fileExists("/proc/stb/lcd/symbol_network") and config.lcd.mode.value == '1':
			open("/proc/stb/lcd/symbol_network", "w").write(str(LinkState))
		elif fileExists("/proc/stb/lcd/symbol_network") and config.lcd.mode.value == '0':
			open("/proc/stb/lcd/symbol_network", "w").write('0')

		USBState = 0
		busses = usb.busses()
		for bus in busses:
			devices = bus.devices
			for dev in devices:
				if dev.deviceClass != 9 and dev.deviceClass != 2 and dev.idVendor > 0:
# 						print ' '
# 						print "Device:", dev.filename
# 						print "  Number:", dev.deviceClass
# 						print "  idVendor: %d (0x%04x)" % (dev.idVendor, dev.idVendor)
# 						print "  idProduct: %d (0x%04x)" % (dev.idProduct, dev.idProduct)
					USBState = 1
		if fileExists("/proc/stb/lcd/symbol_usb") and config.lcd.mode.value == '1':
			open("/proc/stb/lcd/symbol_usb", "w").write(str(USBState))
		elif fileExists("/proc/stb/lcd/symbol_usb") and config.lcd.mode.value == '0':
			open("/proc/stb/lcd/symbol_usb", "w").write('0')

		self.timer.startLongTimer(30)

 def _findDevice(self):
     """Find the vendor and product ID on the USB bus."""
     for bus in usb.busses():
         for dev in bus.devices:
             if dev.idVendor == self.vendor_id and dev.idProduct == self.product_id:
                 return dev
     return None

def find_keyboard_device():
    for bus in usb.busses():
        for device in bus.devices:
	    print device
            if device.idVendor == USB_VENDOR and \
               device.idProduct == USB_PRODUCT or device.idProduct == USB_OTHER_PRODUCT:
                return device

def find_usb_devices():
    busses = usb.busses()

    devobjs = []
    for dev in usb.core.find(find_all=True):
        serialno = None
        if dev.iSerialNumber > 0:
            try:
                serialno = dev.serial_number
            except usb.USBError:
                pass
            except ValueError:
                pass

        did = None
        try:
            did = '%04x' % dev.bcdDevice
        except TypeError:
            pass

        devobjs.append(
            LibDevice(
                vid=dev.idVendor,
                pid=dev.idProduct,
                did=did,
                serialno=serialno,
                path=Path(
                    bus=dev.bus,
                    address=dev.address)))
    return devobjs

def init(n=0): #opens the device, returns its deviceHandle
	import usb
	#global dh
	b=usb.busses()
	d=b[0].devices[n]
	print "DEVICE ",n,": PID:", d.idProduct ," VID: ",d.idVendor,", devnum: ",d.devnum
	dh=d.open()
	print "manuf:",dh.getString(d.iManufacturer,1000),", SN:",dh.getString(d.iSerialNumber,1000)
	c=d.configurations[0]
	try:
		print "config:",c.value,",",dh.getString(c.iConfiguration,1000)
	except:
		pass
	ifs=c.interfaces
	i=ifs[0][0]
	es=i.endpoints
	for e in es:
		if e.address>=128:
			ei=e.address
		else:
			eo=e.address
	dh.setConfiguration(c)
	global dhG
	try:
		dh.claimInterface(i)
		dhG=dh
	except usb.USBError:
		print "					INTERFACE WAS BUSY; RELEASING..."
		dhG.releaseInterface()
		#dh.releaseInterface()
		dh.claimInterface(i)
		dhG=dh
	return {"hnd":dh,"in":ei,"out":eo}

def get_g9_device():
    for bus in usb.busses():
        for device in bus.devices:
            if device.idVendor == G9_VENDOR_ID \
                    and device.idProduct in G9_PRODUCT_IDS:
                return device.open()
    return None

	def enumTry(self):
		busses = usb.busses()
		for bus in busses:
			devices = bus.devices
			for dev in devices:
				print "Devices: ", dev.filename
				print " Device Class: ", dev.deviceClass
				print " Device Subclass: ", dev.deviceSubClass
				print " Device Protocol: ", dev.deviceProtocol
				print " Device max packet size: ", dev.maxPacketSize
				print " ID Vendor: ", dev.idVendor
				print " ID Product: ", dev.idProduct
				print " Device Version: ", dev.deviceVersion
				for config in dev.configurations:
					print "  Configuration: ", config.value
					print "   Total Length: ", config.totalLength
					print "   Self powered: ", config.selfPowered
					print "   Remote Wakeup: ", config.remoteWakeup
					print "   Max Power: ", config.maxPower
					for intf in config.interfaces:
						print "    Interface: ", intf[0].interfaceNumber
						for alt in intf:
							print "    Alternate Setting:",alt.alternateSetting
							print "      Interface class:",alt.interfaceClass
							print "      Interface sub class:",alt.interfaceSubClass
							print "      Interface protocol:",alt.interfaceProtocol
							for ep in alt.endpoints:
								print "      Endpoint:",hex(ep.address)
								print "        Type:",ep.type
								print "        Max packet size:",ep.maxPacketSize
								print "        Interval:",ep.interval

def find_bricks(host=None, name=None):
	# FIXME: probably should check host and name
	for bus in usb.busses():
		for device in bus.devices:
			if device.idVendor == ID_VENDOR_LEGO and \
			   device.idProduct == ID_PRODUCT_NXT:
				yield USBSock(device)

 def _find_device(idVendor, idProduct):
     for bus in usb.busses():
         for dev in bus.devices:
             if dev.idVendor == idVendor and \
                     dev.idProduct == idProduct:
                 return dev
     return None

def search_usb(device, vendor=None, product=None):
    busses = usb.busses()
    for bus in busses:
        dev = search_usb_bus(bus, device)
        if dev != None:
            return (bus, dev)
    return (None, None)

    def __send_initalization(self):

        usbdev = None
        for bus in usb.busses():
            for dev in bus.devices:
                if dev.idVendor == 0x3333:
                    usbdev = dev
        if usbdev is None:
            raise IOError('Could not find laser device (3333:5555) ...')

        handle = usbdev.open()

        print 'Initializing device ... ',
        initlog = open(os.path.dirname(os.path.abspath(__file__))+'/usbinit.log')

        for line in initlog.readlines():
            setup_packet = line.split('|')[0]
            buf = line.split('|')[-1]
            if len(buf):
                values = setup_packet.strip().split(' ')
                reqType = int(values[0],16)
                req = int(values[1],16)
                value = int(values[2],16)*256+int(values[3],16)
                index = int(values[4],16)*256+int(values[5],16)
                length = int(values[6],16)*256+int(values[7],16)

                binbuf = ''
                for byte in buf.strip().split(' '):
                    binbuf += chr(int(byte,16))

                handle.controlMsg(reqType,req,binbuf,value,index)

        print 'done'
        time.sleep(1)