Ajoutez des fichiers projet.

venv/Lib/site-packages/django/contrib/staticfiles/handlers.py

@@ -0,0 +1,96 @@
+from urllib.parse import urlparse
+from urllib.request import url2pathname
+
+from asgiref.sync import sync_to_async
+
+from django.conf import settings
+from django.contrib.staticfiles import utils
+from django.contrib.staticfiles.views import serve
+from django.core.handlers.asgi import ASGIHandler
+from django.core.handlers.exception import response_for_exception
+from django.core.handlers.wsgi import WSGIHandler, get_path_info
+from django.http import Http404
+
+
+class StaticFilesHandlerMixin:
+    """
+    Common methods used by WSGI and ASGI handlers.
+    """
+    # May be used to differentiate between handler types (e.g. in a
+    # request_finished signal)
+    handles_files = True
+
+    def load_middleware(self):
+        # Middleware are already loaded for self.application; no need to reload
+        # them for self.
+        pass
+
+    def get_base_url(self):
+        utils.check_settings()
+        return settings.STATIC_URL
+
+    def _should_handle(self, path):
+        """
+        Check if the path should be handled. Ignore the path if:
+        * the host is provided as part of the base_url
+        * the request's path isn't under the media path (or equal)
+        """
+        return path.startswith(self.base_url[2]) and not self.base_url[1]
+
+    def file_path(self, url):
+        """
+        Return the relative path to the media file on disk for the given URL.
+        """
+        relative_url = url[len(self.base_url[2]):]
+        return url2pathname(relative_url)
+
+    def serve(self, request):
+        """Serve the request path."""
+        return serve(request, self.file_path(request.path), insecure=True)
+
+    def get_response(self, request):
+        try:
+            return self.serve(request)
+        except Http404 as e:
+            return response_for_exception(request, e)
+
+    async def get_response_async(self, request):
+        try:
+            return await sync_to_async(self.serve, thread_sensitive=False)(request)
+        except Http404 as e:
+            return await sync_to_async(response_for_exception, thread_sensitive=False)(request, e)
+
+
+class StaticFilesHandler(StaticFilesHandlerMixin, WSGIHandler):
+    """
+    WSGI middleware that intercepts calls to the static files directory, as
+    defined by the STATIC_URL setting, and serves those files.
+    """
+    def __init__(self, application):
+        self.application = application
+        self.base_url = urlparse(self.get_base_url())
+        super().__init__()
+
+    def __call__(self, environ, start_response):
+        if not self._should_handle(get_path_info(environ)):
+            return self.application(environ, start_response)
+        return super().__call__(environ, start_response)
+
+
+class ASGIStaticFilesHandler(StaticFilesHandlerMixin, ASGIHandler):
+    """
+    ASGI application which wraps another and intercepts requests for static
+    files, passing them off to Django's static file serving.
+    """
+    def __init__(self, application):
+        self.application = application
+        self.base_url = urlparse(self.get_base_url())
+
+    async def __call__(self, scope, receive, send):
+        # Only even look at HTTP requests
+        if scope['type'] == 'http' and self._should_handle(scope['path']):
+            # Serve static content
+            # (the one thing super() doesn't do is __call__, apparently)
+            return await super().__call__(scope, receive, send)
+        # Hand off to the main app
+        return await self.application(scope, receive, send)