title: How allow HTTP methods "PUT" and "DELETE" in Flask?
body: <p>I'm beginning in Python and I try to do PUT and DELETE methods like this:</p>
  
  <pre><code>import gamerocket
  from flask import Flask, request, render_template
  app = Flask(__name__)
  
  gamerocket.Configuration.configure(gamerocket.Environment.Development,
                                  apiKey = "my_apiKey",
                                  secretKey = "my_secretKey")
  
  @app.route("/update_player", methods = ["PUT"])
  def update_player():
      result = gamerocket.Player.update(
          "a_player_id",
          {
              "name" : "bob_update",
              "emailHash" : "update@test.com",
              "totalPointsAchievement" : 1
          }
      )
  
  if result.is_success:
      return "&lt;h1&gt;Success! " + result.player.id + " " + result.player.name +   "&lt;/h1&gt;"
  else:
      return "&lt;h1&gt;Error " + result.error + ": " + result.error_description
  
  if __name__ == '__main__':
  app.run(debug=True)
  </code></pre>
  
  <p>but I get a HTTP 405 error
  Method Not Allowed</p>
  
  <p>The method is not allowed for the requested URL.</p>
  
  <p>Could you help me?</p>
  
  <p>Edit: Here is how I call the method:</p>
  
  <pre><code>class PlayerGateway(object):
      def update(self, player_id, params={}):
      response = self.config.http().put("/players/" + player_id, params)
      if "player" in response:
          return SuccessfulResult({"player": Player(self.gateway,response["player"])})
      elif "error" in response:
          return ErrorResult(response)
      else:
          pass
  </code></pre>
  
  <p>Next in Http:</p>
  
  <pre><code>class Http(object):
      def put(self, path, params={}):
          return self.__http_do("PUT", path, params)
      def delete(self, path, params={}):
          return self.__http_do("DELETE", path, params)
  
      def __http_do(self, http_verb, path, params):
  
          http_strategy = self.config.http_strategy()
  
          full_path = self.environment.base_url + "/api/" + self.config.api_version() + path
          params['signature'] = self.config.crypto().sign(http_verb, full_path, params,
                                self.config.secretKey)
  
          params = self.config.sort_dict(params)
  
          request_body = urlencode(params) if params !={} else ''
  
          if http_verb == "GET":
              full_path += "?" + request_body
          elif http_verb == "DELETE":
              full_path += "?" + request_body
  
          status, response_body = http_strategy.http_do(http_verb, full_path, 
                              self.__headers(),request_body)
  
          if Http.is_error_status(status):
              Http.raise_exception_from_status(status)
          else:
              if len(response_body.strip()) == 0:
                  return {}
              else:
                  return json.loads(response_body)
  
      def __headers(self):
          return {
              "Accept" : "application/json",
              "Content-type" : "application/x-www-form-urlencoded",
              "User-Agent" : "Gamerocket Python " + version.Version,
              "X-ApiVersion" : gamerocket.configuration.Configuration.api_version()
          }
  </code></pre>
  
  <p>And to determine request strategy:</p>
  
  <pre><code>import requests
  
  class RequestsStrategy(object):
      def __init__(self, config, environment):
          self.config = config
          self.environment = environment
  
      def http_do(self, http_verb, path, headers, request_body):
  
          response = self.__request_function(http_verb)(
              path,
              headers = headers,
              data = request_body,
              verify = self.environment.ssl_certificate,
          )
  
          return [response.status_code, response.text]
  
      def __request_function(self, method):
          if method == "GET":
              return requests.get
          elif method == "POST":
              return requests.post
          elif method == "PUT":
              return requests.put
          elif method == "DELETE":
              return requests.delete
  </code></pre>