Handle responses `DebugBreakEvent`.
347361
def handle_debug_break(self, call_id, payload):
        """"""
        line = payload['line']
        config = self.launcher.config  # TODO: make an attribute of client
        path = os.path.relpath(payload['file'], config['root-dir'])

        self.editor.raw_message(feedback['notify_break'].format(line, path))
        self.debug_thread_id = payload["threadId"]
249881
def handle(self, msg):
        """"""
        debug_msg = ': {!r}'.format(msg) if self.debug else ''
        log.debug('request: %d bytes%s', len(msg), debug_msg)
        buf = io.BytesIO(msg)
        code, = util.recv(buf, '>B')
        if code not in self.methods:
            log.warning('Unsupported command: %s (%d)', msg_name(code), code)
            return failure()

        method = self.methods[code]
        log.debug('calling %s()', method.__name__)
        reply = method(buf=buf)
        debug_reply = ': {!r}'.format(reply) if self.debug else ''
        log.debug('reply: %d bytes%s', len(reply), debug_reply)
        return reply
108418
void handleResponse(ByteBuf response) {
    long requestId = response.readLong();
    byte status = response.readByte();
    switch (status) {
      case SUCCESS:
        try {
          handleResponseSuccess(requestId, readResponse(response));
        } catch (SerializationException e) {
          handleResponseFailure(requestId, e);
        }
        break;
      case FAILURE:
        try {
          handleResponseFailure(requestId, readError(response));
        } catch (SerializationException e) {
          handleResponseFailure(requestId, e);
        }
        break;
    }
    response.release();
  }
1294770
def handle_request(self, msgtype, msgid, method, args, kwargs):
        """"""
        response = None
        error = None
        exception = None

        try:
            response = self.dispatch.call(method, args, kwargs)
        except Exception as e:
            error = (e.__class__.__name__, str(e))
            exception = e

        if isinstance(response, Deferred):
            response.add_callback(self.send_response, msgid)
            response.add_errback(self.send_error, msgid)
        else:
            if exception is None:
                self.send_response(msgid, response)
            else:
                self.send_error(msgid, exception)
318839
def process_response(self, request, response):
        """"""

        # For debug only.
        if not settings.DEBUG:
            return response

        # Check for responses where the data can't be inserted.
        content_encoding = response.get('Content-Encoding', '')
        content_type = response.get('Content-Type', '').split(';')[0]
        if any((getattr(response, 'streaming', False),
                'gzip' in content_encoding,
                content_type not in _HTML_TYPES)):
            return response

        content = force_text(response.content, encoding=settings.DEFAULT_CHARSET)

        pattern = re.escape('</body>')
        bits = re.split(pattern, content, flags=re.IGNORECASE)

        if len(bits) > 1:
            bits[-2] += debug_payload(request, response, self.view_data)
            response.content = "</body>".join(bits)
            if response.get('Content-Length', None):
                response['Content-Length'] = len(response.content)

        return response
528048
def handle_event(self, message):
        """"""
        # _LOGGER.debug(message)
        needs_update = 0
        for zone in self.zones:
            if zone in message:
                _LOGGER.debug("Received message for zone: %s", zone)
                self.zones[zone].update_status(message[zone])

        if 'netusb' in message:
            needs_update += self.handle_netusb(message['netusb'])

        if needs_update > 0:
            _LOGGER.debug("needs_update: %d", needs_update)
            self.update_hass()
360958
@Override
    public void debug() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Response Message: " + this);
            Tr.debug(tc, "Status: " + getStatusCodeAsInt());
            Tr.debug(tc, "Reason: " + getReasonPhrase());
            super.debug();
        }
    }
295091
def handleResponse(self, data):
        """"""

        self.factory.response_xml = data

        if self.status == '200':
            self.factory.parseErrorAndResponse(data)

        self.factory.deferred = None
        self.transport.loseConnection()
332769
def nl_msg_in_handler_debug(msg, arg):
    """"""
    ofd = arg or _LOGGER.debug
    ofd('-- Debug: Received Message:')
    nl_msg_dump(msg, ofd)
    return NL_OK
270781
function () {
        var prefix = 'DEBUG';
        this.output(prefix, prefix.blue, Array.prototype.slice.call(arguments));
    }
1202815
private static void debug(String header, GatekeeperReply reply) {
	if (logger.isTraceEnabled()) {
	    logger.trace(header);
	    logger.trace(reply.toString());
	}
    }
329305
async def handler(event):
    """"""
    await event.delete()

    await event.respond(
        get_docs_message(kind=event.pattern_match.group(1),
                         query=event.pattern_match.group(2)),
        reply_to=event.reply_to_msg_id
    )
524626
def debug(version=False):
    """"""
    if version:
        print(__version__)
        return
    print(json.dumps(MANAGE_DICT, indent=2))
68500
def debug(self, *debugReqs):
        """"""
        return self._client.send(debug=sc2api_pb2.RequestDebug(debug=debugReqs))
86861
def nl_skipped_handler_debug(msg, arg):
    """"""
    ofd = arg or _LOGGER.debug
    ofd('-- Debug: Skipped message: ' + print_header_content(nlmsg_hdr(msg)))
    return NL_SKIP
494710
public void debug(Throwable t) {
        if (isEnabled() && isDebugEnabled()) {
            dispatchLogException(new LogEvent(this, LogEvent.DEBUG_TYPE, t));
        }
    }
834960
def handler(self, event):
        """"""

        if self.escape(event):  # A chance to escape
            self.stop()
        elif self.diagnostic:
            self._diagnostic(event)
        else:
            self._tap(event)
        #This is needed according to the pyHook tutorials 'http://sourceforge.net/apps/mediawiki/pyhook/index.php?title=PyHook_Tutorial'
        return True