%global _empty_manifest_terminate_build 0
Name:		python-Flask-ErrorsHandler
Version:	4.0.2
Release:	1
Summary:	Customizable errors handler for flask application and blueprints
License:	MIT
URL:		https://github.com/cs91chris/flask_errors_handler
Source0:	https://mirrors.aliyun.com/pypi/web/packages/c3/ae/404fa9ee5ea0884ab1faff1ae055d2c34e73d34cab8c157ddda22ee28c1d/Flask-ErrorsHandler-4.0.2.tar.gz
BuildArch:	noarch

Requires:	python3-Flask

%description
|version|
Set customizable default errors handler for flask app and blueprints.
You can register error handler for:
- api that returns JSON, default response is as API problem specification like (see https://tools.ietf.org/html/rfc7807).
  Instead you can use your own response implementation passed as argument to ``ErrorHandler`` class:
  it must be a decorator and must take 3 args, a dict response, status code and dict headers.
- web that returns html page or api response if request is XHR (for compatibility with old clients)
- you can register custom handlers for blueprint or the entire app
This module provide also an abstract ``ErrorDispatcher`` class in order to dispatch 404 or 405 error to the correct blueprint
because flask Blueprint does not own url_prefix (see https://github.com/pallets/flask/issues/1498).
There are 2 concrete implementation:
- ``SubdomainDispatcher``: dispatch the error to the handler associate with blueprint with certain subdomain
  (if 2 or more Blueprint has the same subdomain the first blueprint handler matched is used)
- ``URLPrefixDispatcher``: dispatch the error to the handler associate with blueprint with certain url prefix.
  This will not work if 2 Blueprint are registered under the same url prefix, for example:
  Blueprint A registered under /prefix/blueprint, Blueprint B registered under /prefix, this dispatcher executes the handler
  of B in both case if B is registered after A.
Moreover you can create you own dispatcher by extending ``ErrorDispatcher`` class and implementing ``dispatch`` method.
Only the *last* ErrorDispatcher registered is executed. This is the best solution I have found, suggestions are welcome.
Notices:
1. In order to use correctly dispatcher you must set prefix or subdomain in Blueprints constructor, see example below.
2. If you use dispatcher do not register an handler to app object because it overwrites dispatcher.
3. When using a dispatcher you should use failure handler on app to catch unhandled exceptions.
QuickStart
~~~~~~~~~~
Install ``flask_errors_handler`` using ``pip``:
   $ pip install Flask-ErrorsHandler
Example usage
^^^^^^^^^^^^^
    import flask
    from flask_errors_handler import ErrorHandler
    app = flask.Flask(__name__)
    error = ErrorHandler(app, dispatcher='urlprefix')
    api = flask.Blueprint('api', __name__, url_prefix='/api')
    web = flask.Blueprint('web', __name__, url_prefix='/web')
    custom = flask.Blueprint('custom', __name__, url_prefix='/custom')
    error.web_register(web)
    error.api_register(api)
    error.failure_register(app)
    @error.register(custom)
    def error_handler(exc):
        return str(exc), 500, {'Content-Type': 'text/plain'}
    @api.route('/')
    def index():
        flask.abort(500, 'Error from api blueprint')
    @web.route('/')
    def index():
        flask.abort(500, 'Error from web blueprint')
    @custom.route('/')
    def index():
        flask.abort(500, 'Error from custom blueprint')
    @app.route('/')
    def index():
        raise NameError("test custom")
    app.register_blueprint(web)
    app.register_blueprint(api)
    app.register_blueprint(custom)
    app.run()
- Go to http://127.0.0.1:5000/api and see error message response as a JSON
- Go to http://127.0.0.1:5000/web and see error message response as an HTML page
- Go to http://127.0.0.1:5000/custom and see error message response as a plain text
Configuration
^^^^^^^^^^^^^
1. ``ERROR_PAGE``: *(default: error.html)* path of html template to use for show error message
2. ``ERROR_DEFAULT_MSG``: *(default: Unhandled Exception)* default message for unhandled exceptions
3. ``ERROR_XHR_ENABLED``: *(default: True)* enable or disable api response where request is XHR
4. ``ERROR_FORCE_CONTENT_TYPE``: *(True)* force response content type to be api problem compliant
5. ``ERROR_CONTENT_TYPES``: *('json', 'xml'))* list of format types to force api problem content type
6. ``ERROR_DISPATCHER``: dispatcher to use, one of: ``default, urlprefix, subdomain``
7. ``ERROR_HANDLER``: global error handler, one of: ``api, web``
License MIT

%package -n python3-Flask-ErrorsHandler
Summary:	Customizable errors handler for flask application and blueprints
Provides:	python-Flask-ErrorsHandler
BuildRequires:	python3-devel
BuildRequires:	python3-setuptools
BuildRequires:	python3-pip
%description -n python3-Flask-ErrorsHandler
|version|
Set customizable default errors handler for flask app and blueprints.
You can register error handler for:
- api that returns JSON, default response is as API problem specification like (see https://tools.ietf.org/html/rfc7807).
  Instead you can use your own response implementation passed as argument to ``ErrorHandler`` class:
  it must be a decorator and must take 3 args, a dict response, status code and dict headers.
- web that returns html page or api response if request is XHR (for compatibility with old clients)
- you can register custom handlers for blueprint or the entire app
This module provide also an abstract ``ErrorDispatcher`` class in order to dispatch 404 or 405 error to the correct blueprint
because flask Blueprint does not own url_prefix (see https://github.com/pallets/flask/issues/1498).
There are 2 concrete implementation:
- ``SubdomainDispatcher``: dispatch the error to the handler associate with blueprint with certain subdomain
  (if 2 or more Blueprint has the same subdomain the first blueprint handler matched is used)
- ``URLPrefixDispatcher``: dispatch the error to the handler associate with blueprint with certain url prefix.
  This will not work if 2 Blueprint are registered under the same url prefix, for example:
  Blueprint A registered under /prefix/blueprint, Blueprint B registered under /prefix, this dispatcher executes the handler
  of B in both case if B is registered after A.
Moreover you can create you own dispatcher by extending ``ErrorDispatcher`` class and implementing ``dispatch`` method.
Only the *last* ErrorDispatcher registered is executed. This is the best solution I have found, suggestions are welcome.
Notices:
1. In order to use correctly dispatcher you must set prefix or subdomain in Blueprints constructor, see example below.
2. If you use dispatcher do not register an handler to app object because it overwrites dispatcher.
3. When using a dispatcher you should use failure handler on app to catch unhandled exceptions.
QuickStart
~~~~~~~~~~
Install ``flask_errors_handler`` using ``pip``:
   $ pip install Flask-ErrorsHandler
Example usage
^^^^^^^^^^^^^
    import flask
    from flask_errors_handler import ErrorHandler
    app = flask.Flask(__name__)
    error = ErrorHandler(app, dispatcher='urlprefix')
    api = flask.Blueprint('api', __name__, url_prefix='/api')
    web = flask.Blueprint('web', __name__, url_prefix='/web')
    custom = flask.Blueprint('custom', __name__, url_prefix='/custom')
    error.web_register(web)
    error.api_register(api)
    error.failure_register(app)
    @error.register(custom)
    def error_handler(exc):
        return str(exc), 500, {'Content-Type': 'text/plain'}
    @api.route('/')
    def index():
        flask.abort(500, 'Error from api blueprint')
    @web.route('/')
    def index():
        flask.abort(500, 'Error from web blueprint')
    @custom.route('/')
    def index():
        flask.abort(500, 'Error from custom blueprint')
    @app.route('/')
    def index():
        raise NameError("test custom")
    app.register_blueprint(web)
    app.register_blueprint(api)
    app.register_blueprint(custom)
    app.run()
- Go to http://127.0.0.1:5000/api and see error message response as a JSON
- Go to http://127.0.0.1:5000/web and see error message response as an HTML page
- Go to http://127.0.0.1:5000/custom and see error message response as a plain text
Configuration
^^^^^^^^^^^^^
1. ``ERROR_PAGE``: *(default: error.html)* path of html template to use for show error message
2. ``ERROR_DEFAULT_MSG``: *(default: Unhandled Exception)* default message for unhandled exceptions
3. ``ERROR_XHR_ENABLED``: *(default: True)* enable or disable api response where request is XHR
4. ``ERROR_FORCE_CONTENT_TYPE``: *(True)* force response content type to be api problem compliant
5. ``ERROR_CONTENT_TYPES``: *('json', 'xml'))* list of format types to force api problem content type
6. ``ERROR_DISPATCHER``: dispatcher to use, one of: ``default, urlprefix, subdomain``
7. ``ERROR_HANDLER``: global error handler, one of: ``api, web``
License MIT

%package help
Summary:	Development documents and examples for Flask-ErrorsHandler
Provides:	python3-Flask-ErrorsHandler-doc
%description help
|version|
Set customizable default errors handler for flask app and blueprints.
You can register error handler for:
- api that returns JSON, default response is as API problem specification like (see https://tools.ietf.org/html/rfc7807).
  Instead you can use your own response implementation passed as argument to ``ErrorHandler`` class:
  it must be a decorator and must take 3 args, a dict response, status code and dict headers.
- web that returns html page or api response if request is XHR (for compatibility with old clients)
- you can register custom handlers for blueprint or the entire app
This module provide also an abstract ``ErrorDispatcher`` class in order to dispatch 404 or 405 error to the correct blueprint
because flask Blueprint does not own url_prefix (see https://github.com/pallets/flask/issues/1498).
There are 2 concrete implementation:
- ``SubdomainDispatcher``: dispatch the error to the handler associate with blueprint with certain subdomain
  (if 2 or more Blueprint has the same subdomain the first blueprint handler matched is used)
- ``URLPrefixDispatcher``: dispatch the error to the handler associate with blueprint with certain url prefix.
  This will not work if 2 Blueprint are registered under the same url prefix, for example:
  Blueprint A registered under /prefix/blueprint, Blueprint B registered under /prefix, this dispatcher executes the handler
  of B in both case if B is registered after A.
Moreover you can create you own dispatcher by extending ``ErrorDispatcher`` class and implementing ``dispatch`` method.
Only the *last* ErrorDispatcher registered is executed. This is the best solution I have found, suggestions are welcome.
Notices:
1. In order to use correctly dispatcher you must set prefix or subdomain in Blueprints constructor, see example below.
2. If you use dispatcher do not register an handler to app object because it overwrites dispatcher.
3. When using a dispatcher you should use failure handler on app to catch unhandled exceptions.
QuickStart
~~~~~~~~~~
Install ``flask_errors_handler`` using ``pip``:
   $ pip install Flask-ErrorsHandler
Example usage
^^^^^^^^^^^^^
    import flask
    from flask_errors_handler import ErrorHandler
    app = flask.Flask(__name__)
    error = ErrorHandler(app, dispatcher='urlprefix')
    api = flask.Blueprint('api', __name__, url_prefix='/api')
    web = flask.Blueprint('web', __name__, url_prefix='/web')
    custom = flask.Blueprint('custom', __name__, url_prefix='/custom')
    error.web_register(web)
    error.api_register(api)
    error.failure_register(app)
    @error.register(custom)
    def error_handler(exc):
        return str(exc), 500, {'Content-Type': 'text/plain'}
    @api.route('/')
    def index():
        flask.abort(500, 'Error from api blueprint')
    @web.route('/')
    def index():
        flask.abort(500, 'Error from web blueprint')
    @custom.route('/')
    def index():
        flask.abort(500, 'Error from custom blueprint')
    @app.route('/')
    def index():
        raise NameError("test custom")
    app.register_blueprint(web)
    app.register_blueprint(api)
    app.register_blueprint(custom)
    app.run()
- Go to http://127.0.0.1:5000/api and see error message response as a JSON
- Go to http://127.0.0.1:5000/web and see error message response as an HTML page
- Go to http://127.0.0.1:5000/custom and see error message response as a plain text
Configuration
^^^^^^^^^^^^^
1. ``ERROR_PAGE``: *(default: error.html)* path of html template to use for show error message
2. ``ERROR_DEFAULT_MSG``: *(default: Unhandled Exception)* default message for unhandled exceptions
3. ``ERROR_XHR_ENABLED``: *(default: True)* enable or disable api response where request is XHR
4. ``ERROR_FORCE_CONTENT_TYPE``: *(True)* force response content type to be api problem compliant
5. ``ERROR_CONTENT_TYPES``: *('json', 'xml'))* list of format types to force api problem content type
6. ``ERROR_DISPATCHER``: dispatcher to use, one of: ``default, urlprefix, subdomain``
7. ``ERROR_HANDLER``: global error handler, one of: ``api, web``
License MIT

%prep
%autosetup -n Flask-ErrorsHandler-4.0.2

%build
%py3_build

%install
%py3_install
install -d -m755 %{buildroot}/%{_pkgdocdir}
if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi
if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi
if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi
if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi
pushd %{buildroot}
if [ -d usr/lib ]; then
	find usr/lib -type f -printf "\"/%h/%f\"\n" >> filelist.lst
fi
if [ -d usr/lib64 ]; then
	find usr/lib64 -type f -printf "\"/%h/%f\"\n" >> filelist.lst
fi
if [ -d usr/bin ]; then
	find usr/bin -type f -printf "\"/%h/%f\"\n" >> filelist.lst
fi
if [ -d usr/sbin ]; then
	find usr/sbin -type f -printf "\"/%h/%f\"\n" >> filelist.lst
fi
touch doclist.lst
if [ -d usr/share/man ]; then
	find usr/share/man -type f -printf "\"/%h/%f.gz\"\n" >> doclist.lst
fi
popd
mv %{buildroot}/filelist.lst .
mv %{buildroot}/doclist.lst .

%files -n python3-Flask-ErrorsHandler -f filelist.lst
%dir %{python3_sitelib}/*

%files help -f doclist.lst
%{_docdir}/*

%changelog
* Fri Jun 09 2023 Python_Bot <Python_Bot@openeuler.org> - 4.0.2-1
- Package Spec generated