Return the the super function.
182082
def _getSuperFunc(self, s, func):
        """"""

        return getattr(super(self.cls(), s), func.__name__)
770040
def superkey(self):
        """"""
        sorted_list = []
        for header in self.header:
            if header in self._keys:
                sorted_list.append(header)
        return sorted_list
361692
function(name) {
       if ($caller !== null) {
            for(var $s = $caller.boundTo.$parent; $s !== null; $s = $s.$parent) {
                var m = $s.prototype[name];
                if (typeof m === 'function') {
                    return m;
                }
            }
            return null;
        }
        throw new Error("$super is called outside of class context");
    }
438647
def get(self, *args, **kw):
        """"""
        if not self._loaded:
            self.load_config()
        return super(FedmsgConfig, self).get(*args, **kw)
549996
private void tryReplaceSuper(Node superNode) {
    checkState(!superclasses.isEmpty(), "`super` cannot appear outside a function");
    Optional<Node> currentSuperclass = superclasses.peek();
    if (!currentSuperclass.isPresent() || !currentSuperclass.get().isQualifiedName()) {
      // either if a) we're in a static class fn without an 'extends' clause or b) we're not in
      // a static class function
      return;
    }

    Node fullyQualifiedSuperRef = currentSuperclass.get().cloneTree();
    superNode.replaceWith(fullyQualifiedSuperRef);
    compiler.reportChangeToEnclosingScope(fullyQualifiedSuperRef);
  }
596588
def get(self, k, d=None):
        """"""

        return super(HeaderDict, self).get(k.title(), d)
949128
function(C, SuperC) {
		C.$super = null; // what's this?
		C.$subclasses = [];
		C.$superclass = SuperC || null;
		C.$recurring = SuperC ?
			gui.Object.copy(SuperC.$recurring) : Object.create(null);
		if (SuperC) {
			SuperC.$subclasses.push(C);
		}
		return C;
	}
958049
function($super, oldValue, newValue) {
            var oldPrecision = this.mathUtils.getDecimalPrecision(oldValue, 3),
                newPrecision = this.mathUtils.getDecimalPrecision(newValue, 3);

            this.valueAnimationPrecision = Math.max(oldPrecision, newPrecision);
            $super(oldValue, newValue);
        }
730567
def upper(self):
        
        q = self.copy()
        q.addFunction(Query.Function.Upper)
        return q
611494
def on_get(self, req, resp, **kwargs):
        """"""
        return super().on_get(req, resp, handler=self._list, **kwargs)
643290
def retrieve(cls, *args, **kwargs):
        """"""
        return super(Reversal, cls).retrieve(*args, **kwargs)
1067425
def find_function(self, name):
        """"""
        deffunction = lib.EnvFindDeffunction(self._env, name.encode())
        if deffunction == ffi.NULL:
            raise LookupError("Function '%s' not found" % name)

        return Function(self._env, deffunction)
839317
def getlist(self, name: str, default: Any = None) -> List[Any]:
        """"""
        return super().get(name, default)
1123936
def get_value(self, key, args, kwargs):
        """"""
        if hasattr(self._item, key):
            return getattr(self._item, key)
        return super().get_value(key, args, kwargs)
1248424
def dispatch(self, *args, **kwargs):
        """"""
        return super(AnimalCreate, self).dispatch(*args, **kwargs)
1355666
def super(self):
        """"""
        if self._depth + 1 >= len(self._stack):
            return self._context.environment. \
                undefined('there is no parent block called %r.' %
                          self.name, name='super')
        return BlockReference(self.name, self._context, self._stack,
                              self._depth + 1)
864667
function _gpfGenSuperMember (superMethod, method) {
    return function GpfSuperableMethod () {
        var previousSuper = this._super,
            result;
        // Add a new ._super() method pointing to the base class member
        this._super = superMethod;
        try {
            // Execute the method
            result = method.apply(this, arguments);
        } finally {
            // Remove it after execution
            if (undefined === previousSuper) {
                delete this._super;
            } else {
                this._super = previousSuper;
            }
        }
        return result;
    };
}