Update the callsafety data structure
496549
def _update_callsafety(self, response):
        
        if self.ratelimit is not None:
            self.callsafety['lastcalltime'] = time()
            self.callsafety['lastlimitremaining'] = int(response.headers.get('X-Rate-Limit-Remaining', 0))
1353318
def _update(self, data):
        """"""
        for k, v in six.iteritems(data):
            new_value = v
            if isinstance(v, dict):
                new_value = type(self)(v)
            elif isinstance(v, list):
                new_value = [(type(self)(e) if isinstance(e, dict) else e)
                             for e in v]
            setattr(self, k, new_value)
1159373
def update(cls, settings):
        """"""
        for key, val in settings.__dict__.items():
            if key.startswith('_'):
                continue
            setattr(cls, key, val)
1290843
def _call_callbacks(self):
        """"""
        for callback in self._callbacks:
            callback(self, self._changeset)
        self._changeset = {}
636816
def apply(self, fn, *a, **kw):
        """"""
        args, kwargs = self.prepare_callable(fn)
        args += a; kwargs.update(kw)
        return fn(*args, **kwargs)
937972
def __store_callable(self, o, method_name, member):
        
        self.__store__['callables'][method_name] = eval( "o." + method_name )
        self.__store__['callables'][method_name[0].lower() + method_name[1:]] = eval( "o." + method_name )
        ret_val = self.__wrap( method_name )
        self.__store__[ method_name ] = ret_val
        self.__store__[ method_name[0].lower() + method_name[1:] ] = ret_val
390789
function(updater) {
                    if (!onchanged) {
                        onchanged = function(ev) {
                            if (compute.bound && (ev.batchNum === undefined || ev.batchNum !== batchNum)) {
                                // Keep the old value
                                var oldValue = readInfo.value;

                                // Get the new value
                                readInfo = getValueAndBind(func, context, readInfo.observed, onchanged);

                                // Call the updater with old and new values
                                updater(readInfo.value, oldValue, ev.batchNum);

                                batchNum = batchNum = ev.batchNum;
                            }
                        };
                    }

                    readInfo = getValueAndBind(func, context, {}, onchanged);

                    setCachedValue(readInfo.value);

                    compute.hasDependencies = !can.isEmptyObject(readInfo.observed);
                }
599907
def perform_update(self, data, instance):
        

        for key, val in data.items():
            setattr(instance, key, val)
883437
function(name) {
        if (JOII.Config.callables.indexOf(name) === -1) {
            return;
        }

        JOII.Config.callables.splice(JOII.Config.callables.indexOf(name), 1);
    }
1215888
def update(self, **kwargs):
        """"""
        assert not self.called
        self.kw.update(kwargs)
        return self
782975
function _update() {
  var nodesData = _treeLayout.nodes(_treeData),
      linksData = _getLinks(nodesData);

  _normalize(nodesData);

  var nodes = _g.selectAll('g.node')
    .data(nodesData, _getNodeId);
  _updateNodes(nodes, _treeData);

  var links = _g.selectAll('path.link')
      .data(linksData, _getLinkId);
  _updateLinks(links, _treeData);

  nodesData.forEach(_stashOldPositions);
}
1361406
def call(self, name, *a):
        """"""
        return callJavaFunc(self._sc, getattr(self._java_model, name), *a)
483876
private void processObjectCreateCall(Node callNode) {
    Node curParam = callNode.getSecondChild();
    if (canOptimizeObjectCreate(curParam)) {
      Node objNode = IR.objectlit().srcref(callNode);
      while (curParam != null) {
        Node keyNode = curParam;
        Node valueNode = curParam.getNext();
        curParam = valueNode.getNext();

        callNode.removeChild(keyNode);
        callNode.removeChild(valueNode);

        addKeyValueToObjLit(objNode, keyNode, valueNode);
      }
      callNode.replaceWith(objNode);
      compiler.reportChangeToEnclosingScope(objNode);
    }
  }
158486
private void updateBind(Node n) {
    CodingConvention.Bind bind =
        compiler.getCodingConvention().describeFunctionBind(n, false, true);
    if (bind == null) {
      return;
    }

    Node target = bind.target;
    FunctionType callTargetFn = getJSType(target)
        .restrictByNotNullOrUndefined().toMaybeFunctionType();
    if (callTargetFn == null) {
      return;
    }

    if (bind.thisValue != null && target.isFunction()) {
      JSType thisType = getJSType(bind.thisValue);
      if (thisType.toObjectType() != null && !thisType.isUnknownType()
          && callTargetFn.getTypeOfThis().isUnknownType()) {
        callTargetFn =
            FunctionType.builder(registry)
                .copyFromOtherFunction(callTargetFn)
                .withTypeOfThis(thisType.toObjectType())
                .build();
        target.setJSType(callTargetFn);
      }
    }

    n.setJSType(
        callTargetFn.getBindReturnType(
            // getBindReturnType expects the 'this' argument to be included.
            bind.getBoundParameterCount() + 1));
  }
943050
static void update(AbstractCompiler compiler, Node externs, Node root) {
    compiler.setExternGetterAndSetterProperties(gather(compiler, externs));
    compiler.setSourceGetterAndSetterProperties(gather(compiler, root));
  }
658036
void update()
    {
        mx = x - oldX;
        my = y - oldY;
        oldX = x;
        oldY = y;
    }
925746
function setProxy (call, property, data) {
    // reset call
    call = resetCall(call)
    // only allow set on data
    assert.ok(property === 'data', 'can only set value for data')
    // module name to set data for
    var moduleName
    // namespace context not set
    if (!defined(call.namespace)) {
        // get module name from session
        moduleName = getModuleName(call.session)
    }
    else if (defined(call.module)) {
        // cannot set data in method context
        assert.ok(!defined(call.method), 'ImmutableAI cannot set data in method context')
        // get full module name
        moduleName = call.module+GLOBAL.localNamespaces[call.namespace]
    }
    // require module name
    assert.ok(defined(moduleName), `ImmutableAI cannot set data without module context`)
    // set data
    GLOBAL.immutableCore.setData(moduleName, data)

    return true
}