script files

Presently/venv/Lib/site-packages/_distutils_hack/__init__.py

+import sys
+import os
+import re
+import importlib
+import warnings
+
+
+is_pypy = '__pypy__' in sys.builtin_module_names
+
+
+warnings.filterwarnings('ignore',
+                        '.+ distutils .+ deprecated',
+                        DeprecationWarning)
+
+
+def warn_distutils_present():
+    if 'distutils' not in sys.modules:
+        return
+    if is_pypy and sys.version_info < (3, 7):
+        # PyPy for 3.6 unconditionally imports distutils, so bypass the warning
+        # https://foss.heptapod.net/pypy/pypy/-/blob/be829135bc0d758997b3566062999ee8b23872b4/lib-python/3/site.py#L250
+        return
+    warnings.warn(
+        "Distutils was imported before Setuptools, but importing Setuptools "
+        "also replaces the `distutils` module in `sys.modules`. This may lead "
+        "to undesirable behaviors or errors. To avoid these issues, avoid "
+        "using distutils directly, ensure that setuptools is installed in the "
+        "traditional way (e.g. not an editable install), and/or make sure "
+        "that setuptools is always imported before distutils.")
+
+
+def clear_distutils():
+    if 'distutils' not in sys.modules:
+        return
+    warnings.warn("Setuptools is replacing distutils.")
+    mods = [name for name in sys.modules if re.match(r'distutils\b', name)]
+    for name in mods:
+        del sys.modules[name]
+
+
+def enabled():
+    """
+    Allow selection of distutils by environment variable.
+    """
+    which = os.environ.get('SETUPTOOLS_USE_DISTUTILS', 'stdlib')
+    return which == 'local'
+
+
+def ensure_local_distutils():
+    clear_distutils()
+    distutils = importlib.import_module('setuptools._distutils')
+    distutils.__name__ = 'distutils'
+    sys.modules['distutils'] = distutils
+
+    # sanity check that submodules load as expected
+    core = importlib.import_module('distutils.core')
+    assert '_distutils' in core.__file__, core.__file__
+
+
+def do_override():
+    """
+    Ensure that the local copy of distutils is preferred over stdlib.
+
+    See https://github.com/pypa/setuptools/issues/417#issuecomment-392298401
+    for more motivation.
+    """
+    if enabled():
+        warn_distutils_present()
+        ensure_local_distutils()
+
+
+class DistutilsMetaFinder:
+    def find_spec(self, fullname, path, target=None):
+        if path is not None:
+            return
+
+        method_name = 'spec_for_{fullname}'.format(**locals())
+        method = getattr(self, method_name, lambda: None)
+        return method()
+
+    def spec_for_distutils(self):
+        import importlib.abc
+        import importlib.util
+
+        class DistutilsLoader(importlib.abc.Loader):
+
+            def create_module(self, spec):
+                return importlib.import_module('setuptools._distutils')
+
+            def exec_module(self, module):
+                pass
+
+        return importlib.util.spec_from_loader('distutils', DistutilsLoader())
+
+    def spec_for_pip(self):
+        """
+        Ensure stdlib distutils when running under pip.
+        See pypa/pip#8761 for rationale.
+        """
+        if self.pip_imported_during_build():
+            return
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    @staticmethod
+    def pip_imported_during_build():
+        """
+        Detect if pip is being imported in a build script. Ref #2355.
+        """
+        import traceback
+        return any(
+            frame.f_globals['__file__'].endswith('setup.py')
+            for frame, line in traceback.walk_stack(None)
+        )
+
+
+DISTUTILS_FINDER = DistutilsMetaFinder()
+
+
+def add_shim():
+    sys.meta_path.insert(0, DISTUTILS_FINDER)
+
+
+def remove_shim():
+    try:
+        sys.meta_path.remove(DISTUTILS_FINDER)
+    except ValueError:
+        pass

Presently/venv/Lib/site-packages/_distutils_hack/override.py

+__import__('_distutils_hack').do_override()

Presently/venv/Lib/site-packages/asgiref-3.5.0.dist-info/INSTALLER

+pip

Presently/venv/Lib/site-packages/asgiref-3.5.0.dist-info/LICENSE

+Copyright (c) Django Software Foundation and individual contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+
+    3. Neither the name of Django nor the names of its contributors may be used
+       to endorse or promote products derived from this software without
+       specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Presently/venv/Lib/site-packages/asgiref-3.5.0.dist-info/METADATA

+Metadata-Version: 2.1
+Name: asgiref
+Version: 3.5.0
+Summary: ASGI specs, helper code, and adapters
+Home-page: https://github.com/django/asgiref/
+Author: Django Software Foundation
+Author-email: foundation@djangoproject.com
+License: BSD
+Project-URL: Documentation, https://asgi.readthedocs.io/
+Project-URL: Further Documentation, https://docs.djangoproject.com/en/stable/topics/async/#async-adapter-functions
+Project-URL: Changelog, https://github.com/django/asgiref/blob/master/CHANGELOG.txt
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.7
+License-File: LICENSE
+Requires-Dist: typing-extensions ; python_version < "3.8"
+Provides-Extra: tests
+Requires-Dist: pytest ; extra == 'tests'
+Requires-Dist: pytest-asyncio ; extra == 'tests'
+Requires-Dist: mypy (>=0.800) ; extra == 'tests'
+
+asgiref
+=======
+
+.. image:: https://api.travis-ci.org/django/asgiref.svg
+    :target: https://travis-ci.org/django/asgiref
+
+.. image:: https://img.shields.io/pypi/v/asgiref.svg
+    :target: https://pypi.python.org/pypi/asgiref
+
+ASGI is a standard for Python asynchronous web apps and servers to communicate
+with each other, and positioned as an asynchronous successor to WSGI. You can
+read more at https://asgi.readthedocs.io/en/latest/
+
+This package includes ASGI base libraries, such as:
+
+* Sync-to-async and async-to-sync function wrappers, ``asgiref.sync``
+* Server base classes, ``asgiref.server``
+* A WSGI-to-ASGI adapter, in ``asgiref.wsgi``
+
+
+Function wrappers
+-----------------
+
+These allow you to wrap or decorate async or sync functions to call them from
+the other style (so you can call async functions from a synchronous thread,
+or vice-versa).
+
+In particular:
+
+* AsyncToSync lets a synchronous subthread stop and wait while the async
+  function is called on the main thread's event loop, and then control is
+  returned to the thread when the async function is finished.
+
+* SyncToAsync lets async code call a synchronous function, which is run in
+  a threadpool and control returned to the async coroutine when the synchronous
+  function completes.
+
+The idea is to make it easier to call synchronous APIs from async code and
+asynchronous APIs from synchronous code so it's easier to transition code from
+one style to the other. In the case of Channels, we wrap the (synchronous)
+Django view system with SyncToAsync to allow it to run inside the (asynchronous)
+ASGI server.
+
+Note that exactly what threads things run in is very specific, and aimed to
+keep maximum compatibility with old synchronous code. See
+"Synchronous code & Threads" below for a full explanation. By default,
+``sync_to_async`` will run all synchronous code in the program in the same
+thread for safety reasons; you can disable this for more performance with
+``@sync_to_async(thread_sensitive=False)``, but make sure that your code does
+not rely on anything bound to threads (like database connections) when you do.
+
+
+Threadlocal replacement
+-----------------------
+
+This is a drop-in replacement for ``threading.local`` that works with both
+threads and asyncio Tasks. Even better, it will proxy values through from a
+task-local context to a thread-local context when you use ``sync_to_async``
+to run things in a threadpool, and vice-versa for ``async_to_sync``.
+
+If you instead want true thread- and task-safety, you can set
+``thread_critical`` on the Local object to ensure this instead.
+
+
+Server base classes
+-------------------
+
+Includes a ``StatelessServer`` class which provides all the hard work of
+writing a stateless server (as in, does not handle direct incoming sockets
+but instead consumes external streams or sockets to work out what is happening).
+
+An example of such a server would be a chatbot server that connects out to
+a central chat server and provides a "connection scope" per user chatting to
+it. There's only one actual connection, but the server has to separate things
+into several scopes for easier writing of the code.
+
+You can see an example of this being used in `frequensgi <https://github.com/andrewgodwin/frequensgi>`_.
+
+
+WSGI-to-ASGI adapter
+--------------------
+
+Allows you to wrap a WSGI application so it appears as a valid ASGI application.
+
+Simply wrap it around your WSGI application like so::
+
+    asgi_application = WsgiToAsgi(wsgi_application)
+
+The WSGI application will be run in a synchronous threadpool, and the wrapped
+ASGI application will be one that accepts ``http`` class messages.
+
+Please note that not all extended features of WSGI may be supported (such as
+file handles for incoming POST bodies).
+
+
+Dependencies
+------------
+
+``asgiref`` requires Python 3.7 or higher.
+
+
+Contributing
+------------
+
+Please refer to the
+`main Channels contributing docs <https://github.com/django/channels/blob/master/CONTRIBUTING.rst>`_.
+
+
+Testing
+'''''''
+
+To run tests, make sure you have installed the ``tests`` extra with the package::
+
+    cd asgiref/
+    pip install -e .[tests]
+    pytest
+
+
+Building the documentation
+''''''''''''''''''''''''''
+
+The documentation uses `Sphinx <http://www.sphinx-doc.org>`_::
+
+    cd asgiref/docs/
+    pip install sphinx
+
+To build the docs, you can use the default tools::
+
+    sphinx-build -b html . _build/html  # or `make html`, if you've got make set up
+    cd _build/html
+    python -m http.server
+
+...or you can use ``sphinx-autobuild`` to run a server and rebuild/reload
+your documentation changes automatically::
+
+    pip install sphinx-autobuild
+    sphinx-autobuild . _build/html
+
+
+Releasing
+'''''''''
+
+To release, first add details to CHANGELOG.txt and update the version number in ``asgiref/__init__.py``.
+
+Then, build and push the packages::
+
+    python -m build
+    twine upload dist/*
+    rm -r build/ dist/
+
+
+Implementation Details
+----------------------
+
+Synchronous code & threads
+''''''''''''''''''''''''''
+
+The ``asgiref.sync`` module provides two wrappers that let you go between
+asynchronous and synchronous code at will, while taking care of the rough edges
+for you.
+
+Unfortunately, the rough edges are numerous, and the code has to work especially
+hard to keep things in the same thread as much as possible. Notably, the
+restrictions we are working with are:
+
+* All synchronous code called through ``SyncToAsync`` and marked with
+  ``thread_sensitive`` should run in the same thread as each other (and if the
+  outer layer of the program is synchronous, the main thread)
+
+* If a thread already has a running async loop, ``AsyncToSync`` can't run things
+  on that loop if it's blocked on synchronous code that is above you in the
+  call stack.
+
+The first compromise you get to might be that ``thread_sensitive`` code should
+just run in the same thread and not spawn in a sub-thread, fulfilling the first
+restriction, but that immediately runs you into the second restriction.
+
+The only real solution is to essentially have a variant of ThreadPoolExecutor
+that executes any ``thread_sensitive`` code on the outermost synchronous
+thread - either the main thread, or a single spawned subthread.
+
+This means you now have two basic states:
+
+* If the outermost layer of your program is synchronous, then all async code
+  run through ``AsyncToSync`` will run in a per-call event loop in arbitrary
+  sub-threads, while all ``thread_sensitive`` code will run in the main thread.
+
+* If the outermost layer of your program is asynchronous, then all async code
+  runs on the main thread's event loop, and all ``thread_sensitive`` synchronous
+  code will run in a single shared sub-thread.
+
+Crucially, this means that in both cases there is a thread which is a shared
+resource that all ``thread_sensitive`` code must run on, and there is a chance
+that this thread is currently blocked on its own ``AsyncToSync`` call. Thus,
+``AsyncToSync`` needs to act as an executor for thread code while it's blocking.
+
+The ``CurrentThreadExecutor`` class provides this functionality; rather than
+simply waiting on a Future, you can call its ``run_until_future`` method and
+it will run submitted code until that Future is done. This means that code
+inside the call can then run code on your thread.
+
+
+Maintenance and Security
+------------------------
+
+To report security issues, please contact security@djangoproject.com. For GPG
+signatures and more security process information, see
+https://docs.djangoproject.com/en/dev/internals/security/.
+
+To report bugs or request new features, please open a new GitHub issue.
+
+This repository is part of the Channels project. For the shepherd and maintenance team, please see the
+`main Channels readme <https://github.com/django/channels/blob/master/README.rst>`_.
+
+

Presently/venv/Lib/site-packages/asgiref-3.5.0.dist-info/RECORD

+asgiref-3.5.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+asgiref-3.5.0.dist-info/LICENSE,sha256=uEZBXRtRTpwd_xSiLeuQbXlLxUbKYSn5UKGM0JHipmk,1552
+asgiref-3.5.0.dist-info/METADATA,sha256=bMkU821Y4ssj34LYK6R1ytLYcpXhqagXszRtAentodE,9163
+asgiref-3.5.0.dist-info/RECORD,,
+asgiref-3.5.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+asgiref-3.5.0.dist-info/top_level.txt,sha256=bokQjCzwwERhdBiPdvYEZa4cHxT4NCeAffQNUqJ8ssg,8
+asgiref/__init__.py,sha256=j0HWOe68EJbDKQHKURp6LgON8HyoWHbKmvvCvTB1OzA,22
+asgiref/__pycache__/__init__.cpython-39.pyc,,
+asgiref/__pycache__/compatibility.cpython-39.pyc,,
+asgiref/__pycache__/current_thread_executor.cpython-39.pyc,,
+asgiref/__pycache__/local.cpython-39.pyc,,
+asgiref/__pycache__/server.cpython-39.pyc,,
+asgiref/__pycache__/sync.cpython-39.pyc,,
+asgiref/__pycache__/testing.cpython-39.pyc,,
+asgiref/__pycache__/timeout.cpython-39.pyc,,
+asgiref/__pycache__/typing.cpython-39.pyc,,
+asgiref/__pycache__/wsgi.cpython-39.pyc,,
+asgiref/compatibility.py,sha256=MVH2bEdiCMMVTLbE-1V6KiU7q4LwqzP7PIufeXa-njM,1598
+asgiref/current_thread_executor.py,sha256=oeH8zv2tTmcbpxdUmOSMzbEXzeY5nJzIMFvzprE95gA,2801
+asgiref/local.py,sha256=nx5RqVFLYgUJVaxzApuQUW7dd9y21sruMYdgISoRs1k,4854
+asgiref/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+asgiref/server.py,sha256=egTQhZo1k4G0F7SSBQNp_VOekpGcjBJZU2kkCoiGC_M,6005
+asgiref/sync.py,sha256=ugODYuUwixVJ1kYXzPQzMvDBQnSHd9h2dHo-CSZ5I0E,19304
+asgiref/testing.py,sha256=3byNRV7Oto_Fg8Z-fErQJ3yGf7OQlcUexbN_cDQugzQ,3119
+asgiref/timeout.py,sha256=5Ekbmn3X1HPR55qgx-hPJMPEu_-YoivHqNhFEitiSYE,3440
+asgiref/typing.py,sha256=MZ7vbJY1F7EQqo9gL9pMSFRMw9b_SQrQQsnvlJQ2iP4,5603
+asgiref/wsgi.py,sha256=-L0eo_uK_dq7EPjv1meW1BRGytURaO9NPESxnJc9CtA,6575

Presently/venv/Lib/site-packages/asgiref-3.5.0.dist-info/WHEEL

+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

Presently/venv/Lib/site-packages/asgiref-3.5.0.dist-info/top_level.txt

+asgiref

Presently/venv/Lib/site-packages/asgiref/__init__.py

+__version__ = "3.5.0"

Presently/venv/Lib/site-packages/asgiref/compatibility.py

+import asyncio
+import inspect
+
+
+def is_double_callable(application):
+    """
+    Tests to see if an application is a legacy-style (double-callable) application.
+    """
+    # Look for a hint on the object first
+    if getattr(application, "_asgi_single_callable", False):
+        return False
+    if getattr(application, "_asgi_double_callable", False):
+        return True
+    # Uninstanted classes are double-callable
+    if inspect.isclass(application):
+        return True
+    # Instanted classes depend on their __call__
+    if hasattr(application, "__call__"):
+        # We only check to see if its __call__ is a coroutine function -
+        # if it's not, it still might be a coroutine function itself.
+        if asyncio.iscoroutinefunction(application.__call__):
+            return False
+    # Non-classes we just check directly
+    return not asyncio.iscoroutinefunction(application)
+
+
+def double_to_single_callable(application):
+    """
+    Transforms a double-callable ASGI application into a single-callable one.
+    """
+
+    async def new_application(scope, receive, send):
+        instance = application(scope)
+        return await instance(receive, send)
+
+    return new_application
+
+
+def guarantee_single_callable(application):
+    """
+    Takes either a single- or double-callable application and always returns it
+    in single-callable style. Use this to add backwards compatibility for ASGI
+    2.0 applications to your server/test harness/etc.
+    """
+    if is_double_callable(application):
+        application = double_to_single_callable(application)
+    return application

Presently/venv/Lib/site-packages/asgiref/current_thread_executor.py

+import queue
+import threading
+from concurrent.futures import Executor, Future
+
+
+class _WorkItem:
+    """
+    Represents an item needing to be run in the executor.
+    Copied from ThreadPoolExecutor (but it's private, so we're not going to rely on importing it)
+    """
+
+    def __init__(self, future, fn, args, kwargs):
+        self.future = future
+        self.fn = fn
+        self.args = args
+        self.kwargs = kwargs
+
+    def run(self):
+        if not self.future.set_running_or_notify_cancel():
+            return
+        try:
+            result = self.fn(*self.args, **self.kwargs)
+        except BaseException as exc:
+            self.future.set_exception(exc)
+            # Break a reference cycle with the exception 'exc'
+            self = None
+        else:
+            self.future.set_result(result)
+
+
+class CurrentThreadExecutor(Executor):
+    """
+    An Executor that actually runs code in the thread it is instantiated in.
+    Passed to other threads running async code, so they can run sync code in
+    the thread they came from.
+    """
+
+    def __init__(self):
+        self._work_thread = threading.current_thread()
+        self._work_queue = queue.Queue()
+        self._broken = False
+
+    def run_until_future(self, future):
+        """
+        Runs the code in the work queue until a result is available from the future.
+        Should be run from the thread the executor is initialised in.
+        """
+        # Check we're in the right thread
+        if threading.current_thread() != self._work_thread:
+            raise RuntimeError(
+                "You cannot run CurrentThreadExecutor from a different thread"
+            )
+        future.add_done_callback(self._work_queue.put)
+        # Keep getting and running work items until we get the future we're waiting for
+        # back via the future's done callback.
+        try:
+            while True:
+                # Get a work item and run it
+                work_item = self._work_queue.get()
+                if work_item is future:
+                    return
+                work_item.run()
+                del work_item
+        finally:
+            self._broken = True
+
+    def submit(self, fn, *args, **kwargs):
+        # Check they're not submitting from the same thread
+        if threading.current_thread() == self._work_thread:
+            raise RuntimeError(
+                "You cannot submit onto CurrentThreadExecutor from its own thread"
+            )
+        # Check they're not too late or the executor errored
+        if self._broken:
+            raise RuntimeError("CurrentThreadExecutor already quit or is broken")
+        # Add to work queue
+        f = Future()
+        work_item = _WorkItem(f, fn, args, kwargs)
+        self._work_queue.put(work_item)
+        # Return the future
+        return f

Presently/venv/Lib/site-packages/asgiref/local.py

+import random
+import string
+import sys
+import threading
+import weakref
+
+
+class Local:
+    """
+    A drop-in replacement for threading.locals that also works with asyncio
+    Tasks (via the current_task asyncio method), and passes locals through
+    sync_to_async and async_to_sync.
+
+    Specifically:
+     - Locals work per-coroutine on any thread not spawned using asgiref
+     - Locals work per-thread on any thread not spawned using asgiref
+     - Locals are shared with the parent coroutine when using sync_to_async
+     - Locals are shared with the parent thread when using async_to_sync
+       (and if that thread was launched using sync_to_async, with its parent
+       coroutine as well, with this working for indefinite levels of nesting)
+
+    Set thread_critical to True to not allow locals to pass from an async Task
+    to a thread it spawns. This is needed for code that truly needs
+    thread-safety, as opposed to things used for helpful context (e.g. sqlite
+    does not like being called from a different thread to the one it is from).
+    Thread-critical code will still be differentiated per-Task within a thread
+    as it is expected it does not like concurrent access.
+
+    This doesn't use contextvars as it needs to support 3.6. Once it can support
+    3.7 only, we can then reimplement the storage more nicely.
+    """
+
+    def __init__(self, thread_critical: bool = False) -> None:
+        self._thread_critical = thread_critical
+        self._thread_lock = threading.RLock()
+        self._context_refs: "weakref.WeakSet[object]" = weakref.WeakSet()
+        # Random suffixes stop accidental reuse between different Locals,
+        # though we try to force deletion as well.
+        self._attr_name = "_asgiref_local_impl_{}_{}".format(
+            id(self),
+            "".join(random.choice(string.ascii_letters) for i in range(8)),
+        )
+
+    def _get_context_id(self):
+        """
+        Get the ID we should use for looking up variables
+        """
+        # Prevent a circular reference
+        from .sync import AsyncToSync, SyncToAsync
+
+        # First, pull the current task if we can
+        context_id = SyncToAsync.get_current_task()
+        context_is_async = True
+        # OK, let's try for a thread ID
+        if context_id is None:
+            context_id = threading.current_thread()
+            context_is_async = False
+        # If we're thread-critical, we stop here, as we can't share contexts.
+        if self._thread_critical:
+            return context_id
+        # Now, take those and see if we can resolve them through the launch maps
+        for i in range(sys.getrecursionlimit()):
+            try:
+                if context_is_async:
+                    # Tasks have a source thread in AsyncToSync
+                    context_id = AsyncToSync.launch_map[context_id]
+                    context_is_async = False
+                else:
+                    # Threads have a source task in SyncToAsync
+                    context_id = SyncToAsync.launch_map[context_id]
+                    context_is_async = True
+            except KeyError:
+                break
+        else:
+            # Catch infinite loops (they happen if you are screwing around
+            # with AsyncToSync implementations)
+            raise RuntimeError("Infinite launch_map loops")
+        return context_id
+
+    def _get_storage(self):
+        context_obj = self._get_context_id()
+        if not hasattr(context_obj, self._attr_name):
+            setattr(context_obj, self._attr_name, {})
+            self._context_refs.add(context_obj)
+        return getattr(context_obj, self._attr_name)
+
+    def __del__(self):
+        try:
+            for context_obj in self._context_refs:
+                try:
+                    delattr(context_obj, self._attr_name)
+                except AttributeError:
+                    pass
+        except TypeError:
+            # WeakSet.__iter__ can crash when interpreter is shutting down due
+            # to _IterationGuard being None.
+            pass
+
+    def __getattr__(self, key):
+        with self._thread_lock:
+            storage = self._get_storage()
+            if key in storage:
+                return storage[key]
+            else:
+                raise AttributeError(f"{self!r} object has no attribute {key!r}")
+
+    def __setattr__(self, key, value):
+        if key in ("_context_refs", "_thread_critical", "_thread_lock", "_attr_name"):
+            return super().__setattr__(key, value)
+        with self._thread_lock:
+            storage = self._get_storage()
+            storage[key] = value
+
+    def __delattr__(self, key):
+        with self._thread_lock:
+            storage = self._get_storage()
+            if key in storage:
+                del storage[key]
+            else:
+                raise AttributeError(f"{self!r} object has no attribute {key!r}")

Presently/venv/Lib/site-packages/asgiref/server.py

+import asyncio
+import logging
+import time
+import traceback
+
+from .compatibility import guarantee_single_callable
+
+logger = logging.getLogger(__name__)
+
+
+class StatelessServer:
+    """
+    Base server class that handles basic concepts like application instance
+    creation/pooling, exception handling, and similar, for stateless protocols
+    (i.e. ones without actual incoming connections to the process)
+
+    Your code should override the handle() method, doing whatever it needs to,
+    and calling get_or_create_application_instance with a unique `scope_id`
+    and `scope` for the scope it wants to get.
+
+    If an application instance is found with the same `scope_id`, you are
+    given its input queue, otherwise one is made for you with the scope provided
+    and you are given that fresh new input queue. Either way, you should do
+    something like:
+
+    input_queue = self.get_or_create_application_instance(
+        "user-123456",
+        {"type": "testprotocol", "user_id": "123456", "username": "andrew"},
+    )
+    input_queue.put_nowait(message)
+
+    If you try and create an application instance and there are already
+    `max_application` instances, the oldest/least recently used one will be
+    reclaimed and shut down to make space.
+
+    Application coroutines that error will be found periodically (every 100ms
+    by default) and have their exceptions printed to the console. Override
+    application_exception() if you want to do more when this happens.
+
+    If you override run(), make sure you handle things like launching the
+    application checker.
+    """
+
+    application_checker_interval = 0.1
+
+    def __init__(self, application, max_applications=1000):
+        # Parameters
+        self.application = application
+        self.max_applications = max_applications
+        # Initialisation
+        self.application_instances = {}
+
+    ### Mainloop and handling
+
+    def run(self):
+        """
+        Runs the asyncio event loop with our handler loop.
+        """
+        event_loop = asyncio.get_event_loop()
+        asyncio.ensure_future(self.application_checker())
+        try:
+            event_loop.run_until_complete(self.handle())
+        except KeyboardInterrupt:
+            logger.info("Exiting due to Ctrl-C/interrupt")
+
+    async def handle(self):
+        raise NotImplementedError("You must implement handle()")
+
+    async def application_send(self, scope, message):
+        """
+        Receives outbound sends from applications and handles them.
+        """
+        raise NotImplementedError("You must implement application_send()")
+
+    ### Application instance management
+
+    def get_or_create_application_instance(self, scope_id, scope):
+        """
+        Creates an application instance and returns its queue.
+        """
+        if scope_id in self.application_instances:
+            self.application_instances[scope_id]["last_used"] = time.time()
+            return self.application_instances[scope_id]["input_queue"]
+        # See if we need to delete an old one
+        while len(self.application_instances) > self.max_applications:
+            self.delete_oldest_application_instance()
+        # Make an instance of the application
+        input_queue = asyncio.Queue()
+        application_instance = guarantee_single_callable(self.application)
+        # Run it, and stash the future for later checking
+        future = asyncio.ensure_future(
+            application_instance(
+                scope=scope,
+                receive=input_queue.get,
+                send=lambda message: self.application_send(scope, message),
+            ),
+        )
+        self.application_instances[scope_id] = {
+            "input_queue": input_queue,
+            "future": future,
+            "scope": scope,
+            "last_used": time.time(),
+        }
+        return input_queue
+
+    def delete_oldest_application_instance(self):
+        """
+        Finds and deletes the oldest application instance
+        """
+        oldest_time = min(
+            details["last_used"] for details in self.application_instances.values()
+        )
+        for scope_id, details in self.application_instances.items():
+            if details["last_used"] == oldest_time:
+                self.delete_application_instance(scope_id)
+                # Return to make sure we only delete one in case two have
+                # the same oldest time
+                return
+
+    def delete_application_instance(self, scope_id):
+        """
+        Removes an application instance (makes sure its task is stopped,
+        then removes it from the current set)
+        """
+        details = self.application_instances[scope_id]
+        del self.application_instances[scope_id]
+        if not details["future"].done():
+            details["future"].cancel()
+
+    async def application_checker(self):
+        """
+        Goes through the set of current application instance Futures and cleans up
+        any that are done/prints exceptions for any that errored.
+        """
+        while True:
+            await asyncio.sleep(self.application_checker_interval)
+            for scope_id, details in list(self.application_instances.items()):
+                if details["future"].done():
+                    exception = details["future"].exception()
+                    if exception:
+                        await self.application_exception(exception, details)
+                    try:
+                        del self.application_instances[scope_id]
+                    except KeyError:
+                        # Exception handling might have already got here before us. That's fine.
+                        pass
+
+    async def application_exception(self, exception, application_details):
+        """
+        Called whenever an application coroutine has an exception.
+        """
+        logging.error(
+            "Exception inside application: %s\n%s%s",
+            exception,
+            "".join(traceback.format_tb(exception.__traceback__)),
+            f"  {exception}",
+        )

Presently/venv/Lib/site-packages/asgiref/testing.py

+import asyncio
+import time
+
+from .compatibility import guarantee_single_callable
+from .timeout import timeout as async_timeout
+
+
+class ApplicationCommunicator:
+    """
+    Runs an ASGI application in a test mode, allowing sending of
+    messages to it and retrieval of messages it sends.
+    """
+
+    def __init__(self, application, scope):
+        self.application = guarantee_single_callable(application)
+        self.scope = scope
+        self.input_queue = asyncio.Queue()
+        self.output_queue = asyncio.Queue()
+        self.future = asyncio.ensure_future(
+            self.application(scope, self.input_queue.get, self.output_queue.put)
+        )
+
+    async def wait(self, timeout=1):
+        """
+        Waits for the application to stop itself and returns any exceptions.
+        """
+        try:
+            async with async_timeout(timeout):
+                try:
+                    await self.future
+                    self.future.result()
+                except asyncio.CancelledError:
+                    pass
+        finally:
+            if not self.future.done():
+                self.future.cancel()
+                try:
+                    await self.future
+                except asyncio.CancelledError:
+                    pass
+
+    def stop(self, exceptions=True):
+        if not self.future.done():
+            self.future.cancel()
+        elif exceptions:
+            # Give a chance to raise any exceptions
+            self.future.result()
+
+    def __del__(self):
+        # Clean up on deletion
+        try:
+            self.stop(exceptions=False)
+        except RuntimeError:
+            # Event loop already stopped
+            pass
+
+    async def send_input(self, message):
+        """
+        Sends a single message to the application
+        """
+        # Give it the message
+        await self.input_queue.put(message)
+
+    async def receive_output(self, timeout=1):
+        """
+        Receives a single message from the application, with optional timeout.
+        """
+        # Make sure there's not an exception to raise from the task
+        if self.future.done():
+            self.future.result()
+        # Wait and receive the message
+        try:
+            async with async_timeout(timeout):
+                return await self.output_queue.get()
+        except asyncio.TimeoutError as e:
+            # See if we have another error to raise inside
+            if self.future.done():
+                self.future.result()
+            else:
+                self.future.cancel()
+                try:
+                    await self.future
+                except asyncio.CancelledError:
+                    pass
+            raise e
+
+    async def receive_nothing(self, timeout=0.1, interval=0.01):
+        """
+        Checks that there is no message to receive in the given time.
+        """
+        # `interval` has precedence over `timeout`
+        start = time.monotonic()
+        while time.monotonic() - start < timeout:
+            if not self.output_queue.empty():
+                return False
+            await asyncio.sleep(interval)
+        return self.output_queue.empty()

Presently/venv/Lib/site-packages/asgiref/timeout.py

+# This code is originally sourced from the aio-libs project "async_timeout",
+# under the Apache 2.0 license. You may see the original project at
+# https://github.com/aio-libs/async-timeout
+
+# It is vendored here to reduce chain-dependencies on this library, and
+# modified slightly to remove some features we don't use.
+
+
+import asyncio
+from types import TracebackType
+from typing import Any, Optional, Type
+
+
+class timeout:
+    """timeout context manager.
+
+    Useful in cases when you want to apply timeout logic around block
+    of code or in cases when asyncio.wait_for is not suitable. For example:
+
+    >>> with timeout(0.001):
+    ...     async with aiohttp.get('https://github.com') as r:
+    ...         await r.text()
+
+
+    timeout - value in seconds or None to disable timeout logic
+    loop - asyncio compatible event loop
+    """
+
+    def __init__(
+        self,
+        timeout: Optional[float],
+        *,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+    ) -> None:
+        self._timeout = timeout
+        if loop is None:
+            loop = asyncio.get_event_loop()
+        self._loop = loop
+        self._task = None  # type: Optional[asyncio.Task[Any]]
+        self._cancelled = False
+        self._cancel_handler = None  # type: Optional[asyncio.Handle]
+        self._cancel_at = None  # type: Optional[float]
+
+    def __enter__(self) -> "timeout":
+        return self._do_enter()
+
+    def __exit__(
+        self,
+        exc_type: Type[BaseException],
+        exc_val: BaseException,
+        exc_tb: TracebackType,
+    ) -> Optional[bool]:
+        self._do_exit(exc_type)
+        return None
+
+    async def __aenter__(self) -> "timeout":
+        return self._do_enter()
+
+    async def __aexit__(
+        self,
+        exc_type: Type[BaseException],
+        exc_val: BaseException,
+        exc_tb: TracebackType,
+    ) -> None:
+        self._do_exit(exc_type)
+
+    @property
+    def expired(self) -> bool:
+        return self._cancelled
+
+    @property
+    def remaining(self) -> Optional[float]:
+        if self._cancel_at is not None:
+            return max(self._cancel_at - self._loop.time(), 0.0)
+        else:
+            return None
+
+    def _do_enter(self) -> "timeout":
+        # Support Tornado 5- without timeout
+        # Details: https://github.com/python/asyncio/issues/392
+        if self._timeout is None:
+            return self
+
+        self._task = asyncio.current_task(self._loop)
+        if self._task is None:
+            raise RuntimeError(
+                "Timeout context manager should be used " "inside a task"
+            )
+
+        if self._timeout <= 0:
+            self._loop.call_soon(self._cancel_task)
+            return self
+
+        self._cancel_at = self._loop.time() + self._timeout
+        self._cancel_handler = self._loop.call_at(self._cancel_at, self._cancel_task)
+        return self
+
+    def _do_exit(self, exc_type: Type[BaseException]) -> None:
+        if exc_type is asyncio.CancelledError and self._cancelled:
+            self._cancel_handler = None
+            self._task = None
+            raise asyncio.TimeoutError
+        if self._timeout is not None and self._cancel_handler is not None:
+            self._cancel_handler.cancel()
+            self._cancel_handler = None
+        self._task = None
+        return None
+
+    def _cancel_task(self) -> None:
+        if self._task is not None:
+            self._task.cancel()
+            self._cancelled = True

Presently/venv/Lib/site-packages/asgiref/typing.py

+import sys
+from typing import Awaitable, Callable, Dict, Iterable, Optional, Tuple, Type, Union
+
+if sys.version_info >= (3, 8):
+    from typing import Literal, Protocol, TypedDict
+else:
+    from typing_extensions import Literal, Protocol, TypedDict
+
+__all__ = (
+    "ASGIVersions",
+    "HTTPScope",
+    "WebSocketScope",
+    "LifespanScope",
+    "WWWScope",
+    "Scope",
+    "HTTPRequestEvent",
+    "HTTPResponseStartEvent",
+    "HTTPResponseBodyEvent",
+    "HTTPServerPushEvent",
+    "HTTPDisconnectEvent",
+    "WebSocketConnectEvent",
+    "WebSocketAcceptEvent",
+    "WebSocketReceiveEvent",
+    "WebSocketSendEvent",
+    "WebSocketResponseStartEvent",
+    "WebSocketResponseBodyEvent",
+    "WebSocketDisconnectEvent",
+    "WebSocketCloseEvent",
+    "LifespanStartupEvent",
+    "LifespanShutdownEvent",
+    "LifespanStartupCompleteEvent",
+    "LifespanStartupFailedEvent",
+    "LifespanShutdownCompleteEvent",
+    "LifespanShutdownFailedEvent",
+    "ASGIReceiveEvent",
+    "ASGISendEvent",
+    "ASGIReceiveCallable",
+    "ASGISendCallable",
+    "ASGI2Protocol",
+    "ASGI2Application",
+    "ASGI3Application",
+    "ASGIApplication",
+)
+
+
+class ASGIVersions(TypedDict):
+    spec_version: str
+    version: Union[Literal["2.0"], Literal["3.0"]]
+
+
+class HTTPScope(TypedDict):
+    type: Literal["http"]
+    asgi: ASGIVersions
+    http_version: str
+    method: str
+    scheme: str
+    path: str
+    raw_path: bytes
+    query_string: bytes
+    root_path: str
+    headers: Iterable[Tuple[bytes, bytes]]
+    client: Optional[Tuple[str, int]]
+    server: Optional[Tuple[str, Optional[int]]]
+    extensions: Optional[Dict[str, Dict[object, object]]]
+
+
+class WebSocketScope(TypedDict):
+    type: Literal["websocket"]
+    asgi: ASGIVersions
+    http_version: str
+    scheme: str
+    path: str
+    raw_path: bytes
+    query_string: bytes
+    root_path: str
+    headers: Iterable[Tuple[bytes, bytes]]
+    client: Optional[Tuple[str, int]]
+    server: Optional[Tuple[str, Optional[int]]]
+    subprotocols: Iterable[str]
+    extensions: Optional[Dict[str, Dict[object, object]]]
+
+
+class LifespanScope(TypedDict):
+    type: Literal["lifespan"]
+    asgi: ASGIVersions
+
+
+WWWScope = Union[HTTPScope, WebSocketScope]
+Scope = Union[HTTPScope, WebSocketScope, LifespanScope]
+
+
+class HTTPRequestEvent(TypedDict):
+    type: Literal["http.request"]
+    body: bytes
+    more_body: bool
+
+
+class HTTPResponseStartEvent(TypedDict):
+    type: Literal["http.response.start"]
+    status: int
+    headers: Iterable[Tuple[bytes, bytes]]
+
+
+class HTTPResponseBodyEvent(TypedDict):
+    type: Literal["http.response.body"]
+    body: bytes
+    more_body: bool
+
+
+class HTTPServerPushEvent(TypedDict):
+    type: Literal["http.response.push"]
+    path: str
+    headers: Iterable[Tuple[bytes, bytes]]
+
+
+class HTTPDisconnectEvent(TypedDict):
+    type: Literal["http.disconnect"]
+
+
+class WebSocketConnectEvent(TypedDict):
+    type: Literal["websocket.connect"]
+
+
+class WebSocketAcceptEvent(TypedDict):
+    type: Literal["websocket.accept"]
+    subprotocol: Optional[str]
+    headers: Iterable[Tuple[bytes, bytes]]
+
+
+class WebSocketReceiveEvent(TypedDict):
+    type: Literal["websocket.receive"]
+    bytes: Optional[bytes]
+    text: Optional[str]
+
+
+class WebSocketSendEvent(TypedDict):
+    type: Literal["websocket.send"]
+    bytes: Optional[bytes]
+    text: Optional[str]
+
+
+class WebSocketResponseStartEvent(TypedDict):
+    type: Literal["websocket.http.response.start"]
+    status: int
+    headers: Iterable[Tuple[bytes, bytes]]
+
+
+class WebSocketResponseBodyEvent(TypedDict):
+    type: Literal["websocket.http.response.body"]
+    body: bytes
+    more_body: bool
+
+
+class WebSocketDisconnectEvent(TypedDict):
+    type: Literal["websocket.disconnect"]
+    code: int
+
+
+class WebSocketCloseEvent(TypedDict):
+    type: Literal["websocket.close"]
+    code: int
+    reason: Optional[str]
+
+
+class LifespanStartupEvent(TypedDict):
+    type: Literal["lifespan.startup"]
+
+
+class LifespanShutdownEvent(TypedDict):
+    type: Literal["lifespan.shutdown"]
+
+
+class LifespanStartupCompleteEvent(TypedDict):
+    type: Literal["lifespan.startup.complete"]
+
+
+class LifespanStartupFailedEvent(TypedDict):
+    type: Literal["lifespan.startup.failed"]
+    message: str
+
+
+class LifespanShutdownCompleteEvent(TypedDict):
+    type: Literal["lifespan.shutdown.complete"]
+
+
+class LifespanShutdownFailedEvent(TypedDict):
+    type: Literal["lifespan.shutdown.failed"]
+    message: str
+
+
+ASGIReceiveEvent = Union[
+    HTTPRequestEvent,
+    HTTPDisconnectEvent,
+    WebSocketConnectEvent,
+    WebSocketReceiveEvent,
+    WebSocketDisconnectEvent,
+    LifespanStartupEvent,
+    LifespanShutdownEvent,
+]
+
+
+ASGISendEvent = Union[
+    HTTPResponseStartEvent,
+    HTTPResponseBodyEvent,
+    HTTPServerPushEvent,
+    HTTPDisconnectEvent,
+    WebSocketAcceptEvent,
+    WebSocketSendEvent,
+    WebSocketResponseStartEvent,
+    WebSocketResponseBodyEvent,
+    WebSocketCloseEvent,
+    LifespanStartupCompleteEvent,
+    LifespanStartupFailedEvent,
+    LifespanShutdownCompleteEvent,
+    LifespanShutdownFailedEvent,
+]
+
+
+ASGIReceiveCallable = Callable[[], Awaitable[ASGIReceiveEvent]]
+ASGISendCallable = Callable[[ASGISendEvent], Awaitable[None]]
+
+
+class ASGI2Protocol(Protocol):
+    def __init__(self, scope: Scope) -> None:
+        ...
+
+    async def __call__(
+        self, receive: ASGIReceiveCallable, send: ASGISendCallable
+    ) -> None:
+        ...
+
+
+ASGI2Application = Type[ASGI2Protocol]
+ASGI3Application = Callable[
+    [
+        Scope,
+        ASGIReceiveCallable,
+        ASGISendCallable,
+    ],
+    Awaitable[None],
+]
+ASGIApplication = Union[ASGI2Application, ASGI3Application]

Presently/venv/Lib/site-packages/asgiref/wsgi.py

+from io import BytesIO
+from tempfile import SpooledTemporaryFile
+
+from asgiref.sync import AsyncToSync, sync_to_async
+
+
+class WsgiToAsgi:
+    """
+    Wraps a WSGI application to make it into an ASGI application.
+    """
+
+    def __init__(self, wsgi_application):
+        self.wsgi_application = wsgi_application
+
+    async def __call__(self, scope, receive, send):
+        """
+        ASGI application instantiation point.
+        We return a new WsgiToAsgiInstance here with the WSGI app
+        and the scope, ready to respond when it is __call__ed.
+        """
+        await WsgiToAsgiInstance(self.wsgi_application)(scope, receive, send)
+
+
+class WsgiToAsgiInstance:
+    """
+    Per-socket instance of a wrapped WSGI application
+    """
+
+    def __init__(self, wsgi_application):
+        self.wsgi_application = wsgi_application
+        self.response_started = False
+        self.response_content_length = None
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] != "http":
+            raise ValueError("WSGI wrapper received a non-HTTP scope")
+        self.scope = scope
+        with SpooledTemporaryFile(max_size=65536) as body:
+            # Alright, wait for the http.request messages
+            while True:
+                message = await receive()
+                if message["type"] != "http.request":
+                    raise ValueError("WSGI wrapper received a non-HTTP-request message")
+                body.write(message.get("body", b""))
+                if not message.get("more_body"):
+                    break
+            body.seek(0)
+            # Wrap send so it can be called from the subthread
+            self.sync_send = AsyncToSync(send)
+            # Call the WSGI app
+            await self.run_wsgi_app(body)
+
+    def build_environ(self, scope, body):
+        """
+        Builds a scope and request body into a WSGI environ object.
+        """
+        environ = {
+            "REQUEST_METHOD": scope["method"],
+            "SCRIPT_NAME": scope.get("root_path", "").encode("utf8").decode("latin1"),
+            "PATH_INFO": scope["path"].encode("utf8").decode("latin1"),
+            "QUERY_STRING": scope["query_string"].decode("ascii"),
+            "SERVER_PROTOCOL": "HTTP/%s" % scope["http_version"],
+            "wsgi.version": (1, 0),
+            "wsgi.url_scheme": scope.get("scheme", "http"),
+            "wsgi.input": body,
+            "wsgi.errors": BytesIO(),
+            "wsgi.multithread": True,
+            "wsgi.multiprocess": True,
+            "wsgi.run_once": False,
+        }
+        # Get server name and port - required in WSGI, not in ASGI
+        if "server" in scope:
+            environ["SERVER_NAME"] = scope["server"][0]
+            environ["SERVER_PORT"] = str(scope["server"][1])
+        else:
+            environ["SERVER_NAME"] = "localhost"
+            environ["SERVER_PORT"] = "80"
+
+        if "client" in scope:
+            environ["REMOTE_ADDR"] = scope["client"][0]
+
+        # Go through headers and make them into environ entries
+        for name, value in self.scope.get("headers", []):
+            name = name.decode("latin1")
+            if name == "content-length":
+                corrected_name = "CONTENT_LENGTH"
+            elif name == "content-type":
+                corrected_name = "CONTENT_TYPE"
+            else:
+                corrected_name = "HTTP_%s" % name.upper().replace("-", "_")
+            # HTTPbis say only ASCII chars are allowed in headers, but we latin1 just in case
+            value = value.decode("latin1")
+            if corrected_name in environ:
+                value = environ[corrected_name] + "," + value
+            environ[corrected_name] = value
+        return environ
+
+    def start_response(self, status, response_headers, exc_info=None):
+        """
+        WSGI start_response callable.
+        """
+        # Don't allow re-calling once response has begun
+        if self.response_started:
+            raise exc_info[1].with_traceback(exc_info[2])
+        # Don't allow re-calling without exc_info
+        if hasattr(self, "response_start") and exc_info is None:
+            raise ValueError(
+                "You cannot call start_response a second time without exc_info"
+            )
+        # Extract status code
+        status_code, _ = status.split(" ", 1)
+        status_code = int(status_code)
+        # Extract headers
+        headers = [
+            (name.lower().encode("ascii"), value.encode("ascii"))
+            for name, value in response_headers
+        ]
+        # Extract content-length
+        self.response_content_length = None
+        for name, value in response_headers:
+            if name.lower() == "content-length":
+                self.response_content_length = int(value)
+        # Build and send response start message.
+        self.response_start = {
+            "type": "http.response.start",
+            "status": status_code,
+            "headers": headers,
+        }
+
+    @sync_to_async
+    def run_wsgi_app(self, body):
+        """
+        Called in a subthread to run the WSGI app. We encapsulate like
+        this so that the start_response callable is called in the same thread.
+        """
+        # Translate the scope and incoming request body into a WSGI environ
+        environ = self.build_environ(self.scope, body)
+        # Run the WSGI app
+        bytes_sent = 0
+        for output in self.wsgi_application(environ, self.start_response):
+            # If this is the first response, include the response headers
+            if not self.response_started:
+                self.response_started = True
+                self.sync_send(self.response_start)
+            # If the application supplies a Content-Length header
+            if self.response_content_length is not None:
+                # The server should not transmit more bytes to the client than the header allows
+                bytes_allowed = self.response_content_length - bytes_sent
+                if len(output) > bytes_allowed:
+                    output = output[:bytes_allowed]
+            self.sync_send(
+                {"type": "http.response.body", "body": output, "more_body": True}
+            )
+            bytes_sent += len(output)
+            # The server should stop iterating over the response when enough data has been sent
+            if bytes_sent == self.response_content_length:
+                break
+        # Close connection
+        if not self.response_started:
+            self.response_started = True
+            self.sync_send(self.response_start)
+        self.sync_send({"type": "http.response.body"})

Presently/venv/Lib/site-packages/crispy_forms/__init__.py

+__version__ = "1.14.0"

Presently/venv/Lib/site-packages/crispy_forms/base.py

+class KeepContext:
+    """
+    Context manager that receives a `django.template.Context` instance and a list of keys
+
+    Once the context manager is exited, it removes `keys` from the context, to avoid
+    side effects in later layout objects that may use the same context variables.
+
+    Layout objects should use `extra_context` to introduce context variables, never
+    touch context object themselves, that could introduce side effects.
+    """
+
+    def __init__(self, context, keys):
+        self.context = context
+        self.keys = keys
+
+    def __enter__(self):
+        pass
+
+    def __exit__(self, type, value, traceback):
+        for key in list(self.keys):
+            if key in self.context:
+                del self.context[key]

Presently/venv/Lib/site-packages/crispy_forms/exceptions.py

+class CrispyError(Exception):
+    pass
+
+
+class FormHelpersException(CrispyError):
+    """
+    This is raised when building a form via helpers throws an error.
+    We want to catch form helper errors as soon as possible because
+    debugging templatetags is never fun.
+    """
+
+    pass
+
+
+class DynamicError(CrispyError):
+    pass

Presently/venv/Lib/site-packages/crispy_forms/layout_slice.py

+from crispy_forms.bootstrap import Container
+from crispy_forms.exceptions import DynamicError
+from crispy_forms.layout import Fieldset, MultiField
+
+
+class LayoutSlice:
+    # List of layout objects that need args passed first before fields
+    args_first = (Fieldset, MultiField, Container)
+
+    def __init__(self, layout, key):
+        self.layout = layout
+        if isinstance(key, int):
+            self.slice = slice(key, key + 1, 1)
+        else:
+            self.slice = key
+
+    def wrapped_object(self, LayoutClass, fields, *args, **kwargs):
+        """
+        Returns a layout object of type `LayoutClass` with `args` and `kwargs` that
+        wraps `fields` inside.
+        """
+        if args:
+            if isinstance(fields, list):
+                fields = tuple(fields)
+            else:
+                fields = (fields,)
+
+            if LayoutClass in self.args_first:
+                arguments = args + fields
+            else:
+                arguments = fields + args
+
+            return LayoutClass(*arguments, **kwargs)
+        else:
+            if isinstance(fields, list):
+                return LayoutClass(*fields, **kwargs)
+            else:
+                return LayoutClass(fields, **kwargs)
+
+    def pre_map(self, function):
+        """
+        Iterates over layout objects pointed in `self.slice` executing `function` on them.
+        It passes `function` penultimate layout object and the position where to find last one
+        """
+        if isinstance(self.slice, slice):
+            for i in range(*self.slice.indices(len(self.layout.fields))):
+                function(self.layout, i)
+
+        elif isinstance(self.slice, list):
+            # A list of pointers  Ex: [[[0, 0], 'div'], [[0, 2, 3], 'field_name']]
+            for pointer in self.slice:
+                position = pointer[0]
+
+                # If it's pointing first level
+                if len(position) == 1:
+                    function(self.layout, position[-1])
+                else:
+                    layout_object = self.layout.fields[position[0]]
+                    for i in position[1:-1]:
+                        layout_object = layout_object.fields[i]
+
+                    try:
+                        function(layout_object, position[-1])
+                    except IndexError:
+                        # We could avoid this exception, recalculating pointers.
+                        # However this case is most of the time an undesired behavior
+                        raise DynamicError(
+                            "Trying to wrap a field within an already wrapped field, \
+                            recheck your filter or layout"
+                        )
+
+    def wrap(self, LayoutClass, *args, **kwargs):
+        """
+        Wraps every layout object pointed in `self.slice` under a `LayoutClass` instance with
+        `args` and `kwargs` passed.
+        """
+
+        def wrap_object(layout_object, j):
+            layout_object.fields[j] = self.wrapped_object(LayoutClass, layout_object.fields[j], *args, **kwargs)
+
+        self.pre_map(wrap_object)
+
+    def wrap_once(self, LayoutClass, *args, **kwargs):
+        """
+        Wraps every layout object pointed in `self.slice` under a `LayoutClass` instance with
+        `args` and `kwargs` passed, unless layout object's parent is already a subclass of
+        `LayoutClass`.
+        """
+
+        def wrap_object_once(layout_object, j):
+            if not isinstance(layout_object, LayoutClass):
+                layout_object.fields[j] = self.wrapped_object(LayoutClass, layout_object.fields[j], *args, **kwargs)
+
+        self.pre_map(wrap_object_once)
+
+    def wrap_together(self, LayoutClass, *args, **kwargs):
+        """
+        Wraps all layout objects pointed in `self.slice` together under a `LayoutClass`
+        instance with `args` and `kwargs` passed.
+        """
+        if isinstance(self.slice, slice):
+            # The start of the slice is replaced
+            start = self.slice.start if self.slice.start is not None else 0
+            self.layout.fields[start] = self.wrapped_object(
+                LayoutClass, self.layout.fields[self.slice], *args, **kwargs
+            )
+
+            # The rest of places of the slice are removed, as they are included in the previous
+            for i in reversed(range(*self.slice.indices(len(self.layout.fields)))):
+                if i != start:
+                    del self.layout.fields[i]
+
+        elif isinstance(self.slice, list):
+            raise DynamicError("wrap_together doesn't work with filter, only with [] operator")
+
+    def map(self, function):
+        """
+        Iterates over layout objects pointed in `self.slice` executing `function` on them
+        It passes `function` last layout object
+        """
+        if isinstance(self.slice, slice):
+            for i in range(*self.slice.indices(len(self.layout.fields))):
+                function(self.layout.fields[i])
+
+        elif isinstance(self.slice, list):
+            # A list of pointers  Ex: [[[0, 0], 'div'], [[0, 2, 3], 'field_name']]
+            for pointer in self.slice:
+                position = pointer[0]
+
+                layout_object = self.layout.fields[position[0]]
+                for i in position[1:]:
+                    previous_layout_object = layout_object
+                    layout_object = layout_object.fields[i]
+
+                # If update_attrs is applied to a string, we call to its wrapping layout object
+                if function.__name__ == "update_attrs" and isinstance(layout_object, str):
+                    function(previous_layout_object)
+                else:
+                    function(layout_object)
+
+    def update_attributes(self, **original_kwargs):
+        """
+        Updates attributes of every layout object pointed in `self.slice` using kwargs
+        """
+
+        def update_attrs(layout_object):
+            kwargs = original_kwargs.copy()
+            if hasattr(layout_object, "attrs"):
+                if "css_class" in kwargs:
+                    if "class" in layout_object.attrs:
+                        layout_object.attrs["class"] += " %s" % kwargs.pop("css_class")
+                    else:
+                        layout_object.attrs["class"] = kwargs.pop("css_class")
+                layout_object.attrs.update(kwargs)
+
+        self.map(update_attrs)

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/accordion-group.html

+<div class="accordion-group">
+    <div class="accordion-heading">
+        <a class="accordion-toggle" data-toggle="collapse" data-parent="#{{ div.data_parent }}" href="#{{ div.css_id }}">{{ div.name }}</a>
+    </div>
+    <div id="{{ div.css_id }}" class="accordion-body collapse{% if div.active %} in{% endif %}" >
+        <div class="accordion-inner">
+            {{ fields|safe }}
+        </div>
+    </div>
+</div>

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/accordion.html

+<div class="accordion" id="{{ accordion.css_id }}">
+    {{ content|safe }}
+</div>

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/betterform.html

+{% for fieldset in form.fieldsets %}
+    <fieldset class="fieldset-{{ forloop.counter }} {{ fieldset.classes }}">
+        {% if fieldset.legend %}
+            <legend>{{ fieldset.legend }}</legend>
+        {% endif %}
+
+        {% if fieldset.description %}
+            <p class="description">{{ fieldset.description }}</p>
+        {% endif %}
+
+        {% for field in fieldset %}
+            {% if field.is_hidden %}
+                {{ field }}
+            {% else %}
+                {% include "bootstrap/field.html" %}
+            {% endif %}
+        {% endfor %}
+    {% if not forloop.last or not fieldset_open %}
+        </fieldset>
+    {% endif %}
+{% endfor %}
+

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/display_form.html

+{% if form.form_html %}
+    {% if include_media %}{{ form.media }}{% endif %}
+    {% if form_show_errors %}
+        {% include "bootstrap/errors.html" %}
+    {% endif %}
+    {{ form.form_html }}
+{% else %}
+    {% include "bootstrap/uni_form.html" %}
+{% endif %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/errors.html

+{% if form.non_field_errors %}
+    <div class="alert alert-block alert-error">
+        {% if form_error_title %}<h4 class="alert-heading">{{ form_error_title }}</h4>{% endif %}
+        <ul>
+            {{ form.non_field_errors|unordered_list }}
+        </ul>
+    </div>
+{% endif %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/errors_formset.html

+{% if formset.non_form_errors %}
+    <div class="alert alert-block alert-error">
+        {% if formset_error_title %}<h4 class="alert-heading">{{ formset_error_title }}</h4>{% endif %}
+        <ul>
+            {{ formset.non_form_errors|unordered_list }}
+        </ul>
+    </div>
+{% endif %}
+

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/field.html

+{% load crispy_forms_field %}
+
+{% if field.is_hidden %}
+    {{ field }}
+{% else %}
+    <{% if tag %}{{ tag }}{% else %}div{% endif %} id="div_{{ field.auto_id }}" class="control-group{% if wrapper_class %} {{ wrapper_class }}{% endif %}{% if form_show_errors%}{% if field.errors %} error{% endif %}{% endif %}{% if field.css_classes %} {{ field.css_classes }}{% endif %}">
+        {% if field.label and not field|is_checkbox and form_show_labels %}
+            <label for="{{ field.id_for_label }}" class="control-label {% if field.field.required %}requiredField{% endif %}">
+                {{ field.label|safe }}{% if field.field.required %}<span class="asteriskField">*</span>{% endif %}
+            </label>
+        {% endif %}
+
+        {% if field|is_checkboxselectmultiple %}
+            {% include 'bootstrap/layout/checkboxselectmultiple.html' %}
+        {% endif %}
+
+        {% if field|is_radioselect %}
+            {% include 'bootstrap/layout/radioselect.html' %}
+        {% endif %}
+
+        {% if not field|is_checkboxselectmultiple and not field|is_radioselect %}
+            <div class="controls">
+                {% if field|is_checkbox and form_show_labels %}
+                    <label for="{{ field.id_for_label }}" class="checkbox {% if field.field.required %}requiredField{% endif %}">
+                        {% crispy_field field %}
+                        {{ field.label|safe }}{% if field.field.required %}<span class="asteriskField">*</span>{% endif %}
+                    </label>
+                    {% include 'bootstrap/layout/help_text_and_errors.html' %}
+                {% else %}
+                    {% crispy_field field %}
+                    {% include 'bootstrap/layout/help_text_and_errors.html' %}
+                {% endif %}
+            </div>
+        {% endif %}
+    </{% if tag %}{{ tag }}{% else %}div{% endif %}>
+{% endif %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/alert.html

+<div{% if alert.css_id %} id="{{ alert.css_id }}"{% endif %}{% if alert.css_class %} class="{{ alert.css_class }}"{% endif %}>
+    {% if dismiss %}<button type="button" class="close" data-dismiss="alert">&times;</button>{% endif %}
+    {{ content|safe }}
+</div>
\ No newline at end of file

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/baseinput.html

+<input type="{{ input.input_type }}"
+    name="{% if input.name|wordcount > 1 %}{{ input.name|slugify }}{% else %}{{ input.name }}{% endif %}"
+    value="{{ input.value }}"
+    {% if input.input_type != "hidden" %}
+        class="{{ input.field_classes }}"
+        id="{% if input.id %}{{ input.id }}{% else %}{{ input.input_type }}-id-{{ input.name|slugify }}{% endif %}"
+    {% endif %}
+    {{ input.flat_attrs|safe }}
+    />

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/button.html

+<button {{ button.flat_attrs|safe }}>{{ button.content|safe }}</button>

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/buttonholder.html

+<div {% if buttonholder.css_id %}id="{{ buttonholder.css_id }}"{% endif %} 
+    class="buttonHolder{% if buttonholder.css_class %} {{ buttonholder.css_class }}{% endif %}">
+       {{ fields_output|safe }}
+</div>

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/checkboxselectmultiple.html

+{% load crispy_forms_filters %}
+{% load l10n %}
+
+<div class="controls"{% if flat_attrs %} {{ flat_attrs|safe }}{% endif %}>
+    {% include 'bootstrap/layout/field_errors_block.html' %}
+
+    {% for choice in field.field.choices %}
+        <label class="checkbox{% if inline_class %} {{ inline_class }}{% endif %}" for="id_{{ field.html_name }}_{{ forloop.counter0 }}">
+            <input type="checkbox"{% if choice.0 in field.value or choice.0|stringformat:"s" in field.value or choice.0|stringformat:"s" == field.value|default_if_none:""|stringformat:"s" %} checked{% endif %} name="{{ field.html_name }}" id="id_{{ field.html_name }}_{{ forloop.counter0 }}" value="{{ choice.0|unlocalize }}" {% if field.field.disabled %}disabled="true"{% endif %} {{ field.field.widget.attrs|flatatt }}>{{ choice.1|unlocalize }}
+        </label>
+    {% endfor %}
+
+    {% include 'bootstrap/layout/help_text.html' %}
+</div>

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/checkboxselectmultiple_inline.html

+{% if field.is_hidden %}
+    {{ field }}
+{% else %}
+    <div id="div_{{ field.auto_id }}" class="control-group{% if form_show_errors and field.errors %} error{% endif %}{% if field.css_classes %} {{ field.css_classes }}{% endif %}">
+
+        {% if field.label %}
+            <label for="{{ field.auto_id }}"  class="control-label{% if field.field.required %} requiredField{% endif %}">
+                {{ field.label|safe }}{% if field.field.required %}<span class="asteriskField">*</span>{% endif %}
+            </label>
+        {% endif %}
+
+        {% include 'bootstrap/layout/checkboxselectmultiple.html' %}
+    </div>
+{% endif %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/column.html

+<div {% if div.css_id %}id="{{ div.css_id }}"{% endif %} class="{{ div.css_class|default:'' }}" {{ div.flat_attrs|safe }}>
+        {{ fields|safe }}
+</div>

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/div.html

+<div {% if div.css_id %}id="{{ div.css_id }}"{% endif %} 
+    {% if div.css_class %}class="{{ div.css_class }}"{% endif %} {{ div.flat_attrs|safe }}>
+        {{ fields|safe }}
+</div>

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/field_errors.html

+{% if form_show_errors and field.errors %}
+    {% for error in field.errors %}
+        <span id="error_{{ forloop.counter }}_{{ field.auto_id }}" class="help-inline"><strong>{{ error }}</strong></span>
+    {% endfor %}
+{% endif %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/field_errors_block.html

+{% if form_show_errors and field.errors %}
+    {% for error in field.errors %}
+        <p id="error_{{ forloop.counter }}_{{ field.auto_id }}" class="help-block"><strong>{{ error }}</strong></p>
+    {% endfor %}
+{% endif %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/field_with_buttons.html

+{% load crispy_forms_field %}
+
+<div{% if div.css_id %} id="{{ div.css_id }}"{% endif %} class="control-group{% if form_show_errors and field.errors %} error{% endif %}{% if field.css_classes %} {{ field.css_classes }}{% endif %}{% if div.css_class %} {{ div.css_class }}{% endif %}" {{ div.flat_attrs|safe }}>
+    {% if field.label and form_show_labels %}
+        <label for="{{ field.id_for_label }}" class="control-label{% if field.field.required %} requiredField{% endif %}">
+            {{ field.label|safe }}{% if field.field.required %}<span class="asteriskField">*</span>{% endif %}
+        </label>
+    {% endif %}
+
+    <div class="controls">
+        <div class="input-append">
+            {% crispy_field field %}
+            {{ buttons|safe }}
+        </div>
+        {% include 'bootstrap/layout/help_text_and_errors.html' %}
+    </div>
+</div>

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/fieldset.html

+<fieldset {% if fieldset.css_id %}id="{{ fieldset.css_id }}"{% endif %} 
+    {% if fieldset.css_class or form_style %}class="{{ fieldset.css_class }} {{ form_style }}"{% endif %}
+    {{ fieldset.flat_attrs|safe }}>
+    {% if legend %}<legend>{{ legend|safe }}</legend>{% endif %}
+    {{ fields|safe }} 
+</fieldset>

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/formactions.html

+<div{% if formactions.attrs %} {{ formactions.flat_attrs|safe }}{% endif %} class="form-actions">
+    {{ fields_output|safe }}
+</div>

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/help_text.html

+{% if field.help_text %}
+    {% if help_text_inline %}
+        <span id="hint_{{ field.auto_id }}" class="help-inline">{{ field.help_text|safe }}</span>
+    {% else %}
+        <p id="hint_{{ field.auto_id }}" class="help-block">{{ field.help_text|safe }}</p>
+    {% endif %}
+{% endif %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/help_text_and_errors.html

+{% if help_text_inline and not error_text_inline %}
+    {% include 'bootstrap/layout/help_text.html' %}
+{% endif %}
+
+{% if error_text_inline %}
+    {% include 'bootstrap/layout/field_errors.html' %}
+{% else %}
+    {% include 'bootstrap/layout/field_errors_block.html' %}
+{% endif %}
+
+{% if not help_text_inline %}
+    {% include 'bootstrap/layout/help_text.html' %}
+{% endif %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/multifield.html

+{% load crispy_forms_field %}
+
+{% if field.is_hidden %}
+    {{ field }}
+{% else %}
+
+    {% if field.label %}
+        <label for="{{ field.id_for_label }}"{% if labelclass %} class="{{ labelclass }}"{% endif %}>
+    {% endif %}
+
+    {% if field|is_checkbox %}
+        {% crispy_field field %}
+    {% endif %}
+
+    {% if field.label %}
+        {{ field.label }}
+    {% endif %}
+
+    {% if not field|is_checkbox %}
+        {% crispy_field field %}
+    {% endif %}
+
+    {% if field.label %}
+        </label>
+    {% endif %}
+
+{% endif %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/prepended_appended_text.html

+{% load crispy_forms_field %}
+
+{% if field.is_hidden %}
+    {{ field }}
+{% else %}
+    <div id="div_{{ field.auto_id }}" class="control-group{% if form_show_errors and field.errors %} error{% endif %}{% if field.css_classes %} {{ field.css_classes }}{% endif %}">
+
+        {% if field.label and form_show_labels %}
+            <label for="{{ field.id_for_label }}" class="control-label{% if field.field.required %} requiredField{% endif %}">
+                {{ field.label|safe }}{% if field.field.required %}<span class="asteriskField">*</span>{% endif %}
+            </label>
+        {% endif %}
+
+        <div class="controls">
+            <div class="{% if crispy_prepended_text %}input-prepend{% endif %} {% if crispy_appended_text %}input-append{% endif %}">
+                {% if crispy_prepended_text %}<span class="{% if not field|is_select %}add-on{% endif %}{% if active %} active{% endif %}">{{ crispy_prepended_text|safe }}</span>{% endif %}
+                {% crispy_field field %}
+                {% if crispy_appended_text %}<span class="{% if not field|is_select %}add-on{% endif %}{% if active %} active{% endif %}">{{ crispy_appended_text|safe }}</span>{% endif %}
+            </div>
+
+            {% include 'bootstrap/layout/help_text_and_errors.html' %}
+        </div>
+    </div>
+{% endif %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/radioselect.html

+{% load crispy_forms_filters %}
+{% load l10n %}
+
+<div class="controls"{% if flat_attrs %} {{ flat_attrs|safe }}{% endif %}>
+    {% include 'bootstrap/layout/field_errors_block.html' %}
+
+    {% for choice in field.field.choices %}
+        <label for="id_{{ field.html_name }}_{{ forloop.counter0 }}" class="radio{% if inline_class %} {{ inline_class }}{% endif %}">
+            <input type="radio"{% if choice.0|stringformat:"s" == field.value|default_if_none:""|stringformat:"s" %} checked{% endif %} name="{{ field.html_name }}" id="id_{{ field.html_name }}_{{ forloop.counter0 }}" value="{{ choice.0|unlocalize }}" {% if field.field.disabled %}disabled="true"{% endif %} {{ field.field.widget.attrs|flatatt }}>{{ choice.1|unlocalize }}
+        </label>
+    {% endfor %}
+
+    {% include 'bootstrap/layout/help_text.html' %}
+</div>

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/radioselect_inline.html

+{% if field.is_hidden %}
+    {{ field }}
+{% else %}
+    <div id="div_{{ field.auto_id }}" class="control-group{% if form_show_errors and field.errors %} error{% endif %}{% if field.css_classes %} {{ field.css_classes }}{% endif %}">
+
+        {% if field.label %}
+            <label for="{{ field.auto_id }}"  class="control-label{% if field.field.required %} requiredField{% endif %}">
+                {{ field.label|safe }}{% if field.field.required %}<span class="asteriskField">*</span>{% endif %}
+            </label>
+        {% endif %}
+
+        {% include 'bootstrap/layout/radioselect.html' %}
+    </div>
+{% endif %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/row.html

+<div {% if div.css_id %}id="{{ div.css_id }}"{% endif %} class="row {{ div.css_class|default:'' }}" {{ div.flat_attrs|safe }}>
+        {{ fields|safe }}
+</div>

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/tab-link.html

+<li class="tab-pane{% if 'active' in link.css_class %} active{% endif %}"><a href="#{{ link.css_id }}" data-toggle="tab">{{ link.name|capfirst }}{% if tab.errors %}!{% endif %}</a></li>

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/tab.html

+<ul{% if tabs.css_id %} id="{{ tabs.css_id }}"{% endif %} class="nav nav-tabs">
+    {{ links|safe }}
+</ul>
+<div class="tab-content">
+    {{ content|safe }}
+</div>

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/layout/uneditable_input.html

+<div id="div_{{ field.auto_id }}" class="control-group{% if form_show_errors and field.errors %} error{% endif %}{% if field.css_classes %} {{ field.css_classes }}{% endif %}">
+    <div class="control-label{% if field.field.required %} requiredField{% endif %}">{{ field.label|safe }}{% if field.field.required %}<span class="asteriskField">*</span>{% endif %}</div>
+    <div class="controls">
+        <span {{ flat_attrs|safe }}>{% if field.value %}{{ field.value }}{% endif %}</span>
+        {% include 'bootstrap/layout/help_text.html' %}
+    </div>
+</div>

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/table_inline_formset.html

+{% load crispy_forms_tags %}
+{% load crispy_forms_utils %}
+{% load crispy_forms_field %}
+
+{% specialspaceless %}
+{% if formset_tag %}
+<form {{ flat_attrs|safe }} method="{{ form_method }}" {% if formset.is_multipart %} enctype="multipart/form-data"{% endif %}>
+{% endif %}
+    {% if formset_method|lower == 'post' and not disable_csrf %}
+        {% csrf_token %}
+    {% endif %}
+
+    <div>
+        {{ formset.management_form|crispy }}
+    </div>
+
+    <table{% if form_id %} id="{{ form_id }}_table"{% endif%} class="table table-striped table-condensed">
+        <thead>
+            {% if formset.readonly and not formset.queryset.exists %}
+            {% else %}
+                <tr>
+                    {% for field in formset.forms.0 %}
+                        {% if field.label and not field.is_hidden %}
+                            <th for="{{ field.auto_id }}" class="control-label {% if field.field.required and not field|is_checkbox %}requiredField{% endif %}">
+                                {{ field.label|safe }}{% if field.field.required and not field|is_checkbox %}<span class="asteriskField">*</span>{% endif %}
+                            </th>
+                        {% endif %}
+                    {% endfor %}
+                </tr>
+            {% endif %}
+        </thead>
+
+        <tbody>
+            <tr class="hidden empty-form">
+                {% for field in formset.empty_form %}
+                    {% include 'bootstrap/field.html' with tag="td" form_show_labels=False %}
+                {% endfor %}
+            </tr>
+
+            {% for form in formset %}
+                {% if form_show_errors and not form.is_extra %}
+                    {% include "bootstrap/errors.html" %}
+                {% endif %}
+
+                <tr>
+                    {% for field in form %}
+                        {% include 'bootstrap/field.html' with tag="td" form_show_labels=False %}
+                    {% endfor %}
+                </tr>
+            {% endfor %}
+        </tbody>
+    </table>
+
+    {% if inputs %}
+        <div class="form-actions">
+            {% for input in inputs %}
+                {% include "bootstrap/layout/baseinput.html" %}
+            {% endfor %}
+        </div>
+    {% endif %}
+{% if formset_tag %}</form>{% endif %}
+{% endspecialspaceless %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/uni_form.html

+{% load crispy_forms_utils %}
+
+{% specialspaceless %}
+    {% if include_media %}{{ form.media }}{% endif %}
+    {% if form_show_errors %}
+        {% include "bootstrap/errors.html" %}
+    {% endif %}
+    {% for field in form %}
+        {% include field_template %}
+    {% endfor %}
+{% endspecialspaceless %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/uni_formset.html

+{% with formset.management_form as form %}
+    {% include 'bootstrap/uni_form.html' %}
+{% endwith %}
+{% for form in formset %}
+    <div class="multiField">
+        {% include 'bootstrap/uni_form.html' %}
+    </div>
+{% endfor %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/whole_uni_form.html

+{% load crispy_forms_utils %}
+
+{% specialspaceless %}
+{% if form_tag %}<form {{ flat_attrs|safe }} method="{{ form_method }}" {% if form.is_multipart %} enctype="multipart/form-data"{% endif %}>{% endif %}
+    {% if form_method|lower == 'post' and not disable_csrf %}
+        {% csrf_token %}
+    {% endif %}
+
+    {% include "bootstrap/display_form.html" %}
+
+    {% if inputs %}
+        <div class="form-actions">
+            {% for input in inputs %}
+                {% include "bootstrap/layout/baseinput.html" %}
+            {% endfor %}
+        </div>
+    {% endif %}
+{% if form_tag %}</form>{% endif %}
+{% endspecialspaceless %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap/whole_uni_formset.html

+{% load crispy_forms_tags %}
+{% load crispy_forms_utils %}
+
+{% specialspaceless %}
+{% if formset_tag %}
+<form {{ flat_attrs|safe }} method="{{ form_method }}" {% if formset.is_multipart %} enctype="multipart/form-data"{% endif %}>
+{% endif %}
+    {% if formset_method|lower == 'post' and not disable_csrf %}
+        {% csrf_token %}
+    {% endif %}
+
+    <div>
+        {{ formset.management_form|crispy }}
+    </div>
+
+    {% include "bootstrap/errors_formset.html" %}
+
+    {% for form in formset %}
+        {% include "bootstrap/display_form.html" %}
+    {% endfor %}
+
+    {% if inputs %}
+        <div class="form-actions">
+            {% for input in inputs %}
+                {% include "bootstrap/layout/baseinput.html" %}
+            {% endfor %}
+        </div>
+    {% endif %}
+{% if formset_tag %}</form>{% endif %}
+{% endspecialspaceless %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap3/accordion-group.html

+<div class="panel panel-default">
+    <div class="panel-heading">
+        <h4 class="panel-title">
+            <a class="accordion-toggle" data-toggle="collapse" data-parent="#{{ div.data_parent }}" href="#{{ div.css_id }}">{{ div.name }}</a>
+        </h4>
+    </div>
+    <div id="{{ div.css_id }}" class="panel-collapse collapse{% if div.active %} in{% endif %}" >
+        <div class="panel-body">
+            {{ fields|safe }}
+        </div>
+    </div>
+</div>

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap3/accordion.html

+<div class="panel-group" id="{{ accordion.css_id }}">
+    {{ content|safe }}
+</div>

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap3/betterform.html

+{% for fieldset in form.fieldsets %}
+    <fieldset class="fieldset-{{ forloop.counter }} {{ fieldset.classes }}">
+        {% if fieldset.legend %}
+            <legend>{{ fieldset.legend }}</legend>
+        {% endif %}
+
+        {% if fieldset.description %}
+            <p class="description">{{ fieldset.description }}</p>
+        {% endif %}
+
+        {% for field in fieldset %}
+            {% if field.is_hidden %}
+                {{ field }}
+            {% else %}
+                {% include "bootstrap3/field.html" %}
+            {% endif %}
+        {% endfor %}
+    {% if not forloop.last or not fieldset_open %}
+        </fieldset>
+    {% endif %}
+{% endfor %}
+

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap3/display_form.html

+{% if form.form_html %}
+    {% if include_media %}{{ form.media }}{% endif %}
+    {% if form_show_errors %}
+        {% include "bootstrap3/errors.html" %}
+    {% endif %}
+    {{ form.form_html }}
+{% else %}
+    {% include "bootstrap3/uni_form.html" %}
+{% endif %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap3/errors.html

+{% if form.non_field_errors %}
+    <div class="alert alert-block alert-danger">
+        {% if form_error_title %}<h4 class="alert-heading">{{ form_error_title }}</h4>{% endif %}
+        <ul>
+            {{ form.non_field_errors|unordered_list }}
+        </ul>
+    </div>
+{% endif %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap3/errors_formset.html

+{% if formset.non_form_errors %}
+    <div class="alert alert-block alert-danger">
+        {% if formset_error_title %}<h4 class="alert-heading">{{ formset_error_title }}</h4>{% endif %}
+        <ul>
+            {{ formset.non_form_errors|unordered_list }}
+        </ul>
+    </div>
+{% endif %}
+

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap3/field.html

+{% load crispy_forms_field %}
+
+{% if field.is_hidden %}
+    {{ field }}
+{% else %}
+    {% if field|is_checkbox %}
+        <div class="form-group">
+        {% if label_class %}
+            <div class="controls {% for offset in bootstrap_checkbox_offsets %}{{ offset }} {% endfor %}{{ field_class }}">
+        {% endif %}
+    {% endif %}
+    <{% if tag %}{{ tag }}{% else %}div{% endif %} id="div_{{ field.auto_id }}" {% if not field|is_checkbox %}class="form-group{% else %}class="checkbox{% endif %}{% if wrapper_class %} {{ wrapper_class }}{% endif %}{% if form_show_errors%}{% if field.errors %} has-error{% endif %}{% endif %}{% if field.css_classes %} {{ field.css_classes }}{% endif %}">
+        {% if field.label and not field|is_checkbox and form_show_labels %}
+            <label for="{{ field.id_for_label }}" class="control-label {{ label_class }}{% if field.field.required %} requiredField{% endif %}">
+                {{ field.label|safe }}{% if field.field.required %}<span class="asteriskField">*</span>{% endif %}
+            </label>
+        {% endif %}
+
+        {% if field|is_checkboxselectmultiple %}
+            {% include 'bootstrap3/layout/checkboxselectmultiple.html' %}
+        {% endif %}
+
+        {% if field|is_radioselect %}
+            {% include 'bootstrap3/layout/radioselect.html' %}
+        {% endif %}
+
+        {% if not field|is_checkboxselectmultiple and not field|is_radioselect %}
+            {% if field|is_checkbox and form_show_labels %}
+                <label for="{{ field.id_for_label }}" class="{% if field.field.required %} requiredField{% endif %}">
+                    {% crispy_field field %}
+                    {{ field.label|safe }}{% if field.field.required %}<span class="asteriskField">*</span>{% endif %}
+                </label>
+                {% include 'bootstrap3/layout/help_text_and_errors.html' %}
+            {% else %}
+                <div class="controls {{ field_class }}">
+                    {% if field|is_multivalue %}
+                        {% crispy_field field %}
+                    {% else %}    
+                        {% crispy_field field 'class' 'form-control' %}
+                    {% endif %}    
+                    {% include 'bootstrap3/layout/help_text_and_errors.html' %}
+                </div>
+            {% endif %}
+        {% endif %}
+    </{% if tag %}{{ tag }}{% else %}div{% endif %}>
+    {% if field|is_checkbox %}
+        {% if label_class %}
+            </div>
+        {% endif %}
+        </div>
+    {% endif %}
+{% endif %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap3/inputs.html

+{% if inputs %}
+    <div class="form-group">
+        {% if label_class %}
+            <div class="aab controls {{ label_class }}"></div>
+        {% endif %}
+
+        <div class="controls {{ field_class }}">
+            {% for input in inputs %}
+                {% include "bootstrap3/layout/baseinput.html" %}
+            {% endfor %}
+        </div>
+    </div>
+{% endif %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap3/layout/alert.html

+<div{% if alert.css_id %} id="{{ alert.css_id }}"{% endif %}{% if alert.css_class %} class="{{ alert.css_class }}"{% endif %}>
+    {% if dismiss %}<button type="button" class="close" data-dismiss="alert">&times;</button>{% endif %}
+    {{ content|safe }}
+</div>
\ No newline at end of file

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap3/layout/baseinput.html

+<input type="{{ input.input_type }}"
+    name="{% if input.name|wordcount > 1 %}{{ input.name|slugify }}{% else %}{{ input.name }}{% endif %}"
+    value="{{ input.value }}"
+    {% if input.input_type != "hidden" %}
+        class="{{ input.field_classes }}"
+        id="{% if input.id %}{{ input.id }}{% else %}{{ input.input_type }}-id-{{ input.name|slugify }}{% endif %}"
+    {% endif %}
+    {{ input.flat_attrs|safe }}
+    />

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap3/layout/button.html

+<button {{ button.flat_attrs|safe }}>{{ button.content|safe }}</button>

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap3/layout/buttonholder.html

+<div {% if buttonholder.css_id %}id="{{ buttonholder.css_id }}"{% endif %} 
+    class="buttonHolder{% if buttonholder.css_class %} {{ buttonholder.css_class }}{% endif %}">
+       {{ fields_output|safe }}
+</div>

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap3/layout/checkboxselectmultiple.html

+{% load crispy_forms_filters %}
+{% load l10n %}
+
+<div class="controls {{ field_class }}"{% if flat_attrs %} {{ flat_attrs|safe }}{% endif %}>
+    {% include 'bootstrap3/layout/field_errors_block.html' %}
+
+    {% for choice in field.field.choices %}
+
+      {% if not inline_class %}<div class="checkbox">{% endif %}
+        <label class="{% if inline_class %}checkbox-{{ inline_class }}{% endif %}" for="id_{{ field.html_name }}_{{ forloop.counter0 }}">
+            <input type="checkbox"{% if choice.0 in field.value or choice.0|stringformat:"s" in field.value or choice.0|stringformat:"s" == field.value|default_if_none:""|stringformat:"s" %} checked{% endif %} name="{{ field.html_name }}" id="id_{{ field.html_name }}_{{ forloop.counter0 }}" value="{{ choice.0|unlocalize }}" {% if field.field.disabled %}disabled="true"{% endif %} {{ field.field.widget.attrs|flatatt }}>{{ choice.1|unlocalize }}
+        </label>
+      {% if not inline_class %}</div>{% endif %}
+    {% endfor %}
+
+    {% include 'bootstrap3/layout/help_text.html' %}
+</div>

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap3/layout/checkboxselectmultiple_inline.html

+{% if field.is_hidden %}
+    {{ field }}
+{% else %}
+    <div id="div_{{ field.auto_id }}" class="form-group{% if form_show_errors and field.errors %} has-error{% endif %}{% if field.css_classes %} {{ field.css_classes }}{% endif %}">
+
+        {% if field.label %}
+            <label for="{{ field.auto_id }}"  class="control-label {{ label_class }}{% if field.field.required %} requiredField{% endif %}">
+                {{ field.label|safe }}{% if field.field.required %}<span class="asteriskField">*</span>{% endif %}
+            </label>
+        {% endif %}
+
+        {% include 'bootstrap3/layout/checkboxselectmultiple.html' %}
+    </div>
+{% endif %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap3/layout/column.html

+<div {% if div.css_id %}id="{{ div.css_id }}"{% endif %} class="formColumn {{ div.css_class|default:'' }}" {{ div.flat_attrs|safe }}>
+        {{ fields|safe }}
+</div>

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap3/layout/div.html

+<div {% if div.css_id %}id="{{ div.css_id }}"{% endif %} 
+    {% if div.css_class %}class="{{ div.css_class }}"{% endif %} {{ div.flat_attrs|safe }}>
+        {{ fields|safe }}
+</div>

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap3/layout/field_errors.html

+{% if form_show_errors and field.errors %}
+    {% for error in field.errors %}
+        <span id="error_{{ forloop.counter }}_{{ field.auto_id }}" class="help-block"><strong>{{ error }}</strong></span>
+    {% endfor %}
+{% endif %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap3/layout/field_errors_block.html

+{% if form_show_errors and field.errors %}
+    {% for error in field.errors %}
+        <p id="error_{{ forloop.counter }}_{{ field.auto_id }}" class="help-block"><strong>{{ error }}</strong></p>
+    {% endfor %}
+{% endif %}

Presently/venv/Lib/site-packages/crispy_forms/templates/bootstrap3/layout/field_with_buttons.html

+{% load crispy_forms_field %}
+
+<div{% if div.css_id %} id="{{ div.css_id }}"{% endif %} class="form-group{% if form_show_errors and field.errors %} has-error{% endif %}{% if field.css_classes %} {{ field.css_classes }}{% endif %}{% if div.css_class %} {{ div.css_class }}{% endif %}" {{ div.flat_attrs|safe }}>
+    {% if field.label and form_show_labels %}
+        <label for="{{ field.id_for_label }}" class="control-label {{ label_class }}{% if field.field.required %} requiredField{% endif %}">
+            {{ field.label|safe }}{% if field.field.required %}<span class="asteriskField">*</span>{% endif %}
+        </label>
+    {% endif %}
+
+    <div class="controls {{ field_class }}">
+        <div class="input-group">
+            {% crispy_field field %}
+            <span class="input-group-btn{% if active %} active{% endif %}{% if input_size %} {{ input_size }}{% endif %}">{{ buttons|safe }}</span>
+        </div>
+        {% include 'bootstrap3/layout/help_text_and_errors.html' %}
+    </div>
+</div>