The number of rings a device with
		the :attr:`~libinput.constant.DeviceCapability.TABLET_PAD`
		capability provides.

		Returns:
			int: The number of rings or 0 if the device has no rings.
		Raises:
			AttributeError
16649
def num_rings(self):
		

		num = self._libinput.libinput_device_tablet_pad_get_num_rings(
			self._handle)
		if num < 0:
			raise AttributeError('This device is not a tablet pad device')
		return num
493141
def unmanaged_devices(self):
        
        if not self.__unmanaged_devices:
            self.__unmanaged_devices = UnmanagedDevices(self.__connection)
        return self.__unmanaged_devices
1137965
def mps_device_memory_limit():
    
    lib = _load_tcmps_lib()
    if lib is None:
        return None

    c_size = _ctypes.c_uint64()
    ret = lib.TCMPSMetalDeviceMemoryLimit(_ctypes.byref(c_size))
    return c_size.value if ret == 0 else None
648536
def get_xid_device(device_number):
    
    scanner = XidScanner()
    com = scanner.device_at_index(device_number)
    com.open()
    return XidDevice(com)
1149693
def _check_device_number(self, devices):
        '''
        '''

        if len(devices) < 2 or len(devices) > 4:
            msg = 'The number of devices to cluster is not supported.'
            raise ClusterNotSupported(msg)
1066328
def hasInfo(self):
        
        count = len([None
                     for (fromUUID, size)
                     in Diff.theKnownSizes[self.uuid].iteritems()
                     if size is not None and fromUUID is not None
                     ])
        return count > 0
1344906
def is_touched(self, pin):
        
        assert pin >= 0 and pin < 12, 'pin must be between 0-11 (inclusive)'
        t = self.touched()
        return (t & (1 << pin)) > 0
421459
def cardinality(self):
        
        data = clips.data.DataObject(self._env)

        lib.EnvSlotCardinality(
            self._env, self._cls, self._name, data.byref)

        return tuple(data.value) if isinstance(data.value, list) else ()
460382
def get_devices(self):
        
        url = self.base_url + '/net/home_auto_query.lua'
        response = self.session.get(url, params={
            'sid': self.sid,
            'command': 'AllOutletStates',
            'xhr': 0,
        }, timeout=15)
        response.raise_for_status()
        data = response.json()
        count = int(data["Outlet_count"])
        devices = []
        for i in range(1, count + 1):
            device = Device(
                int(data["DeviceID_{0}".format(i)]),
                int(data["DeviceConnectState_{0}".format(i)]),
                int(data["DeviceSwitchState_{0}".format(i)])
            )
            devices.append(device)
        return devices
678599
def devices(self):
        
        data = self.query(MyPlexDevice.key)
        return [MyPlexDevice(self, elem) for elem in data]
273336
int getCurrentDevicePriority() {
        if (mIODevice == null)
        {
            return -1;
        }
        for (PriorityIoDeviceTuple tuple : mCompatibleDevices)
        {
            if (tuple.getIoDevice().equals(mIODevice))
            {
                return tuple.getPriority();
            }
        }
        return -1;
    }
290494
def device_class(self, device_class):
        
        if device_class is not None and len(device_class) > 32:
            raise ValueError("Invalid value for `device_class`, length must be less than or equal to `32`")

        self._device_class = device_class
550942
def tableType( self ):
        
        if not self._tableType:
            if self._tableTypeName:
                self._tableType = Orb.instance().model(nstr(self._tableTypeName))
            
        return self._tableType
915976
def Devices(args):
    
    for d in adb_commands.AdbCommands.Devices():
        if args.output_port_path:
            print('%s\tdevice\t%s' % (
                d.serial_number, ','.join(str(p) for p in d.port_path)))
        else:
            print('%s\tdevice' % d.serial_number)
    return 0
1257357
def delete(self, device_id: int):
        
        device = self._get_or_abort(device_id)
        session.delete(device)
        session.commit()
        return '', 204
1081937
def active_devices(self, active_devices):
        
        if active_devices is None:
            raise ValueError("Invalid value for `active_devices`, must not be `None`")
        if active_devices is not None and active_devices < 0:
            raise ValueError("Invalid value for `active_devices`, must be a value greater than or equal to `0`")

        self._active_devices = active_devices
216866
def search_device_by_id(self, deviceID) -> Device:
        
        for d in self.devices:
            if d.id == deviceID:
                return d
        return None