u'''ring the bell if requested.
185851
def _bell(self):
        '''
        if self.bell_style == u'none':
            pass
        elif self.bell_style == u'visible':
            raise NotImplementedError(u"Bellstyle visible is not implemented yet.")
        elif self.bell_style == u'audible':
            self.console.bell()
        else:
            raise ReadlineError(u"Bellstyle %s unknown."%self.bell_style)
600875
def hello(self):
        """"""
        path = 'hello'
        response = self.request(path, do_authentication=False)
        return response
1106434
def initiate(self):
        """"""
        if not self.model.officer.is_item_allowed(self.model, self._name):
            return defer.succeed(None)

        if not callable(self._enabled):
            d = defer.succeed(self._enabled)
        else:
            context = self.model.make_context(key=self.name)
            d = self._enabled(None, context)
        return d.addCallback(lambda f: self if f else None)
146782
def enter(self):
        """"""
        self._communication.send(StartRequest,
                                 self._communication.left_end_needle,
                                 self._communication.right_end_needle)
757556
function CallRequest(flags, ttl, tracing, service, headers, csum, args) {
    this.type = CallRequest.TypeCode;
    this.flags = flags || 0;
    this.ttl = ttl || 0;
    this.tracing = tracing || Tracing.emptyTracing;
    this.service = service || '';
    this.headers = headers || {};
    this.csum = Checksum.objOrType(csum);
    this.args = args || [];
    this.cont = null;
}
75316
def handleNotification(self, handle, data):
        """"""
        _LOGGER.debug("Got notification from %s: %s", handle, codecs.encode(data, 'hex'))
        if handle in self._callbacks:
            self._callbacks[handle](data)
171744
def signal_handler(self, *args):
        
        self.user_callback(self.signal, self.user_arg, *args)
1284311
def call( severity, time, progname, msg )
      return if msg.blank? || _silence?( msg )

      msg = [
        _tagged( time, :timestamp ),
        _tagged( progname, :progname ),
        formatted_severity_tag( severity ),
        formatted_message( severity, msg )
      ].compact.join(" ")

      super severity, time, progname, msg
    end
229093
function serviceCall(req, res, next) {
        connector.runCall(req.params.connection, req.params.call, req.body).then(res.json.bind(res), next).done();
    }
208731
def handleNotification(self, req):
        """"""
        name = req["method"]
        params = req["params"]
        try: #to get a callable obj 
            obj = getMethodByName(self.service, name)
            rslt = obj(*params)
        except:
            pass
1006376
function forOwn(obj, fn, thisObj){
        forIn_1(obj, function(val, key){
            if (hasOwn_1(obj, key)) {
                return fn.call(thisObj, obj[key], key, obj);
            }
        });
    }
1220380
public void requestDone() {
        currentRequest = null;

        if (anyAreSet(state, CLOSE_REQ)) {
            safeClose(connection);
        } else if (anyAreSet(state, UPGRADE_REQUESTED)) {
            safeClose(connection); //we don't support upgrade, just close the connection to be safe
            return;
        }

        AjpClientExchange next = pendingQueue.poll();

        if (next != null) {
            initiateRequest(next);
        }
    }
415877
def on(self):
        """"""
        msg = X10Send.unit_code_msg(self.address.x10_housecode,
                                    self.address.x10_unitcode)
        self._send_method(msg)

        msg = X10Send.command_msg(self.address.x10_housecode,
                                  X10_COMMAND_ON)
        self._send_method(msg, False)
        self._update_subscribers(0xff)
153239
function ask(question, cbk, skip) {
      if (skip) {
        cbk(skip);
        return;
      }
      self.prompt(question, function(answ) {
        if (String(answ.answer).trim() === "") {
          return ask(question, cbk);
        } else {
          cbk(answ.answer);
        }
      });
    }
186778
def confirm_operation(prompt, prefix=None, assume_yes=False, err=False):
    """"""
    if assume_yes:
        return True

    prefix = prefix or click.style(
        "Are you %s certain you want to" % (click.style("absolutely", bold=True))
    )

    prompt = "%(prefix)s %(prompt)s?" % {"prefix": prefix, "prompt": prompt}

    if click.confirm(prompt, err=err):
        return True

    click.echo(err=err)
    click.secho("OK, phew! Close call. :-)", fg="green", err=err)
    return False
365921
def call
      return broadcast(:invalid) unless user&.invited_to_sign_up?

      user.invite!(user.invited_by, invitation_instructions: instructions)

      broadcast(:ok)
    end
1374736
function DetectUbuntu()
   {
      if (($this->DetectUbuntuPhone() == $this->true)
		|| ($this->DetectUbuntuTablet() == $this->true))
         return $this->true; 
      else
         return $this->false; 
   }