Warn every time a fn is called.
494952
def deprecated(message):
    """"""
    def decorator(fn):
        @functools.wraps(fn)
        def new_fn(*args, **kwargs):
            deprecate(message)
            return fn(*args, **kwargs)
        return new_fn
    return decorator
1193186
def _notify_fn(self):
        """"""
        self._notifyrunning = True
        while self._notifyrunning:
            try:
                with IHCController._mutex:
                    # Are there are any new ids to be added?
                    if self._newnotifyids:
                        self.client.enable_runtime_notifications(
                            self._newnotifyids)
                        self._newnotifyids = []

                changes = self.client.wait_for_resource_value_changes()
                if changes is False:
                    self.re_authenticate(True)
                    continue
                for ihcid in changes:
                    value = changes[ihcid]
                    if ihcid in self._ihcevents:
                        for callback in self._ihcevents[ihcid]:
                            callback(ihcid, value)
            except Exception as exp:
                self.re_authenticate(True)
287684
def call_fn_name(token):
        """"""
        if token.attr is not None:
            return '%s_%i' % (token.kind, token.attr)
        else:
            return '%s_0' % (token.kind)
609095
def warn(self, msg, *args, **kwargs):
    """"""
    if six.PY3:
      warnings.warn("The 'warn' method is deprecated, use 'warning' instead",
                    DeprecationWarning, 2)
    self.log(logging.WARN, msg, *args, **kwargs)
567025
public void warn(Marker marker, String msg, Throwable t) {
        if (!logger.isWarnEnabled(marker))
            return;
        if (instanceofLAL) {
            ((LocationAwareLogger) logger).log(marker, fqcn, LocationAwareLogger.WARN_INT, msg, null, t);
        } else {
            logger.warn(marker, msg, t);
        }
    }
1367145
def calledThrice(cls, spy): #pylint: disable=invalid-name
        
        cls.__is_spy(spy)
        if not (spy.calledThrice):
            raise cls.failException(cls.message)
928771
def warn(self, text):
		
		self.logger.warn("{}{}".format(self.message_prefix, text))
69709
function notify() {
    var args = arguments
    handlers.forEach(function(f){ f.apply(null, args) }) }
407610
def warning_on(*args)
      options = (args[-1].kind_of?(Hash) ? args.pop : {})
      each_changed_file(options[:in] || [:all]) do |file|
        Open3.popen3("fgrep -nH \"#{args.join("\n")}\" #{file}") do |stdin, stdout, stderr|
          err = stdout.read
          err.split("\n").each do |msg|
            args.each do |string|
              @result.warn("#{msg.split(" ").first} contains #{string}") if msg =~ /#{string}/
            end
          end
        end
      end
    end
624046
def _warning(self, msg, node_id, ex, *args, **kwargs):
        

        raises = self.raises(ex) if callable(self.raises) else self.raises

        if raises and isinstance(ex, DispatcherError):
            ex.update(self)
            raise ex

        self._errors[node_id] = msg % ((node_id, ex) + args)
        node_id = '/'.join(self.full_name + (node_id,))

        if raises:
            raise DispatcherError(msg, node_id, ex, *args, sol=self, **kwargs)
        else:
            kwargs['exc_info'] = kwargs.get('exc_info', 1)
            log.error(msg, node_id, ex, *args, **kwargs)
553720
def worker_warning_captured(self, warning_message, when, item):
        """"""
        kwargs = dict(warning_message=warning_message, when=when, item=item)
        self.config.hook.pytest_warning_captured.call_historic(kwargs=kwargs)
56495
def worker_logwarning(self, message, code, nodeid, fslocation):
        """"""
        kwargs = dict(message=message, code=code, nodeid=nodeid, fslocation=fslocation)
        self.config.hook.pytest_logwarning.call_historic(kwargs=kwargs)
379030
function () {
        var prefix = 'WARN';
        this.output(prefix, prefix.yellow, Array.prototype.slice.call(arguments));
    }
38493
function onError (fn) {
  callbacks.push(fn);
  if (window.onerror != handler) {
    callbacks.push(window.onerror);
    window.onerror = handler;
  }
}
33656
function when (condition, fn, interval) {
  if (condition()) return callback.async(fn);

  var ref = setInterval(function () {
    if (!condition()) return;
    callback(fn);
    clearInterval(ref);
  }, interval || 10);
}
392277
def warn(message)
      (m = filter(message, :warn)) && each {|l| l.warn(m)}
    end
474406
def warning(self, request, message, extra_tags='', fail_silently=False):
        """"""
        add(self.target_name, request, constants.WARNING, message, extra_tags=extra_tags,
            fail_silently=fail_silently)