r"""Release an interface previously claimed with claimInterface.
965123
def releaseInterface(self):
        """
        util.release_interface(self.dev, self.__claimed_interface)
        self.__claimed_interface = -1
63165
def _cb_inform_interface_change(self, msg):
        """"""
        self._logger.debug('cb_inform_interface_change(%s)', msg)
        self._interface_changed.set()
364279
async def claimTask(self, *args, **kwargs):
        

        return await self._makeApiCall(self.funcinfo["claimTask"], *args, **kwargs)
16480
def release(self):
        
        query = 'DELETE FROM {cf} WHERE "lockId"=:lockId AND "claimId"=:claimId;'
        d = self._client.execute(query.format(cf=self._lock_table),
                                 {'lockId': self._lock_id, 'claimId': self._claim_id},
                                 ConsistencyLevel.QUORUM)

        def _log_release_time(result):
            if self._log and self._lock_acquired_seconds is not None:
                seconds = self._reactor.seconds() - self._lock_acquired_seconds
                self._log.msg('Released lock. Was held for {0} seconds'.format(seconds),
                              lock_held_time=seconds, result=result, **self._log_kwargs)
            return result

        return d.addBoth(_log_release_time)
585149
def obsolete_client(func):
    """"""

    @functools.wraps(func)
    def new_func(*args, **kwargs):
        raise ObsoleteException(
            "{} has been removed from this version of the library. "
            "Please refer to current documentation for guidance."
            .format(func.__name__)
        )

    return new_func
1055613
def resume(env, identifier):
    """"""

    vsi = SoftLayer.VSManager(env.client)
    vs_id = helpers.resolve_id(vsi.resolve_ids, identifier, 'VS')
    env.client['Virtual_Guest'].resume(id=vs_id)
1117472
def release(self):
        """"""
        if not self.acquired:
            raise threading.ThreadError("Unable to release an unacquired"
                                        " lock")
        try:
            self.unlock()
        except IOError:
            self.logger.exception("Could not unlock the acquired lock opened"
                                  " on `%s`", self.path)
        else:
            self.acquired = False
            try:
                self._do_close()
            except IOError:
                self.logger.exception("Could not close the file handle"
                                      " opened on `%s`", self.path)
            else:
                self.logger.log(_utils.BLATHER,
                                "Unlocked and closed file lock open on"
                                " `%s`", self.path)
310155
def release(self) -> None:
        """"""
        if self._value >= self._initial_value:
            raise ValueError("Semaphore released too many times")
        super(BoundedSemaphore, self).release()
486061
def releaseNetToMs():
    """"""
    a = TpPd(pd=0x3)
    b = MessageType(mesType=0x2d)  # 00101101
    c = CauseHdr(ieiC=0x08, eightBitC=0x0)
    d = CauseHdr(ieiC=0x08, eightBitC=0x0)
    e = FacilityHdr(ieiF=0x1C, eightBitF=0x0)
    f = UserUserHdr(ieiUU=0x7E, eightBitUU=0x0)
    packet = a / b / c / d / e / f
    return packet
807922
def releaseCompleteNetToMs(Cause_presence=0, Facility_presence=0,
                           UserUser_presence=0):
    """"""
    a = TpPd(pd=0x3)
    b = MessageType(mesType=0x2a)  # 00101010
    packet = a / b
    if Cause_presence is 1:
        c = CauseHdr(ieiC=0x08, eightBitC=0x0)
        packet = packet / c
    if Facility_presence is 1:
        d = FacilityHdr(ieiF=0x1C, eightBitF=0x0)
        packet = packet / d
    if UserUser_presence is 1:
        e = UserUserHdr(ieiUU=0x7E, eightBitUU=0x0)
        packet = packet / e
    return packet
1254686
def release_client(self, cb):
        
        cb.stop_using()
        self._q.put(cb, True)
648758
def _interface_exists(self, interface):
        """"""
        ios_cfg = self._get_running_config()
        parse = HTParser(ios_cfg)
        itfcs_raw = parse.find_lines("^interface " + interface)
        return len(itfcs_raw) > 0
1283706
def getGenericInterface(interfaceVersion):
    
    error = EVRInitError()
    result =     _openvr.VR_GetGenericInterface(interfaceVersion, byref(error))
    _checkInitError(error.value)
    return result
735990
def release(cls, entity, unit_of_work):
        
        if not hasattr(entity, '__everest__'):
            raise ValueError('Trying to unregister an entity that has not '
                             'been registered yet!')
        elif not unit_of_work is entity.__everest__.unit_of_work:
            raise ValueError('Trying to unregister an entity that has been '
                             'registered with another session!')
        delattr(entity, '__everest__')
929521
protected void release() {
		stack.getLocalTransactions().remove(Integer.valueOf(localTID));
		stack.getRemoteTxToLocalTxMap().remove(Integer.valueOf(remoteTID));
		cancelTHISTTimerTask();
		cancelLongtranTimer();
		cancelReTransmissionTimer();
		
		if(originalPacket!=null)
			stack.releasePacket(originalPacket);
		
		originalPacket=null;
	}
1271679
def release(self):
        
        self.parent.send(('release-account', self.account_hash))

        response = self.parent.recv()
        if isinstance(response, Exception):
            raise response

        if response != 'ok':
            raise ValueError('unexpected response: ' + repr(response))
801588
def migration(resource, version, previous_version=''):
    """"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            migrated = func(*args, **kwargs)

            return migrated

        m = Migration(wrapper, resource, version, previous_version)
        m.register()

        return m

    return decorator