Unregister an USB-unrelated fd from poller.
        Convenience method.
515556
def unregister(self, fd):
        
        if fd in self.__fd_set:
            raise ValueError(
                'This fd is a special USB event fd, it must stay registered.'
            )
        self.__poller.unregister(fd)
1166966
def poll_ignore_interrupts(fds, timeout=None):
    ''''''

    if timeout is not None:
        end_time = time.time() + timeout

    poller = select.poll()
    for fd in fds:
        poller.register(fd, select.POLLIN | select.POLLPRI | select.POLLHUP | select.POLLERR)

    while True:
        try:
            timeout_ms = None if timeout is None else timeout * 1000
            results = poller.poll(timeout_ms)
            return [afd for afd, _ in results]
        except InterruptedError:
            err = sys.exc_info()[1]
            if err.args[0] == errno.EINTR:
                # if we loop back we have to subtract the
                # amount of time we already waited.
                if timeout is not None:
                    timeout = end_time - time.time()
                    if timeout < 0:
                        return []
            else:
                # something else caused the select.error, so
                # this actually is an exception.
                raise
1174840
def remove_callback(self, handle):
        """"""
        if self._poll is None:
            raise RuntimeError('poll instance is closed')
        remove_callback(self, handle)
        if handle.extra & READABLE:
            self._readers -= 1
        if handle.extra & WRITABLE:
            self._writers -= 1
        self._sync()
278973
def destroy(self):
        '''
        
        '''
        # We borrowed the local clients poller so give it back before
        # it's destroyed. Reset the local poller reference.
        super(Syndic, self).destroy()
        if hasattr(self, 'local'):
            del self.local

        if hasattr(self, 'forward_events'):
            self.forward_events.stop()
1040579
def remove_watcher(self, fd):
        """"""
        if not isinstance(fd, int):
            fd = fd.fileno()

        if fd not in self.callbacks:
            return

        self.callbacks.pop(fd, None)
        self.epoll.unregister(fd)
250475
def remove_port_profile_to_delete(self, profile_name, device_id):
        """"""
        with self.session.begin(subtransactions=True):
            self.session.query(ucsm_model.PortProfileDelete).filter_by(
                profile_id=profile_name, device_id=device_id).delete()
307139
def unregister_file(path, pkg=None, conn=None):  # pylint: disable=W0612
    '''
    
    '''
    close = False
    if conn is None:
        close = True
        conn = init()

    conn.execute('DELETE FROM files WHERE path=?', (path, ))
    if close:
        conn.close()
907017
def _unset(self, pos):
        """"""
        assert 0 <= pos < self.len
        self._datastore.unsetbit(pos)
1150645
def delete_fw_device(self, tenant_id, fw_id, data):
        
        drvr_dict, mgmt_ip = self.sched_obj.get_fw_dev_map(fw_id)
        ret = drvr_dict.get('drvr_obj').delete_fw(tenant_id, data)
        # FW DB gets deleted, so no need to remove the MGMT IP
        if ret:
            self.sched_obj.deallocate_fw_dev(fw_id)
        return ret
60479
def reset_poller(poll=None):
    
    state.poller = poll or poller.best()
    log.info("resetting fd poller, using %s" % type(state.poller).__name__)
641429
def unmount(self, force=None, auth_no_user_interaction=None):
        """"""
        return self._M.Filesystem.Unmount(
            '(a{sv})',
            filter_opt({
                'force': ('b', force),
                'auth.no_user_interaction': ('b', auth_no_user_interaction),
            })
        )
1199765
def close(self):
        
        if self.fd:
            os.close(self.fd)
            self.fd = None
323606
function unlinkFromCuratedDeviceEvents() {
        self.curatedDevice.removeListener(
            'DEVICE_DISCONNECTED',
            curatedDeviceDisconnected
        );
        self.curatedDevice.removeListener(
            'DEVICE_RECONNECTED',
            curatedDeviceReconnected
        );
        self.curatedDevice.removeListener(
            'DEVICE_ERROR',
            curatedDeviceError
        );
        self.curatedDevice.removeListener(
            'DEVICE_RECONNECTING',
            curatedDeviceReconnecting
        );
        self.curatedDevice.removeListener(
            'DEVICE_ATTRIBUTES_CHANGED',
            cureatedDeviceAttributesChanged
        );
    }
619830
def remove_callback(self, fd, handle):
        
        if self._mpoll is None:
            raise RuntimeError('Poller instance is closed')
        mpoll = self._mpoll.get(fd)
        if mpoll is None:
            raise ValueError('not watching fd {}'.format(fd))
        mpoll.remove_callback(handle)
1288861
def unregister(self, uuid):
        
        schema = self._schbyuuid.pop(uuid)

        # clean schemas by name
        self._schbyname[schema.name].remove(schema)
        if not self._schbyname[schema.name]:
            del self._schbyname[schema.name]
1221011
def off(device):
    '''
    
    '''
    cmd = 'quotaoff {0}'.format(device)
    __salt__['cmd.run'](cmd, python_shell=False)
    return True
230836
def unassign(pid_type, pid_value):
    """"""
    from .models import PersistentIdentifier

    obj = PersistentIdentifier.get(pid_type, pid_value)
    obj.unassign()
    db.session.commit()
    click.echo(obj.status)