docs: def load_model(model, attributes=None, parameter=None,
          kwargs=False, permission=None, addlperms=None, urlcheck=[]):
      """
      Decorator to load a model given a query parameter.
  
      Typical usage::
  
          @app.route('/<profile>')
          @load_model(Profile, {'name': 'profile'}, 'profileob')
          def profile_view(profileob):
              # 'profileob' is now a Profile model instance. The load_model decorator replaced this:
              # profileob = Profile.query.filter_by(name=profile).first_or_404()
              return "Hello, %s" % profileob.name
  
      Using the same name for request and parameter makes code easier to understand::
  
          @app.route('/<profile>')
          @load_model(Profile, {'name': 'profile'}, 'profile')
          def profile_view(profile):
              return "Hello, %s" % profile.name
  
      ``load_model`` aborts with a 404 if no instance is found.
  
      :param model: The SQLAlchemy model to query. Must contain a ``query`` object
          (which is the default with Flask-SQLAlchemy)
  
      :param attributes: A dict of attributes (from the URL request) that will be
          used to query for the object. For each key:value pair, the key is the name of
          the column on the model and the value is the name of the request parameter that
          contains the data
  
      :param parameter: The name of the parameter to the decorated function via which
          the result is passed. Usually the same as the attribute. If the parameter name
          is prefixed with 'g.', the parameter is also made available as g.<parameter>
  
      :param kwargs: If True, the original request parameters are passed to the decorated
          function as a ``kwargs`` parameter
  
      :param permission: If present, ``load_model`` calls the
          :meth:`~coaster.sqlalchemy.PermissionMixin.permissions` method of the
          retrieved object with ``current_auth.actor`` as a parameter. If
          ``permission`` is not present in the result, ``load_model`` aborts with
          a 403. The permission may be a string or a list of strings, in which
          case access is allowed if any of the listed permissions are available
  
      :param addlperms: Iterable or callable that returns an iterable containing additional
          permissions available to the user, apart from those granted by the models. In an app
          that uses Lastuser for authentication, passing ``lastuser.permissions`` will pass
          through permissions granted via Lastuser
  
      :param list urlcheck: If an attribute in this list has been used to load an object, but
          the value of the attribute in the loaded object does not match the request argument,
          issue a redirect to the corrected URL. This is useful for attributes like
          ``url_id_name`` and ``url_name_suuid`` where the ``name`` component may change
      """
      return load_models((model, attributes, parameter),
          kwargs=kwargs, permission=permission, addlperms=addlperms, urlcheck=urlcheck)