fastapi_chameleon 0.1.14__tar.gz

fastapi_chameleon-0.1.14/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Michael Kennedy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fastapi_chameleon-0.1.14/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.1
+Name: fastapi_chameleon
+Version: 0.1.14
+Summary: Adds integration of the Chameleon template language to FastAPI.
+Home-page: https://github.com/mikeckennedy/fastapi-chameleon
+Author: Michael Kennedy
+Author-email: michael@talkpython.fm
+License: MIT
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# fastapi-chameleon
+
+Adds integration of the Chameleon template language to FastAPI. If you are interested in Jinja instead, see the sister project: [github.com/AGeekInside/fastapi-jinja](https://github.com/AGeekInside/fastapi-jinja).
+
+## Installation
+
+Simply `pip install fastapi_chameleon`.
+
+## Usage
+
+This is easy to use. Just create a folder within your web app to hold the templates such as:
+
+```
+├── main.py
+├── views.py
+│
+├── templates
+│   ├── home
+│   │   └── index.pt
+│   └── shared
+│       └── layout.pt
+
+```
+
+In the app startup, tell the library about the folder you wish to use:
+
+```python
+import os
+from pathlib import Path
+import fastapi_chameleon
+
+dev_mode = True
+
+BASE_DIR = Path(__file__).resolve().parent
+template_folder = str(BASE_DIR / 'templates')
+fastapi_chameleon.global_init(template_folder, auto_reload=dev_mode)
+```
+
+Then just decorate the FastAPI view methods (works on sync and async methods):
+
+```python
+@router.post('/')
+@fastapi_chameleon.template('home/index.pt')
+async def home_post(request: Request):
+    form = await request.form()
+    vm = PersonViewModel(**form) 
+
+    return vm.dict() # {'first':'Michael', 'last':'Kennedy', ...}
+
+```
+
+The view method should return a `dict` to be passed as variables/values to the template. 
+
+If a `fastapi.Response` is returned, the template is skipped and the response along with status_code and
+other values is directly passed through. This is common for redirects and error responses not meant
+for this page template.
+
+## Friendly 404s and errors
+
+A common technique for user-friendly sites is to use a 
+[custom HTML page for 404 responses](http://www.instantshift.com/2019/10/16/user-friendly-404-pages/).
+This is especially important in FastAPI because FastAPI returns a 404 response + JSON by default.
+This library has support for friendly 404 pages using the `fastapi_chameleon.not_found()` function.
+
+Here's an example:
+
+```python
+@router.get('/catalog/item/{item_id}')
+@fastapi_chameleon.template('catalog/item.pt')
+async def item(item_id: int):
+    item = service.get_item_by_id(item_id)
+    if not item:
+        fastapi_chameleon.not_found()
+    
+    return item.dict()
+```
+
+This will render a 404 response with using the template file `templates/errors/404.pt`.
+You can specify another template to use for the response, but it's not required.
+
+If you need to return errors other than `Not Found` (status code `404`), you can use a more
+generic function: `fastapi_chameleon.generic_error(template_file: str, status_code: int)`.
+This function will allow you to return different status codes. It's generic, thus you'll have
+to pass a path to your error template file as well as a status code you want the user to get
+in response. For example:
+
+```python
+@router.get('/catalog/item/{item_id}')
+@fastapi_chameleon.template('catalog/item.pt')
+async def item(item_id: int):
+    item = service.get_item_by_id(item_id)
+    if not item:
+        fastapi_chameleon.generic_error('errors/unauthorized.pt',
+                                        fastapi.status.HTTP_401_UNAUTHORIZED)
+
+    return item.dict()
+```

fastapi_chameleon-0.1.14/README.md

@@ -0,0 +1,97 @@
+# fastapi-chameleon
+
+Adds integration of the Chameleon template language to FastAPI. If you are interested in Jinja instead, see the sister project: [github.com/AGeekInside/fastapi-jinja](https://github.com/AGeekInside/fastapi-jinja).
+
+## Installation
+
+Simply `pip install fastapi_chameleon`.
+
+## Usage
+
+This is easy to use. Just create a folder within your web app to hold the templates such as:
+
+```
+├── main.py
+├── views.py
+│
+├── templates
+│   ├── home
+│   │   └── index.pt
+│   └── shared
+│       └── layout.pt
+
+```
+
+In the app startup, tell the library about the folder you wish to use:
+
+```python
+import os
+from pathlib import Path
+import fastapi_chameleon
+
+dev_mode = True
+
+BASE_DIR = Path(__file__).resolve().parent
+template_folder = str(BASE_DIR / 'templates')
+fastapi_chameleon.global_init(template_folder, auto_reload=dev_mode)
+```
+
+Then just decorate the FastAPI view methods (works on sync and async methods):
+
+```python
+@router.post('/')
+@fastapi_chameleon.template('home/index.pt')
+async def home_post(request: Request):
+    form = await request.form()
+    vm = PersonViewModel(**form) 
+
+    return vm.dict() # {'first':'Michael', 'last':'Kennedy', ...}
+
+```
+
+The view method should return a `dict` to be passed as variables/values to the template. 
+
+If a `fastapi.Response` is returned, the template is skipped and the response along with status_code and
+other values is directly passed through. This is common for redirects and error responses not meant
+for this page template.
+
+## Friendly 404s and errors
+
+A common technique for user-friendly sites is to use a 
+[custom HTML page for 404 responses](http://www.instantshift.com/2019/10/16/user-friendly-404-pages/).
+This is especially important in FastAPI because FastAPI returns a 404 response + JSON by default.
+This library has support for friendly 404 pages using the `fastapi_chameleon.not_found()` function.
+
+Here's an example:
+
+```python
+@router.get('/catalog/item/{item_id}')
+@fastapi_chameleon.template('catalog/item.pt')
+async def item(item_id: int):
+    item = service.get_item_by_id(item_id)
+    if not item:
+        fastapi_chameleon.not_found()
+    
+    return item.dict()
+```
+
+This will render a 404 response with using the template file `templates/errors/404.pt`.
+You can specify another template to use for the response, but it's not required.
+
+If you need to return errors other than `Not Found` (status code `404`), you can use a more
+generic function: `fastapi_chameleon.generic_error(template_file: str, status_code: int)`.
+This function will allow you to return different status codes. It's generic, thus you'll have
+to pass a path to your error template file as well as a status code you want the user to get
+in response. For example:
+
+```python
+@router.get('/catalog/item/{item_id}')
+@fastapi_chameleon.template('catalog/item.pt')
+async def item(item_id: int):
+    item = service.get_item_by_id(item_id)
+    if not item:
+        fastapi_chameleon.generic_error('errors/unauthorized.pt',
+                                        fastapi.status.HTTP_401_UNAUTHORIZED)
+
+    return item.dict()
+```

fastapi_chameleon-0.1.14/fastapi_chameleon/__init__.py

@@ -0,0 +1,11 @@
+"""fastapi-chameleon - Adds integration of the Chameleon template language to FastAPI."""
+
+__version__ = '0.1.14'
+__author__ = 'Michael Kennedy <michael@talkpython.fm>'
+__all__ = ['template', 'global_init', 'not_found', 'response', 'generic_error', ]
+
+from .engine import global_init
+from .engine import template
+from .engine import response
+from .engine import not_found
+from .engine import generic_error

fastapi_chameleon-0.1.14/fastapi_chameleon/engine.py

@@ -0,0 +1,141 @@
+import inspect
+import os
+from functools import wraps
+from typing import Optional, Union, Callable
+
+import fastapi
+from chameleon import PageTemplateLoader, PageTemplate
+
+from fastapi_chameleon.exceptions import FastAPIChameleonException, FastAPIChameleonGenericException, \
+    FastAPIChameleonNotFoundException
+
+__templates: Optional[PageTemplateLoader] = None
+template_path: Optional[str] = None
+
+
+def global_init(template_folder: str, auto_reload=False, cache_init=True):
+    global __templates, template_path
+
+    if __templates and cache_init:
+        return
+
+    if not template_folder:
+        msg = f'The template_folder must be specified.'
+        raise FastAPIChameleonException(msg)
+
+    if not os.path.isdir(template_folder):
+        msg = f"The specified template folder must be a folder, it's not: {template_folder}"
+        raise FastAPIChameleonException(msg)
+
+    template_path = template_folder
+    __templates = PageTemplateLoader(template_folder, auto_reload=auto_reload)
+
+
+def clear():
+    global __templates, template_path
+    __templates = None
+    template_path = None
+
+
+def render(template_file: str, **template_data: dict) -> str:
+    if not __templates:
+        raise FastAPIChameleonException("You must call global_init() before rendering templates.")
+
+    page: PageTemplate = __templates[template_file]
+    return page.render(encoding='utf-8', **template_data)
+
+
+def response(template_file: str, mimetype='text/html', status_code=200, **template_data) -> fastapi.Response:
+    html = render(template_file, **template_data)
+    return fastapi.Response(content=html, media_type=mimetype, status_code=status_code)
+
+
+def template(template_file: Optional[Union[Callable, str]] = None, mimetype: str = 'text/html'):
+    """
+    Decorate a FastAPI view method to render an HTML response.
+
+    :param str template_file: Optional, the Chameleon template file (path relative to template folder, *.pt).
+    :param str mimetype: The mimetype response (defaults to text/html).
+    :return: Decorator to be consumed by FastAPI
+    """
+
+    wrapped_function = None
+    if callable(template_file):
+        wrapped_function = template_file
+        template_file = None
+
+    def response_inner(f):
+        nonlocal template_file
+        global template_path
+
+        if not template_path:
+            template_path = 'templates'
+            # raise FastAPIChameleonException("Cannot continue: fastapi_chameleon.global_init() has not been called.")
+
+        if not template_file:
+            # Use the default naming scheme: template_folder/module_name/function_name.pt
+            module = f.__module__
+            if '.' in module:
+                module = module.split('.')[-1]
+            view = f.__name__
+            template_file = f'{module}/{view}.html'
+
+            if not os.path.exists(os.path.join(template_path, template_file)):
+                template_file = f'{module}/{view}.pt'
+
+        @wraps(f)
+        def sync_view_method(*args, **kwargs):
+            try:
+                response_val = f(*args, **kwargs)
+                return __render_response(template_file, response_val, mimetype)
+            except FastAPIChameleonNotFoundException as nfe:
+                return __render_response(nfe.template_file, {}, 'text/html', 404)
+            except FastAPIChameleonGenericException as nfe:
+                return __render_response(nfe.template_file, {}, 'text/html', nfe.status_code)
+
+        @wraps(f)
+        async def async_view_method(*args, **kwargs):
+            try:
+                response_val = await f(*args, **kwargs)
+                return __render_response(template_file, response_val, mimetype)
+            except FastAPIChameleonNotFoundException as nfe:
+                return __render_response(nfe.template_file, {}, 'text/html', 404)
+            except FastAPIChameleonGenericException as nfe:
+                return __render_response(nfe.template_file, {}, 'text/html', nfe.status_code)
+
+        if inspect.iscoroutinefunction(f):
+            return async_view_method
+        else:
+            return sync_view_method
+
+    return response_inner(wrapped_function) if wrapped_function else response_inner
+
+
+def __render_response(template_file, response_val, mimetype, status_code: int = 200) -> fastapi.Response:
+    # source skip: assign-if-exp
+    if isinstance(response_val, fastapi.Response):
+        return response_val
+
+    if template_file and not isinstance(response_val, dict):
+        msg = f"Invalid return type {type(response_val)}, we expected a dict or fastapi.Response as the return value."
+        raise FastAPIChameleonException(msg)
+
+    model = response_val
+
+    html = render(template_file, **model)
+    return fastapi.Response(content=html, media_type=mimetype, status_code=status_code)
+
+
+def not_found(four04template_file: str = 'errors/404.pt'):
+    msg = 'The URL resulted in a 404 response.'
+
+    if four04template_file and four04template_file.strip():
+        raise FastAPIChameleonNotFoundException(msg, four04template_file)
+    else:
+        raise FastAPIChameleonNotFoundException(msg)
+
+
+def generic_error(template_file: str, status_code: int):
+    msg = 'The URL resulted in an error.'
+
+    raise FastAPIChameleonGenericException(template_file, status_code, msg)

fastapi_chameleon-0.1.14/fastapi_chameleon/exceptions.py

@@ -0,0 +1,23 @@
+from typing import Optional
+
+
+class FastAPIChameleonException(Exception):
+    pass
+
+
+class FastAPIChameleonNotFoundException(FastAPIChameleonException):
+    def __init__(self, message: Optional[str] = None, four04template_file: str = 'errors/404.pt'):
+        super().__init__(message)
+
+        self.template_file: str = four04template_file
+        self.message: Optional[str] = message
+
+
+class FastAPIChameleonGenericException(FastAPIChameleonException):
+    def __init__(self, template_file: str, status_code: int,
+                 message: Optional[str] = None):
+        super().__init__(message)
+
+        self.template_file: str = template_file
+        self.status_code: int = status_code
+        self.message: Optional[str] = message

fastapi_chameleon-0.1.14/fastapi_chameleon.egg-info/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.1
+Name: fastapi-chameleon
+Version: 0.1.14
+Summary: Adds integration of the Chameleon template language to FastAPI.
+Home-page: https://github.com/mikeckennedy/fastapi-chameleon
+Author: Michael Kennedy
+Author-email: michael@talkpython.fm
+License: MIT
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# fastapi-chameleon
+
+Adds integration of the Chameleon template language to FastAPI. If you are interested in Jinja instead, see the sister project: [github.com/AGeekInside/fastapi-jinja](https://github.com/AGeekInside/fastapi-jinja).
+
+## Installation
+
+Simply `pip install fastapi_chameleon`.
+
+## Usage
+
+This is easy to use. Just create a folder within your web app to hold the templates such as:
+
+```
+├── main.py
+├── views.py
+│
+├── templates
+│   ├── home
+│   │   └── index.pt
+│   └── shared
+│       └── layout.pt
+
+```
+
+In the app startup, tell the library about the folder you wish to use:
+
+```python
+import os
+from pathlib import Path
+import fastapi_chameleon
+
+dev_mode = True
+
+BASE_DIR = Path(__file__).resolve().parent
+template_folder = str(BASE_DIR / 'templates')
+fastapi_chameleon.global_init(template_folder, auto_reload=dev_mode)
+```
+
+Then just decorate the FastAPI view methods (works on sync and async methods):
+
+```python
+@router.post('/')
+@fastapi_chameleon.template('home/index.pt')
+async def home_post(request: Request):
+    form = await request.form()
+    vm = PersonViewModel(**form) 
+
+    return vm.dict() # {'first':'Michael', 'last':'Kennedy', ...}
+
+```
+
+The view method should return a `dict` to be passed as variables/values to the template. 
+
+If a `fastapi.Response` is returned, the template is skipped and the response along with status_code and
+other values is directly passed through. This is common for redirects and error responses not meant
+for this page template.
+
+## Friendly 404s and errors
+
+A common technique for user-friendly sites is to use a 
+[custom HTML page for 404 responses](http://www.instantshift.com/2019/10/16/user-friendly-404-pages/).
+This is especially important in FastAPI because FastAPI returns a 404 response + JSON by default.
+This library has support for friendly 404 pages using the `fastapi_chameleon.not_found()` function.
+
+Here's an example:
+
+```python
+@router.get('/catalog/item/{item_id}')
+@fastapi_chameleon.template('catalog/item.pt')
+async def item(item_id: int):
+    item = service.get_item_by_id(item_id)
+    if not item:
+        fastapi_chameleon.not_found()
+    
+    return item.dict()
+```
+
+This will render a 404 response with using the template file `templates/errors/404.pt`.
+You can specify another template to use for the response, but it's not required.
+
+If you need to return errors other than `Not Found` (status code `404`), you can use a more
+generic function: `fastapi_chameleon.generic_error(template_file: str, status_code: int)`.
+This function will allow you to return different status codes. It's generic, thus you'll have
+to pass a path to your error template file as well as a status code you want the user to get
+in response. For example:
+
+```python
+@router.get('/catalog/item/{item_id}')
+@fastapi_chameleon.template('catalog/item.pt')
+async def item(item_id: int):
+    item = service.get_item_by_id(item_id)
+    if not item:
+        fastapi_chameleon.generic_error('errors/unauthorized.pt',
+                                        fastapi.status.HTTP_401_UNAUTHORIZED)
+
+    return item.dict()
+```

fastapi_chameleon-0.1.14/fastapi_chameleon.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+setup.py
+fastapi_chameleon/__init__.py
+fastapi_chameleon/engine.py
+fastapi_chameleon/exceptions.py
+fastapi_chameleon.egg-info/PKG-INFO
+fastapi_chameleon.egg-info/SOURCES.txt
+fastapi_chameleon.egg-info/dependency_links.txt
+fastapi_chameleon.egg-info/requires.txt
+fastapi_chameleon.egg-info/top_level.txt
+tests/test_generic_error.py
+tests/test_init.py
+tests/test_not_found.py
+tests/test_render.py

fastapi_chameleon-0.1.14/fastapi_chameleon.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fastapi_chameleon-0.1.14/fastapi_chameleon.egg-info/requires.txt

@@ -0,0 +1,2 @@
+fastapi
+Chameleon

fastapi_chameleon-0.1.14/fastapi_chameleon.egg-info/top_level.txt

@@ -0,0 +1 @@
+fastapi_chameleon

fastapi_chameleon-0.1.14/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

fastapi_chameleon-0.1.14/setup.py

@@ -0,0 +1,67 @@
+import io
+import os
+import re
+
+from setuptools import find_packages
+from setuptools import setup
+
+
+def read(filename):
+    filename = os.path.join(os.path.dirname(__file__), filename)
+    text_type = type(u"")
+    with io.open(filename, mode="r", encoding='utf-8') as fd:
+        return re.sub(text_type(r':[a-z]+:`~?(.*?)`'), text_type(r'``\1``'), fd.read())
+
+
+def read_version():
+    filename = os.path.join(os.path.dirname(__file__), 'fastapi_chameleon', '__init__.py')
+    with open(filename, mode="r", encoding='utf-8') as fin:
+        for line in fin:
+            if line and line.strip() and line.startswith('__version__'):
+                return line.split('=')[1].strip().strip("'").strip('"')
+
+    return "0.0.0.0"
+
+
+# requirements_txt = os.path.join(
+#      os.path.dirname(__file__),
+#     'requirements.txt'
+# )
+
+# with open(requirements_txt, 'r', encoding='utf-8') as fin:
+#     requires = [
+#         line.strip()
+#         for line in fin
+#         if line and line.strip() and not line.strip().startswith('#')
+#     ]
+
+requires = ["fastapi", "Chameleon"]
+
+setup(
+    name="fastapi_chameleon",
+    version=read_version(),
+    url="https://github.com/mikeckennedy/fastapi-chameleon",
+    license='MIT',
+
+    author="Michael Kennedy",
+    author_email="michael@talkpython.fm",
+
+    description="Adds integration of the Chameleon template language to FastAPI.",
+    long_description=read("README.md"),
+    long_description_content_type="text/markdown",
+
+    packages=find_packages(exclude=('tests', 'example', 'readme_resources', 'build', 'dist',)),
+
+    install_requires=requires,
+
+    classifiers=[
+        'Development Status :: 2 - Pre-Alpha',
+        'License :: OSI Approved :: MIT License',
+        'Programming Language :: Python',
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+    ],
+)

fastapi_chameleon-0.1.14/tests/test_generic_error.py

@@ -0,0 +1,63 @@
+import asyncio
+
+import fastapi
+import pytest
+
+import fastapi_chameleon
+import fastapi_chameleon as fc
+
+
+# setup_global_template - needed as pytest mix-in.
+# noinspection PyUnusedLocal
+@pytest.mark.parametrize(
+    ("status_code", "template_file", "expected_h1_in_body"),
+    [
+        (fastapi.status.HTTP_400_BAD_REQUEST, "errors/404.pt", b'<h1>This is a pretty 404 page.</h1>'),
+        (fastapi.status.HTTP_401_UNAUTHORIZED, "errors/other_error_page.pt", b'<h1>Another pretty 404 page.</h1>'),
+        (fastapi.status.HTTP_403_FORBIDDEN, "errors/404.pt", b'<h1>This is a pretty 404 page.</h1>'),
+        (fastapi.status.HTTP_404_NOT_FOUND, "errors/other_error_page.pt", b'<h1>Another pretty 404 page.</h1>'),
+        (fastapi.status.HTTP_405_METHOD_NOT_ALLOWED, "errors/404.pt", b'<h1>This is a pretty 404 page.</h1>'),
+        (fastapi.status.HTTP_406_NOT_ACCEPTABLE, "errors/other_error_page.pt", b'<h1>Another pretty 404 page.</h1>'),
+        (fastapi.status.HTTP_407_PROXY_AUTHENTICATION_REQUIRED, "errors/404.pt",
+         b'<h1>This is a pretty 404 page.</h1>'),
+        (fastapi.status.HTTP_408_REQUEST_TIMEOUT, "errors/other_error_page.pt", b'<h1>Another pretty 404 page.</h1>'),
+    ],
+)
+def test_friendly_403_sync_method(setup_global_template, status_code, template_file, expected_h1_in_body):
+    @fc.template('home/index.pt')
+    def view_method(a, b, c):
+        fastapi_chameleon.generic_error(template_file, status_code)
+        return {'a': a, 'b': b, 'c': c}
+
+    resp = view_method(1, 2, 3)
+    assert isinstance(resp, fastapi.Response)
+    assert resp.status_code == status_code
+    assert expected_h1_in_body in resp.body
+
+
+# setup_global_template - needed as pytest mix-in.
+# noinspection PyUnusedLocal
+@pytest.mark.parametrize(
+    ("status_code", "template_file", "expected_h1_in_body"),
+    [
+        (fastapi.status.HTTP_400_BAD_REQUEST, "errors/404.pt", b'<h1>This is a pretty 404 page.</h1>'),
+        (fastapi.status.HTTP_401_UNAUTHORIZED, "errors/other_error_page.pt", b'<h1>Another pretty 404 page.</h1>'),
+        (fastapi.status.HTTP_403_FORBIDDEN, "errors/404.pt", b'<h1>This is a pretty 404 page.</h1>'),
+        (fastapi.status.HTTP_404_NOT_FOUND, "errors/other_error_page.pt", b'<h1>Another pretty 404 page.</h1>'),
+        (fastapi.status.HTTP_405_METHOD_NOT_ALLOWED, "errors/404.pt", b'<h1>This is a pretty 404 page.</h1>'),
+        (fastapi.status.HTTP_406_NOT_ACCEPTABLE, "errors/other_error_page.pt", b'<h1>Another pretty 404 page.</h1>'),
+        (fastapi.status.HTTP_407_PROXY_AUTHENTICATION_REQUIRED, "errors/404.pt",
+         b'<h1>This is a pretty 404 page.</h1>'),
+        (fastapi.status.HTTP_408_REQUEST_TIMEOUT, "errors/other_error_page.pt", b'<h1>Another pretty 404 page.</h1>'),
+    ],
+)
+def test_friendly_403_async_method(setup_global_template, status_code, template_file, expected_h1_in_body):
+    @fc.template('home/index.pt')
+    async def view_method(a, b, c):
+        fastapi_chameleon.generic_error(template_file, status_code)
+        return {'a': a, 'b': b, 'c': c}
+
+    resp = asyncio.run(view_method(1, 2, 3))
+    assert isinstance(resp, fastapi.Response)
+    assert resp.status_code == status_code
+    assert expected_h1_in_body in resp.body

fastapi_chameleon-0.1.14/tests/test_init.py

@@ -0,0 +1,28 @@
+import pytest
+
+import fastapi_chameleon as fc
+from fastapi_chameleon.exceptions import FastAPIChameleonException
+
+
+def test_cannot_decorate_with_missing_init():
+    fc.engine.clear()
+
+    with pytest.raises(FastAPIChameleonException):
+        @fc.template('home/index.pt')
+        def view_method(a, b, c):
+            return {"a": a, "b": b, "c": c}
+
+        view_method(1, 2, 3)
+
+
+def test_can_call_init_with_good_path(test_templates_path):
+    fc.global_init(str(test_templates_path), cache_init=False)
+
+    # Clear paths so as to no affect future tests
+    fc.engine.clear()
+
+
+def test_cannot_call_init_with_bad_path(test_templates_path):
+    bad_path = test_templates_path / "missing"
+    with pytest.raises(Exception):
+        fc.global_init(str(bad_path), cache_init=False)

fastapi_chameleon-0.1.14/tests/test_not_found.py

@@ -0,0 +1,48 @@
+import asyncio
+
+import fastapi
+
+import fastapi_chameleon
+import fastapi_chameleon as fc
+
+
+# setup_global_template - needed as pytest mix-in.
+# noinspection PyUnusedLocal
+def test_friendly_404_sync_method(setup_global_template):
+    @fc.template('home/index.pt')
+    def view_method(a, b, c):
+        fastapi_chameleon.not_found()
+        return {'a': a, 'b': b, 'c': c}
+
+    resp = view_method(1, 2, 3)
+    assert isinstance(resp, fastapi.Response)
+    assert resp.status_code == 404
+    assert b'<h1>This is a pretty 404 page.</h1>' in resp.body
+
+
+# setup_global_template - needed as pytest mix-in.
+# noinspection PyUnusedLocal
+def test_friendly_404_custom_template_sync_method(setup_global_template):
+    @fc.template('home/index.pt')
+    def view_method(a, b, c):
+        fastapi_chameleon.not_found(four04template_file='errors/other_error_page.pt')
+        return {'a': a, 'b': b, 'c': c}
+
+    resp = view_method(1, 2, 3)
+    assert isinstance(resp, fastapi.Response)
+    assert resp.status_code == 404
+    assert b'<h1>Another pretty 404 page.</h1>' in resp.body
+
+
+# setup_global_template - needed as pytest mix-in.
+# noinspection PyUnusedLocal
+def test_friendly_404_async_method(setup_global_template):
+    @fc.template('home/index.pt')
+    async def view_method(a, b, c):
+        fastapi_chameleon.not_found()
+        return {'a': a, 'b': b, 'c': c}
+
+    resp = asyncio.run(view_method(1, 2, 3))
+    assert isinstance(resp, fastapi.Response)
+    assert resp.status_code == 404
+    assert b'<h1>This is a pretty 404 page.</h1>' in resp.body

fastapi_chameleon-0.1.14/tests/test_render.py

@@ -0,0 +1,102 @@
+import asyncio
+
+import fastapi
+# noinspection PyPackageRequirements
+import pytest
+
+import fastapi_chameleon as fc
+
+
+# setup_global_template - needed as pytest mix-in.
+# noinspection PyUnusedLocal
+def test_cannot_decorate_missing_template(setup_global_template):
+    with pytest.raises(ValueError):
+        @fc.template('home/missing.pt')
+        def view_method():
+            return {}
+
+        view_method()
+
+
+# setup_global_template - needed as pytest mix-in.
+# noinspection PyUnusedLocal
+def test_requires_template_for_default_name(setup_global_template):
+    with pytest.raises(ValueError):
+        @fc.template(None)
+        def view_method():
+            return {}
+
+        view_method()
+
+
+# setup_global_template - needed as pytest mix-in.
+# noinspection PyUnusedLocal
+def test_default_template_name_pt(setup_global_template):
+    @fc.template()
+    def index(a, b, c):
+        return {'a': a, 'b': b, 'c': c, 'world': 'WORLD'}
+
+    resp = index(1, 2, 3)
+    assert isinstance(resp, fastapi.Response)
+    assert resp.status_code == 200
+    html = resp.body.decode('utf-8')
+    assert '<h1>Hello default WORLD!</h1>' in html
+
+
+# setup_global_template - needed as pytest mix-in.
+# noinspection PyUnusedLocal
+def test_default_template_name_no_parentheses(setup_global_template):
+    @fc.template
+    def index(a, b, c):
+        return {'a': a, 'b': b, 'c': c, 'world': 'WORLD'}
+
+    resp = index(1, 2, 3)
+    assert isinstance(resp, fastapi.Response)
+    assert resp.status_code == 200
+    html = resp.body.decode('utf-8')
+    assert '<h1>Hello default WORLD!</h1>' in html
+
+
+def test_default_template_name_html(setup_global_template):
+    @fc.template()
+    def details(a, b, c):
+        return {'a': a, 'b': b, 'c': c, 'world': 'WORLD'}
+
+    resp = details(1, 2, 3)
+    assert isinstance(resp, fastapi.Response)
+    assert resp.status_code == 200
+    html = resp.body.decode('utf-8')
+    assert '<h1>Hello default WORLD!</h1>' in html
+
+
+# setup_global_template - needed as pytest mix-in.
+# noinspection PyUnusedLocal
+def test_can_decorate_dict_sync_method(setup_global_template):
+    @fc.template('home/index.pt')
+    def view_method(a, b, c):
+        return {'a': a, 'b': b, 'c': c}
+
+    resp = view_method(1, 2, 3)
+    assert isinstance(resp, fastapi.Response)
+    assert resp.status_code == 200
+
+
+def test_can_decorate_dict_async_method(setup_global_template):
+    @fc.template('home/index.pt')
+    async def view_method(a, b, c):
+        return {'a': a, 'b': b, 'c': c}
+
+    resp = asyncio.run(view_method(1, 2, 3))
+    assert isinstance(resp, fastapi.Response)
+    assert resp.status_code == 200
+
+
+def test_direct_response_pass_through():
+    @fc.template('home/index.pt')
+    def view_method(a, b, c):
+        return fastapi.Response(content='abc', status_code=418)
+
+    resp = view_method(1, 2, 3)
+    assert isinstance(resp, fastapi.Response)
+    assert resp.status_code == 418
+    assert resp.body == b"abc"