Determine if a method is in the wsdl.

    Args:
      method_name: The name of the method.

    Returns:
      True if the method is in the wsdl, otherwise False.
510411
def _WsdlHasMethod(self, method_name):
    
    try:
      self._method_bindings.get(method_name)
      return True
    except ValueError:
      return False
992795
def has_method(self, key: str) -> bool:
        
        return hasattr(self.__class__, key) and callable(getattr(self.__class__, key))
561756
def has_method(obj, name):
        
        if obj == None:
            raise Exception("Object cannot be null")
        if name == None:
            raise Exception("Method name cannot be null")

        name = name.lower()

        for method_name in dir(obj): 
            if method_name.lower() != name:
                continue

            method = getattr(obj, method_name)

            if MethodReflector._is_method(method, method_name):
                return True
        
        return False
573075
def is_attribute(method, name=None):
    
    if name is None:
        name = method.__name__
    method.is_attribute = True
    method.name = name
    return method
1219928
function hasRemoteMethod(model, methodName) {
  return model.sharedClass
    .methods({ includeDisabled: false })
    .map(sharedMethod => sharedMethod.name)
    .includes(methodName)
}
959562
def is_bound(method):
    
    @functools.wraps(method)
    def wrapper(self, *args, **kwargs):
        if not self._is_bound:
            raise ValueError("%r must be bound to call %s()" % (self, method.__name__))
        return method(self, *args, **kwargs)
    return wrapper
846119
public static boolean is(Method method, boolean acceptPrefixless) {
        int length = method.getName().length();

        if (method.isPrivate() || method.isStatic()) {
            return false;
        }

        if (!method.getArguments().isEmpty()) {
            return false;
        }

        if (method.getReturnType().equals(VOID)) {
            return false;
        }

        if (acceptPrefixless) {
            return true;
        }

        if (method.getName().startsWith(GET_PREFIX)) {
            return length > GET_PREFIX.length();
        }

        if (method.getName().startsWith(IS_PREFIX) && TypeUtils.isBoolean(method.getReturnType())) {
            return length > IS_PREFIX.length();
        }

        if (method.getName().startsWith(SHOULD_PREFIX) && TypeUtils.isBoolean(method.getReturnType())) {
            return length > SHOULD_PREFIX.length();
        }
        return false;
    }
677761
def method_missing(name, *args, &block)
      return meta[name.to_s] if meta.key?(name.to_s)
      super
    end
386761
def method_missing(method_name, *args, &block)
      mapped_key = key_map[method_name.to_sym]
      if attributes.has_key?(mapped_key)
        attributes[mapped_key]
      else
        super
      end
    end
951514
public boolean containsMethod(final String name) {
      if (StringUtils.isNullOrBlank(name)) {
         return false;
      }
      return ClassDescriptorCache.getInstance()
                                 .getClassDescriptor(clazz)
                                 .getMethods(accessAll)
                                 .stream()
                                 .anyMatch(f -> f.getName().equals(name));
   }
436127
def is_observing_method(self, prop_name, method):
        
        if (prop_name, method) in self.__PAT_METH_TO_KWARGS:
            return True
        if method in self.__METH_TO_PAT:
            pat = self.__METH_TO_PAT[method]
            if fnmatch.fnmatch(prop_name, pat):
                return True

        return False
901129
private boolean isObjectMethod(Method method) {
    for (Method objectMethod : Object.class.getMethods()) {
      if (method.getName().equals(objectMethod.getName())) {
        if (equalParamTypes(objectMethod.getParameterTypes(), method.getParameterTypes())) {
          return true;
        }
      }
    }

    return false;
  }
1104087
def is_classmethod(meth):
    
    if inspect.ismethoddescriptor(meth):
        return isinstance(meth, classmethod)
    if not inspect.ismethod(meth):
        return False
    if not inspect.isclass(meth.__self__):
        return False
    if not hasattr(meth.__self__, meth.__name__):
        return False
    return meth == getattr(meth.__self__, meth.__name__)
425073
private boolean inMethodConfigs(String methodConfigs, String methodName) {
        String[] excludeMethodCollections = StringUtils.splitWithCommaOrSemicolon(methodConfigs);
        for (String excludeMethodName : excludeMethodCollections) {
            boolean exist = StringUtils.equals(excludeMethodName, methodName);
            if (exist) {
                return true;
            }
        }
        return false;
    }
1130739
def has_method(obj, method_name):
    '''
    
    '''
    if method_name in dir(obj):
        return True

    log.error('Method \'%s\' not yet supported!', method_name)
    return False
1371920
def method?(name)
      begin
        klass = Esi::Calls.const_get(method_to_class_name(name))
      rescue NameError
        return false
      end
      !klass.nil?
    end
407648
def method_missing(method, *args)
      if method.to_s =~ /^(\w+)\?$/
        v = self.class.find_by_symbol($1)
        raise NameError unless v
        other = v.to_sym
        self.class.class_eval { define_method(method) { self.to_sym == other }}
        return self.to_sym == other
      end
      super
    end