code: def make_proxy_method(cls, name):
          
  
          i = cls()
          view = getattr(i, name)
  
          if cls.decorators:
              for decorator in cls.decorators:
                  view = decorator(view)
  
          @functools.wraps(view)
          def proxy(**forgettable_view_args):
              # Always use the global request object's view_args, because they
              # can be modified by intervening function before an endpoint or
              # wrapper gets called. This matches Flask's behavior.
              del forgettable_view_args
  
              if hasattr(i, "before_request"):
                  response = i.before_request(name, **request.view_args)
                  if response is not None:
                      return response
  
              before_view_name = "before_" + name
              if hasattr(i, before_view_name):
                  before_view = getattr(i, before_view_name)
                  response = before_view(**request.view_args)
                  if response is not None:
                      return response
  
              response = view(**request.view_args)
  
              # You can also return a dict or None, it will pass it to render
              if isinstance(response, dict) or response is None:
                  response = response or {}
                  if hasattr(i, "_renderer"):
                      response = i._renderer(response)
                  else:
                      df_v_t = "%s/%s.html" % (cls.__name__, view.__name__)
                      response.setdefault("template_", df_v_t)
                      response = i.render_(**response)
  
              if not isinstance(response, Response):
                  response = make_response(response)
  
              after_view_name = "after_" + name
              if hasattr(i, after_view_name):
                  after_view = getattr(i, after_view_name)
                  response = after_view(response)
  
              if hasattr(i, "after_request"):
                  response = i.after_request(name, response)
  
              return response
  
          return proxy
docs: Creates a proxy function that can be used by Flasks routing. The
          proxy instantiates the FlaskView subclass and calls the appropriate
          method.
          :param name: the name of the method to create a proxy for