to keep track on which directories the finder has searched the static files a base file finder to be used for custom staticfiles finder classes given a relative file path find an absolute file path if the all parameter is false default return only the first found file path if true return a list of all found files paths given an optional list of paths to ignore return a two item iterable consisting of the relative path and storage instance a static files finder that uses the staticfilesdirs setting to locate files list of locations with static files maps dir paths to an appropriate storage instance look for files in the extra locations as defined in staticfilesdirs find a requested static file in a location and return the found absolute path or none if no match list all files in all locations skip nonexistent directories a static files finder that looks in the directory of each app as specified in the sourcedir attribute the list of apps that are handled mapping of app names to storage instances list all files in all app storages look for files in the app directories find a requested static file in an app s static locations only try to find a file if the source dir actually exists a base static files finder to be used to extended with an own storage class make sure we have a storage instance here look for files in the default file storage if it s local list all files of the storage a static files finder that uses the default storage backend find a static file with the given path using all enabled finders if all is false default return the first matching absolute path or none if no match otherwise return a list no match import the staticfiles finder class described by importpath where importpath is the full python path to the class to keep track on which directories the finder has searched the static files a base file finder to be used for custom staticfiles finder classes given a relative file path find an absolute file path if the all parameter is false default return only the first found file path if true return a list of all found files paths given an optional list of paths to ignore return a two item iterable consisting of the relative path and storage instance a static files finder that uses the staticfiles_dirs setting to locate files list of locations with static files maps dir paths to an appropriate storage instance look for files in the extra locations as defined in staticfiles_dirs find a requested static file in a location and return the found absolute path or none if no match list all files in all locations skip nonexistent directories a static files finder that looks in the directory of each app as specified in the source_dir attribute the list of apps that are handled mapping of app names to storage instances list all files in all app storages check if storage location exists look for files in the app directories find a requested static file in an app s static locations only try to find a file if the source dir actually exists a base static files finder to be used to extended with an own storage class make sure we have a storage instance here look for files in the default file storage if it s local list all files of the storage a static files finder that uses the default storage backend find a static file with the given path using all enabled finders if all is false default return the first matching absolute path or none if no match otherwise return a list no match import the staticfiles finder class described by import_path where import_path is the full python path to the class
import functools
import os

from django.apps import apps
from django.conf import settings
from django.contrib.staticfiles import utils
from django.core.checks import Error, Warning
from django.core.exceptions import ImproperlyConfigured
from django.core.files.storage import FileSystemStorage, Storage, default_storage
from django.utils._os import safe_join
from django.utils.functional import LazyObject, empty
from django.utils.module_loading import import_string


searched_locations = []


class BaseFinder:
    

    def check(self, **kwargs):
        raise NotImplementedError(
            "subclasses may provide a check() method to verify the finder is "
            "configured correctly."
        )

    def find(self, path, all=False):
        
        raise NotImplementedError(
            "subclasses of BaseFinder must provide a find() method"
        )

    def list(self, ignore_patterns):
        
        raise NotImplementedError(
            "subclasses of BaseFinder must provide a list() method"
        )


class FileSystemFinder(BaseFinder):
    

    def __init__(self, app_names=None, *args, **kwargs):
        
        self.locations = []
        
        self.storages = {}
        for root in settings.STATICFILES_DIRS:
            if isinstance(root, (list, tuple)):
                prefix, root = root
            else:
                prefix = ""
            if (prefix, root) not in self.locations:
                self.locations.append((prefix, root))
        for prefix, root in self.locations:
            filesystem_storage = FileSystemStorage(location=root)
            filesystem_storage.prefix = prefix
            self.storages[root] = filesystem_storage
        super().__init__(*args, **kwargs)

    def check(self, **kwargs):
        errors = []
        if not isinstance(settings.STATICFILES_DIRS, (list, tuple)):
            errors.append(
                Error(
                    "The STATICFILES_DIRS setting is not a tuple or list.",
                    hint="Perhaps you forgot a trailing comma?",
                    id="staticfiles.E001",
                )
            )
            return errors
        for root in settings.STATICFILES_DIRS:
            if isinstance(root, (list, tuple)):
                prefix, root = root
                if prefix.endswith("/"):
                    errors.append(
                        Error(
                            "The prefix %r in the STATICFILES_DIRS setting must "
                            "not end with a slash." % prefix,
                            id="staticfiles.E003",
                        )
                    )
            if settings.STATIC_ROOT and os.path.abspath(
                settings.STATIC_ROOT
            ) == os.path.abspath(root):
                errors.append(
                    Error(
                        "The STATICFILES_DIRS setting should not contain the "
                        "STATIC_ROOT setting.",
                        id="staticfiles.E002",
                    )
                )
            if not os.path.isdir(root):
                errors.append(
                    Warning(
                        f"The directory '{root}' in the STATICFILES_DIRS setting "
                        f"does not exist.",
                        id="staticfiles.W004",
                    )
                )
        return errors

    def find(self, path, all=False):
        
        matches = []
        for prefix, root in self.locations:
            if root not in searched_locations:
                searched_locations.append(root)
            matched_path = self.find_location(root, path, prefix)
            if matched_path:
                if not all:
                    return matched_path
                matches.append(matched_path)
        return matches

    def find_location(self, root, path, prefix=None):
        
        if prefix:
            prefix = "%s%s" % (prefix, os.sep)
            if not path.startswith(prefix):
                return None
            path = path.removeprefix(prefix)
        path = safe_join(root, path)
        if os.path.exists(path):
            return path

    def list(self, ignore_patterns):
        
        for prefix, root in self.locations:
            
            if os.path.isdir(root):
                storage = self.storages[root]
                for path in utils.get_files(storage, ignore_patterns):
                    yield path, storage


class AppDirectoriesFinder(BaseFinder):
    

    storage_class = FileSystemStorage
    source_dir = "static"

    def __init__(self, app_names=None, *args, **kwargs):
        
        self.apps = []
        
        self.storages = {}
        app_configs = apps.get_app_configs()
        if app_names:
            app_names = set(app_names)
            app_configs = [ac for ac in app_configs if ac.name in app_names]
        for app_config in app_configs:
            app_storage = self.storage_class(
                os.path.join(app_config.path, self.source_dir)
            )
            if os.path.isdir(app_storage.location):
                self.storages[app_config.name] = app_storage
                if app_config.name not in self.apps:
                    self.apps.append(app_config.name)
        super().__init__(*args, **kwargs)

    def list(self, ignore_patterns):
        
        for storage in self.storages.values():
            if storage.exists(""):  
                for path in utils.get_files(storage, ignore_patterns):
                    yield path, storage

    def find(self, path, all=False):
        
        matches = []
        for app in self.apps:
            app_location = self.storages[app].location
            if app_location not in searched_locations:
                searched_locations.append(app_location)
            match = self.find_in_app(app, path)
            if match:
                if not all:
                    return match
                matches.append(match)
        return matches

    def find_in_app(self, app, path):
        
        storage = self.storages.get(app)
        
        if storage and storage.exists(path):
            matched_path = storage.path(path)
            if matched_path:
                return matched_path


class BaseStorageFinder(BaseFinder):
    

    storage = None

    def __init__(self, storage=None, *args, **kwargs):
        if storage is not None:
            self.storage = storage
        if self.storage is None:
            raise ImproperlyConfigured(
                "The staticfiles storage finder %r "
                "doesn't have a storage class "
                "assigned." % self.__class__
            )
        
        if not isinstance(self.storage, (Storage, LazyObject)):
            self.storage = self.storage()
        super().__init__(*args, **kwargs)

    def find(self, path, all=False):
        
        try:
            self.storage.path("")
        except NotImplementedError:
            pass
        else:
            if self.storage.location not in searched_locations:
                searched_locations.append(self.storage.location)
            if self.storage.exists(path):
                match = self.storage.path(path)
                if all:
                    match = [match]
                return match
        return []

    def list(self, ignore_patterns):
        
        for path in utils.get_files(self.storage, ignore_patterns):
            yield path, self.storage


class DefaultStorageFinder(BaseStorageFinder):
    

    storage = default_storage

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        base_location = getattr(self.storage, "base_location", empty)
        if not base_location:
            raise ImproperlyConfigured(
                "The storage backend of the "
                "staticfiles finder %r doesn't have "
                "a valid location." % self.__class__
            )


def find(path, all=False):
    
    searched_locations[:] = []
    matches = []
    for finder in get_finders():
        result = finder.find(path, all=all)
        if not all and result:
            return result
        if not isinstance(result, (list, tuple)):
            result = [result]
        matches.extend(result)
    if matches:
        return matches
    
    return [] if all else None


def get_finders():
    for finder_path in settings.STATICFILES_FINDERS:
        yield get_finder(finder_path)


@functools.cache
def get_finder(import_path):
    
    Finder = import_string(import_path)
    if not issubclass(Finder, BaseFinder):
        raise ImproperlyConfigured(
            'Finder "%s" is not a subclass of "%s"' % (Finder, BaseFinder)
        )
    return Finder()