Returns the method double for the provided method name, creating one if necessary.

        :param str method_name: The name of the method to retrieve a method double for.
        :return: The mapped ``MethodDouble``.
        :rtype: MethodDouble
439272
def method_double_for(self, method_name):
        

        if method_name not in self._method_doubles:
            self._method_doubles[method_name] = MethodDouble(method_name, self._target)

        return self._method_doubles[method_name]
1095283
def method_missing(key_name, *args)
      key_name_str = key_name.to_s()
      if key_name_str =~ /=$/ then
        self[key_name_str.chop()] = args[0]
      else
        return self[key_name_str]
      end
    end
1337305
def method_caller(method_name, *args, **kwargs):
	
	def call_method(target):
		func = getattr(target, method_name)
		return func(*args, **kwargs)
	return call_method
840830
def value_call(method_name, *args, **kwargs):
    

    def value_call(value, context, **_params):
        method = getattr(value, method_name)
        return _call(method, args, kwargs)

    return value_call
613715
def _get_method(self, request):
        
        methodname = request.method.lower()
        method = getattr(self, methodname, None)
        if not method or not callable(method):
            raise errors.MethodNotAllowed()
        return method
1231190
public String getFullyQualifiedNameForMethodName(String methodName) {
    if (!methodNameToFullyQualifiedName.containsKey(methodName)) {
      return methodName;
    }

    return methodNameToFullyQualifiedName.get(methodName);
  }
1091160
def _get_remote_method(self, funcname):
        

        func = getattr(self, funcname)
        if not callable(func) or not getattr(func, '_remote', False):
            raise AttributeError("%r object has no attribute %r" %
                                 (self.__class__.__name__, funcname))

        return func
1057766
def get_function(self, name):
        
        p = ffi.lib.LLVMPY_GetNamedFunction(self, _encode_string(name))
        if not p:
            raise NameError(name)
        return ValueRef(p, 'function', dict(module=self))
1176151
def queue_name_for_method(method_name)
      return queue_names[method_name] if queue_names[method_name]

      queue_name = generate_queue_name(method_name)
      queue_for(method_name, queue_name)
      return queue_name
    end
230092
def method_by_name(self, method_name):
        

        #        print("METHODS FOR MODULE: %s " % self.path)
        for m in self.methods:
            if m.full_name == method_name or m.name == method_name:
                return m

        return None
725570
def get_method_returning_field_value(self, field_name):
        
        return (
            super().get_method_returning_field_value(field_name)
            or self.core.get_method_returning_field_value(field_name)
        )
1266167
def inplace(method_name):
    
    def method(self, other):
        getattr(self, method_name)(value_left(self, other))
        return self
    return method
533136
def routing_key_name_for_method(method_name)
      return routing_key_names[method_name] if routing_key_names[method_name]

      routing_key_name = generate_routing_key_name(method_name)
      routing_key_for(method_name, routing_key_name)
      return routing_key_name
    end
606842
def _extract_method(method):
    
    _method = {}
    for k,v in method.items():
        _method["method_" + k] = v
    return _method
442434
def _add_method_dunders(self, method):
        
        try:
            method.__module__ = self._cls.__module__
        except AttributeError:
            pass

        try:
            method.__qualname__ = ".".join(
                (self._cls.__qualname__, method.__name__)
            )
        except AttributeError:
            pass

        return method
906618
public Double getDouble(String name) {
        //let it fail in the more general case where it isn't actually a number
        Number number = (Number) content.get(name);
        if (number == null) {
            return null;
        } else if (number instanceof Double) {
            return (Double) number;
        } else {
            return number.doubleValue(); //autoboxing to Double
        }
    }
1042500
def _get_method(method):
        

        # Split the class out from the job
        module = method.split(':')

        # Set the import module
        _module_import = module[0]

        # Set the class name to use
        class_name = module[-1]

        # import the module
        module_import = __import__(_module_import, fromlist=[class_name])

        # Return the attributes for the imported module and class
        return getattr(module_import, class_name)