Internal helper method. Do not call directly.
428192
def sync_events(sync_m, *args)
      if args[0].is_a?(PredictionIO::AsyncResponse)
        response = args[0].get
      else
        response = send(sync_m, *args).get
      end
      return response if response.is_a?(Net::HTTPCreated)
      begin
        msg = response.body
      rescue
        raise NotCreatedError, response
      end
      fail NotCreatedError, msg
    end
12708
def method_missing(name, *args, &block)
      helpers.key?(name) ? helpers.fetch(name).call : super
    end
645970
def coerce(cls, arg):
        """"""
        try:
            return cls(arg).value
        except (ValueError, TypeError):
            raise InvalidParameterDatatype("%s coerce error" % (cls.__name__,))
163189
@CallSuper
    @Override
    protected void onInactive() {
        for (Map.Entry<LiveData<?>, Source<?>> source : mSources) {
            source.getValue().unplug();
        }
    }
681123
def _call(self, x, out=None):
        """"""
        if out is None:
            out = self.scalar * x
        else:
            out.lincomb(self.scalar, x)
        return out
1215888
def update(self, **kwargs):
        """"""
        assert not self.called
        self.kw.update(kwargs)
        return self
1026193
def call(__self, __context, __obj, *args, **kwargs):
        """"""
        # the double prefixes are to avoid double keyword argument
        # errors when proxying the call.
        if not __self.is_safe_callable(__obj):
            raise SecurityError('%r is not safely callable' % (__obj,))
        return __context.call(__obj, *args, **kwargs)
489093
def _forget_annot(self, annot):
        """"""
        aid = id(annot)
        if aid in self._annot_refs:
            self._annot_refs[aid] = None
474388
def _call(self, x, out=None):
        """"""
        # TODO: add optimization in case an operator appears repeatedly in a
        # row
        if out is None:
            out = self.range.zero()
            for i, j, op in zip(self.ops.row, self.ops.col, self.ops.data):
                out[i] += op(x[j])
        else:
            has_evaluated_row = np.zeros(len(self.range), dtype=bool)
            for i, j, op in zip(self.ops.row, self.ops.col, self.ops.data):
                if not has_evaluated_row[i]:
                    op(x[j], out=out[i])
                else:
                    # TODO: optimize
                    out[i] += op(x[j])

                has_evaluated_row[i] = True

            for i, evaluated in enumerate(has_evaluated_row):
                if not evaluated:
                    out[i].set_zero()

        return out
643290
def retrieve(cls, *args, **kwargs):
        """"""
        return super(Reversal, cls).retrieve(*args, **kwargs)
477738
def cancel(self, caller):
        
        for o in {i for i in self.children if isinstance(i, AbstractCallable)}:
            o.cancel(caller)
570820
def callbackShortHelp(option, opt, value, parser):
    ''''''
    # clear usage and description
    parser.set_description(None)
    # parser.set_usage(None)
    # output help
    parser.print_help()
    # exit
    parser.exit()
1138085
def _call(self, x, out=None):
        """"""
        if out is None:
            return self.range.element(copy(self.constant))
        else:
            out.assign(self.constant)
942811
def _call(self, func, out=None, **kwargs):
        """"""
        mesh = self.grid.meshgrid
        if out is None:
            out = func(mesh, **kwargs)
        else:
            with writable_array(out) as out_arr:
                func(mesh, out=out_arr, **kwargs)
        return out
911716
public static <O extends Object> void notNull(O o) {
		if(!validation) return;
		if(o == null)
			throw new ParameterException(ErrorCode.NULLPOINTER);
	}
1177471
def not_called_with(self, *args, **kwargs):
        
        call = Call(*args, **kwargs)
        if call in calls(self.spy):
            raise VerificationError(
                'expected %s to not be called with %s, but it was' % (
                    self.spy, call.formatted_args))
        return True
715019
def _handler(self, sender, setting, value, **kwargs):
        
        if setting.startswith(self.prefix):
            self._set_attr(setting, value)