code: def require_oauth(self, realm=None, require_resource_owner=True,
              require_verifier=False, require_realm=False):
          
  
          def decorator(f):
              @wraps(f)
              def verify_request(*args, **kwargs):
                  """Verify OAuth params before running view function f"""
                  try:
                      if request.form:
                          body = request.form.to_dict()
                      else:
                          body = request.data.decode("utf-8")
                      verify_result = self.verify_request(request.url.decode("utf-8"),
                              http_method=request.method.decode("utf-8"),
                              body=body,
                              headers=request.headers,
                              require_resource_owner=require_resource_owner,
                              require_verifier=require_verifier,
                              require_realm=require_realm or bool(realm),
                              required_realm=realm)
                      valid, oauth_request = verify_result
                      if valid:
                          request.oauth = self.collect_request_parameters(request)
  
                          # Request tokens are only valid when a verifier is too
                          token = {}
                          if require_verifier:
                              token[u'request_token'] = request.oauth.resource_owner_key
                          else:
                              token[u'access_token'] = request.oauth.resource_owner_key
  
                          # All nonce/timestamp pairs must be stored to prevent
                          # replay attacks, they may be connected to a specific
                          # client and token to decrease collision probability.
                          self.save_timestamp_and_nonce(request.oauth.client_key,
                                  request.oauth.timestamp, request.oauth.nonce,
                                  **token)
  
                          # By this point, the request is fully authorized
                          return f(*args, **kwargs)
                      else:
                          # Unauthorized requests should not diclose their cause
                          raise Unauthorized()
  
                  except ValueError as err:
                      # Caused by missing of or badly formatted parameters
                      raise BadRequest(err.message)
  
              return verify_request
          return decorator
docs: Mark the view function f as a protected resource