def set_default_responders(method_map, asgi=False):
"""Map HTTP methods not explicitly defined on a resource to default responders.
Args:
method_map: A dict with HTTP methods mapped to responders explicitly
defined in a resource.
asgi (bool): ``True`` if using an ASGI app, ``False`` otherwise
(default ``False``).
"""
# Attach a resource for unsupported HTTP methods
allowed_methods = [
m for m in sorted(list(method_map.keys()))
if m not in constants._META_METHODS
]
if 'OPTIONS' not in method_map:
# OPTIONS itself is intentionally excluded from the Allow header
opt_responder = responders.create_default_options(allowed_methods,
asgi=asgi)
method_map['OPTIONS'] = opt_responder
allowed_methods.append('OPTIONS')
na_responder = responders.create_method_not_allowed(allowed_methods,
asgi=asgi)
for method in constants.COMBINED_METHODS:
if method not in method_map:
method_map[method] = na_responder
def create_http_method_map(resource):
"""Maps HTTP methods (such as GET and POST) to methods of resource object
Args:
resource: An object with "responder" methods, starting with on_*, that
correspond to each method the resource supports. For example, if a
resource supports GET and POST, it should define
on_get(self, req, resp) and on_post(self,req,resp).
"""
method_map = {}
for method in HTTP_METHODS:
try:
func = getattr(resource, 'on_' + method.lower())
except AttributeError:
# resource does not implement this method
pass
else:
# Usually expect a method, but any callable will do
if hasattr(func, '__call__'):
method_map[method] = func
# Attach a resource for unsupported HTTP methods
allowed_methods = list(method_map.keys())
func = responders.create_method_not_allowed(allowed_methods)
for method in HTTP_METHODS:
if method not in allowed_methods:
method_map[method] = func
return method_map
def create_http_method_map(resource, uri_fields, before, after):
"""Maps HTTP methods (e.g., GET, POST) to methods of a resource object.
Args:
resource: An object with *responder* methods, following the naming
convention *on_\**, that correspond to each method the resource
supports. For example, if a resource supports GET and POST, it
should define ``on_get(self, req, resp)`` and
``on_post(self, req, resp)``.
uri_fields: A set of field names from the route's URI template
that a responder must support in order to avoid "method not
allowed".
before: An action hook or list of hooks to be called before each
*on_\** responder defined by the resource.
after: An action hook or list of hooks to be called after each
*on_\** responder defined by the resource.
Returns:
dict: A mapping of HTTP methods to responders.
"""
method_map = {}
for method in HTTP_METHODS:
try:
responder = getattr(resource, 'on_' + method.lower())
except AttributeError:
# resource does not implement this method
pass
else:
# Usually expect a method, but any callable will do
if callable(responder):
responder = _wrap_with_hooks(
before, after, responder, resource)
method_map[method] = responder
# Attach a resource for unsupported HTTP methods
allowed_methods = sorted(list(method_map.keys()))
# NOTE(sebasmagri): We want the OPTIONS and 405 (Not Allowed) methods
# responders to be wrapped on global hooks
if 'OPTIONS' not in method_map:
# OPTIONS itself is intentionally excluded from the Allow header
responder = responders.create_default_options(
allowed_methods)
method_map['OPTIONS'] = _wrap_with_hooks(
before, after, responder, resource)
allowed_methods.append('OPTIONS')
na_responder = responders.create_method_not_allowed(allowed_methods)
for method in HTTP_METHODS:
if method not in allowed_methods:
method_map[method] = _wrap_with_hooks(
before, after, na_responder, resource)
return method_map
def create_http_method_map(resource, uri_fields, before, after):
"""Maps HTTP methods (e.g., 'GET', 'POST') to methods of a resource object.
Args:
resource: An object with *responder* methods, following the naming
convention *on_\**, that correspond to each method the resource
supports. For example, if a resource supports GET and POST, it
should define ``on_get(self, req, resp)`` and
``on_post(self, req, resp)``.
uri_fields: A set of field names from the route's URI template
that a responder must support in order to avoid "method not
allowed".
before: An action hook or ``list`` of hooks to be called before each
*on_\** responder defined by the resource.
after: An action hook or ``list`` of hooks to be called after each
*on_\** responder defined by the resource.
Returns:
dict: A mapping of HTTP methods to responders.
"""
method_map = {}
for method in HTTP_METHODS:
try:
responder = getattr(resource, 'on_' + method.lower())
except AttributeError:
# resource does not implement this method
pass
else:
# Usually expect a method, but any callable will do
if callable(responder):
responder = _wrap_with_hooks(before, after, responder,
resource)
method_map[method] = responder
# Attach a resource for unsupported HTTP methods
allowed_methods = sorted(list(method_map.keys()))
# NOTE(sebasmagri): We want the OPTIONS and 405 (Not Allowed) methods
# responders to be wrapped on global hooks
if 'OPTIONS' not in method_map:
# OPTIONS itself is intentionally excluded from the Allow header
responder = responders.create_default_options(allowed_methods)
method_map['OPTIONS'] = _wrap_with_hooks(before, after, responder,
resource)
allowed_methods.append('OPTIONS')
na_responder = responders.create_method_not_allowed(allowed_methods)
for method in HTTP_METHODS:
if method not in allowed_methods:
method_map[method] = _wrap_with_hooks(before, after, na_responder,
resource)
return method_map
def extend_method_map(self, method_map):
# See https://github.com/falconry/falcon/issues/667
allowed_methods = sorted(list(method_map.keys()))
if 'OPTIONS' not in method_map:
responder = create_default_options(allowed_methods)
allowed_methods.append('OPTIONS')
responder = create_method_not_allowed(allowed_methods)
for method in HTTP_METHODS:
if method not in allowed_methods:
method_map[method] = responder
def extend_method_map(self, method_map):
# See https://github.com/falconry/falcon/issues/667
allowed_methods = sorted(list(method_map.keys()))
if 'OPTIONS' not in method_map:
responder = create_default_options(allowed_methods)
allowed_methods.append('OPTIONS')
responder = create_method_not_allowed(allowed_methods)
for method in HTTP_METHODS:
if method not in allowed_methods:
method_map[method] = responder
def create_http_method_map(resource, uri_fields, before, after):
"""Maps HTTP methods (such as GET and POST) to methods of resource object
Args:
resource: An object with "responder" methods, starting with on_*, that
correspond to each method the resource supports. For example, if a
resource supports GET and POST, it should define
on_get(self, req, resp) and on_post(self,req,resp).
uri_fields: A set of field names from the route's URI template that
a responder must support in order to avoid "method not allowed".
before: An action hook or list of hooks to be called before each
on_* responder defined by the resource.
after: An action hook or list of hooks to be called after each on_*
responder defined by the resource.
Returns:
A tuple containing a dict mapping HTTP methods to responders, and
the method-not-allowed responder.
"""
method_map = {}
for method in HTTP_METHODS:
try:
responder = getattr(resource, "on_" + method.lower())
except AttributeError:
# resource does not implement this method
pass
else:
# Usually expect a method, but any callable will do
if callable(responder):
responder = _wrap_with_hooks(before, after, responder, resource)
method_map[method] = responder
# Attach a resource for unsupported HTTP methods
allowed_methods = sorted(list(method_map.keys()))
# NOTE(sebasmagri): We want the OPTIONS and 405 (Not Allowed) methods
# responders to be wrapped on global hooks
if "OPTIONS" not in method_map:
# OPTIONS itself is intentionally excluded from the Allow header
responder = responders.create_default_options(allowed_methods)
method_map["OPTIONS"] = _wrap_with_hooks(before, after, responder, resource)
allowed_methods.append("OPTIONS")
na_responder = responders.create_method_not_allowed(allowed_methods)
for method in HTTP_METHODS:
if method not in allowed_methods:
method_map[method] = _wrap_with_hooks(before, after, na_responder, resource)
return method_map
def create_http_method_map(resource, uri_fields, before, after):
"""Maps HTTP methods (such as GET and POST) to methods of resource object
Args:
resource: An object with "responder" methods, starting with on_*, that
correspond to each method the resource supports. For example, if a
resource supports GET and POST, it should define
on_get(self, req, resp) and on_post(self,req,resp).
uri_fields: A set of field names from the route's URI template that
a responder must support in order to avoid "method not allowed".
before: An action hook or list of hooks to be called before each
on_* responder defined by the resource.
after: An action hook or list of hooks to be called after each on_*
responder defined by the resource.
Returns:
A tuple containing a dict mapping HTTP methods to responders, and
the method-not-allowed responder.
"""
method_map = {}
for method in HTTP_METHODS:
try:
responder = getattr(resource, 'on_' + method.lower())
except AttributeError:
# resource does not implement this method
pass
else:
# Usually expect a method, but any callable will do
if callable(responder):
responder = _wrap_with_hooks(before, after, responder)
method_map[method] = responder
# Attach a resource for unsupported HTTP methods
allowed_methods = sorted(list(method_map.keys()))
if 'OPTIONS' not in method_map:
# OPTIONS itself is intentionally excluded from the Allow header
# This default responder does not run the hooks
method_map['OPTIONS'] = responders.create_default_options(
allowed_methods)
allowed_methods.append('OPTIONS')
na_responder = responders.create_method_not_allowed(allowed_methods)
for method in HTTP_METHODS:
if method not in allowed_methods:
method_map[method] = na_responder
return method_map
def create_http_method_map(resource): # pragma: nocover
"""Maps HTTP methods (e.g., GET, POST) to methods of a resource object.
Warning:
This method is deprecated and will be removed in a future release.
Please use :py:meth:`~falcon.routing.map_http_methods` and
:py:meth:`~falcon.routing.map_http_methods` instead.
Args:
resource: An object with *responder* methods, following the naming
convention *on_\**, that correspond to each method the resource
supports. For example, if a resource supports GET and POST, it
should define ``on_get(self, req, resp)`` and
``on_post(self, req, resp)``.
Returns:
dict: A mapping of HTTP methods to responders.
"""
method_map = {}
for method in COMBINED_METHODS:
try:
responder = getattr(resource, 'on_' + method.lower())
except AttributeError:
# resource does not implement this method
pass
else:
# Usually expect a method, but any callable will do
if callable(responder):
method_map[method] = responder
# Attach a resource for unsupported HTTP methods
allowed_methods = sorted(list(method_map.keys()))
if 'OPTIONS' not in method_map:
# OPTIONS itself is intentionally excluded from the Allow header
opt_responder = responders.create_default_options(allowed_methods)
method_map['OPTIONS'] = opt_responder
allowed_methods.append('OPTIONS')
na_responder = responders.create_method_not_allowed(allowed_methods)
for method in COMBINED_METHODS:
if method not in allowed_methods:
method_map[method] = na_responder
return method_map
def create_http_method_map(resource): # pragma: nocover
"""Maps HTTP methods (e.g., GET, POST) to methods of a resource object.
Warning:
This method is deprecated and will be removed in a future release.
Please use :py:meth:`~falcon.routing.map_http_methods` and
:py:meth:`~falcon.routing.map_http_methods` instead.
Args:
resource: An object with *responder* methods, following the naming
convention *on_\**, that correspond to each method the resource
supports. For example, if a resource supports GET and POST, it
should define ``on_get(self, req, resp)`` and
``on_post(self, req, resp)``.
Returns:
dict: A mapping of HTTP methods to responders.
"""
method_map = {}
for method in COMBINED_METHODS:
try:
responder = getattr(resource, 'on_' + method.lower())
except AttributeError:
# resource does not implement this method
pass
else:
# Usually expect a method, but any callable will do
if callable(responder):
method_map[method] = responder
# Attach a resource for unsupported HTTP methods
allowed_methods = sorted(list(method_map.keys()))
if 'OPTIONS' not in method_map:
# OPTIONS itself is intentionally excluded from the Allow header
opt_responder = responders.create_default_options(allowed_methods)
method_map['OPTIONS'] = opt_responder
allowed_methods.append('OPTIONS')
na_responder = responders.create_method_not_allowed(allowed_methods)
for method in COMBINED_METHODS:
if method not in allowed_methods:
method_map[method] = na_responder
return method_map
def create_http_method_map(resource, uri_fields, before, after):
"""Maps HTTP methods (such as GET and POST) to methods of resource object
Args:
resource: An object with "responder" methods, starting with on_*, that
correspond to each method the resource supports. For example, if a
resource supports GET and POST, it should define
on_get(self, req, resp) and on_post(self,req,resp).
uri_fields: A set of field names from the route's URI template that
a responder must support in order to avoid "method not allowed".
before: An action hook or list of hooks to be called before each
on_* responder defined by the resource.
after: An action hook or list of hooks to be called after each on_*
responder defined by the resource.
Returns:
A tuple containing a dict mapping HTTP methods to responders, and
the method-not-allowed responder.
"""
method_map = {}
for method in HTTP_METHODS:
try:
responder = getattr(resource, 'on_' + method.lower())
except AttributeError:
# resource does not implement this method
pass
else:
# Usually expect a method, but any callable will do
if hasattr(responder, '__call__'):
responder = _wrap_with_hooks(before, after, responder)
method_map[method] = responder
# Attach a resource for unsupported HTTP methods
allowed_methods = sorted(list(method_map.keys()))
na_responder = responders.create_method_not_allowed(allowed_methods)
for method in HTTP_METHODS:
if method not in allowed_methods:
method_map[method] = na_responder
return method_map, na_responder
def create_http_method_map(resource, before):
"""Maps HTTP methods (such as GET and POST) to methods of resource object
Args:
resource: An object with "responder" methods, starting with on_*, that
correspond to each method the resource supports. For example, if a
resource supports GET and POST, it should define
on_get(self, req, resp) and on_post(self,req,resp).
before: An action hooks or list of hooks to be called before each
on_* responder defined by the resource.
"""
method_map = {}
for method in HTTP_METHODS:
try:
responder = getattr(resource, 'on_' + method.lower())
except AttributeError:
# resource does not implement this method
pass
else:
# Usually expect a method, but any callable will do
if hasattr(responder, '__call__'):
if before is not None:
# Wrap in reversed order to achieve natural (first...last)
# execution order.
for action in reversed(before):
responder = _wrap_with_before(action, responder)
method_map[method] = responder
# Attach a resource for unsupported HTTP methods
allowed_methods = list(method_map.keys())
responder = responders.create_method_not_allowed(allowed_methods)
for method in HTTP_METHODS:
if method not in allowed_methods:
method_map[method] = responder
return method_map
def set_default_responders(method_map):
"""Maps HTTP methods not explicitly defined on a resource to default responders.
Args:
method_map: A dict with HTTP methods mapped to responders explicitly
defined in a resource.
"""
# Attach a resource for unsupported HTTP methods
allowed_methods = sorted(list(method_map.keys()))
if 'OPTIONS' not in method_map:
# OPTIONS itself is intentionally excluded from the Allow header
opt_responder = responders.create_default_options(allowed_methods)
method_map['OPTIONS'] = opt_responder
allowed_methods.append('OPTIONS')
na_responder = responders.create_method_not_allowed(allowed_methods)
for method in COMBINED_METHODS:
if method not in allowed_methods:
method_map[method] = na_responder
def set_default_responders(method_map):
"""Maps HTTP methods not explicitly defined on a resource to default responders.
Args:
method_map: A dict with HTTP methods mapped to responders explicitly
defined in a resource.
"""
# Attach a resource for unsupported HTTP methods
allowed_methods = sorted(list(method_map.keys()))
if 'OPTIONS' not in method_map:
# OPTIONS itself is intentionally excluded from the Allow header
opt_responder = responders.create_default_options(allowed_methods)
method_map['OPTIONS'] = opt_responder
allowed_methods.append('OPTIONS')
na_responder = responders.create_method_not_allowed(allowed_methods)
for method in COMBINED_METHODS:
if method not in allowed_methods:
method_map[method] = na_responder
def create_http_method_map(resource, before, after):
"""Maps HTTP methods (such as GET and POST) to methods of resource object
Args:
resource: An object with "responder" methods, starting with on_*, that
correspond to each method the resource supports. For example, if a
resource supports GET and POST, it should define
on_get(self, req, resp) and on_post(self,req,resp).
before: An action hooks or list of hooks to be called before each
on_* responder defined by the resource.
"""
method_map = {}
for method in HTTP_METHODS:
try:
responder = getattr(resource, 'on_' + method.lower())
except AttributeError:
# resource does not implement this method
pass
else:
# Usually expect a method, but any callable will do
if hasattr(responder, '__call__'):
responder = _wrap_with_hooks(before, after, responder)
method_map[method] = responder
# Attach a resource for unsupported HTTP methods
allowed_methods = list(method_map.keys())
responder = responders.create_method_not_allowed(allowed_methods)
for method in HTTP_METHODS:
if method not in allowed_methods:
method_map[method] = responder
return method_map
def create_http_method_map(resource, uri_fields, before, after,
map_uri_fields=False):
"""Maps HTTP methods (such as GET and POST) to methods of resource object
Args:
resource: An object with "responder" methods, starting with on_*, that
correspond to each method the resource supports. For example, if a
resource supports GET and POST, it should define
on_get(self, req, resp) and on_post(self,req,resp).
uri_fields: A set of field names from the route's URI template that
a responder must support in order to avoid "method not allowed".
before: An action hook or list of hooks to be called before each
on_* responder defined by the resource.
after: An action hook or list of hooks to be called after each on_*
responder defined by the resource.
map_url_fields: If set to True, map a route to a responder within a
resource based on the uri fields in the route. A route of
'/test/{user}/{show}' would translate to a get method of
'on_get_user_show(self, req, resp, user, show)'.
Returns:
A tuple containing a dict mapping HTTP methods to responders, and
the method-not-allowed responder.
"""
method_map = {}
for method in HTTP_METHODS:
field_string = ''
if map_uri_fields:
try:
field_string = "_".join(uri_fields)
except:
pass
try:
if map_uri_fields:
responder = getattr(resource, 'on_' + method.lower() +
'_' + field_string)
else:
responder = getattr(resource, 'on_' + method.lower())
except AttributeError:
# resource does not implement this method
pass
else:
# Usually expect a method, but any callable will do
if hasattr(responder, '__call__'):
responder = _wrap_with_hooks(before, after, responder)
method_map[method] = responder
# Attach a resource for unsupported HTTP methods
allowed_methods = sorted(list(method_map.keys()))
if 'OPTIONS' not in method_map:
# OPTIONS itself is intentionally excluded from the Allow header
# This default responder does not run the hooks
method_map['OPTIONS'] = responders.create_default_options(
allowed_methods)
allowed_methods.append('OPTIONS')
na_responder = responders.create_method_not_allowed(allowed_methods)
for method in HTTP_METHODS:
if method not in allowed_methods:
method_map[method] = na_responder
return method_map, na_responder