Add files using upload-large-folder tool

testbed/django__django/django/contrib/sites/admin.py

@@ -0,0 +1,8 @@
+from django.contrib import admin
+from django.contrib.sites.models import Site
+
+
+@admin.register(Site)
+class SiteAdmin(admin.ModelAdmin):
+    list_display = ("domain", "name")
+    search_fields = ("domain", "name")

testbed/django__django/django/contrib/sites/apps.py

@@ -0,0 +1,17 @@
+from django.apps import AppConfig
+from django.contrib.sites.checks import check_site_id
+from django.core import checks
+from django.db.models.signals import post_migrate
+from django.utils.translation import gettext_lazy as _
+
+from .management import create_default_site
+
+
+class SitesConfig(AppConfig):
+    default_auto_field = "django.db.models.AutoField"
+    name = "django.contrib.sites"
+    verbose_name = _("Sites")
+
+    def ready(self):
+        post_migrate.connect(create_default_site, sender=self)
+        checks.register(check_site_id, checks.Tags.sites)

testbed/django__django/django/contrib/sites/checks.py

@@ -0,0 +1,14 @@
+from types import NoneType
+
+from django.conf import settings
+from django.core.checks import Error
+
+
+def check_site_id(app_configs, **kwargs):
+    if hasattr(settings, "SITE_ID") and not isinstance(
+        settings.SITE_ID, (NoneType, int)
+    ):
+        return [
+            Error("The SITE_ID setting must be an integer", id="sites.E101"),
+        ]
+    return []

testbed/django__django/django/contrib/sites/locale/ckb/LC_MESSAGES/django.po

@@ -0,0 +1,36 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# kosar tofiq <kosar.belana@gmail.com>, 2020
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2015-01-17 11:07+0100\n"
+"PO-Revision-Date: 2023-04-24 18:05+0000\n"
+"Last-Translator: kosar tofiq <kosar.belana@gmail.com>, 2020\n"
+"Language-Team: Central Kurdish (http://www.transifex.com/django/django/"
+"language/ckb/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: ckb\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "Sites"
+msgstr "ماڵپەڕەکان"
+
+msgid "The domain name cannot contain any spaces or tabs."
+msgstr "ناوی دۆمەین نابێت بۆشایی یان تابی تێدابێت."
+
+msgid "domain name"
+msgstr "ناوی دۆمەین"
+
+msgid "display name"
+msgstr "ناوی پیشاندان"
+
+msgid "site"
+msgstr "ماڵپەڕ"
+
+msgid "sites"
+msgstr "ماڵپەڕەکان"

testbed/django__django/django/contrib/sites/locale/tr/LC_MESSAGES/django.po

@@ -0,0 +1,39 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Ahmet Emre Aladağ <emre.aladag@isik.edu.tr>, 2014
+# BouRock, 2014
+# Caner Başaran <basaran.caner@protonmail.com>, 2013
+# Jannis Leidel <jannis@leidel.info>, 2011
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2015-01-17 11:07+0100\n"
+"PO-Revision-Date: 2017-09-23 18:54+0000\n"
+"Last-Translator: Jannis Leidel <jannis@leidel.info>\n"
+"Language-Team: Turkish (http://www.transifex.com/django/django/language/"
+"tr/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: tr\n"
+"Plural-Forms: nplurals=2; plural=(n > 1);\n"
+
+msgid "Sites"
+msgstr "Siteler"
+
+msgid "The domain name cannot contain any spaces or tabs."
+msgstr "Etki alanı adı, herhangi bir boşluk ya da sekme içeremez."
+
+msgid "domain name"
+msgstr "etki alanı adı"
+
+msgid "display name"
+msgstr "görünen isim"
+
+msgid "site"
+msgstr "site"
+
+msgid "sites"
+msgstr "siteler"

testbed/django__django/django/contrib/sites/locale/udm/LC_MESSAGES/django.po

@@ -0,0 +1,35 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2015-01-17 11:07+0100\n"
+"PO-Revision-Date: 2014-10-05 20:13+0000\n"
+"Last-Translator: Jannis Leidel <jannis@leidel.info>\n"
+"Language-Team: Udmurt (http://www.transifex.com/projects/p/django/language/"
+"udm/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: udm\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+
+msgid "Sites"
+msgstr ""
+
+msgid "The domain name cannot contain any spaces or tabs."
+msgstr ""
+
+msgid "domain name"
+msgstr ""
+
+msgid "display name"
+msgstr ""
+
+msgid "site"
+msgstr ""
+
+msgid "sites"
+msgstr ""

testbed/django__django/django/contrib/sites/locale/ur/LC_MESSAGES/django.po

@@ -0,0 +1,35 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Mansoorulhaq Mansoor <mnsrknp@gmail.com>, 2011
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2015-01-17 11:07+0100\n"
+"PO-Revision-Date: 2017-09-19 16:40+0000\n"
+"Last-Translator: Jannis Leidel <jannis@leidel.info>\n"
+"Language-Team: Urdu (http://www.transifex.com/django/django/language/ur/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: ur\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "Sites"
+msgstr ""
+
+msgid "The domain name cannot contain any spaces or tabs."
+msgstr ""
+
+msgid "domain name"
+msgstr "ڈومین کا نام"
+
+msgid "display name"
+msgstr "ظاھر ھونے والا نام"
+
+msgid "site"
+msgstr "سائٹ"
+
+msgid "sites"
+msgstr "سائٹس"

testbed/django__django/django/contrib/sites/locale/uz/LC_MESSAGES/django.po

@@ -0,0 +1,35 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Nuruddin Iminokhunov <nuruddin.iminohunov@gmail.com>, 2016
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2015-01-17 11:07+0100\n"
+"PO-Revision-Date: 2017-09-23 01:18+0000\n"
+"Last-Translator: Nuruddin Iminokhunov <nuruddin.iminohunov@gmail.com>\n"
+"Language-Team: Uzbek (http://www.transifex.com/django/django/language/uz/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: uz\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+
+msgid "Sites"
+msgstr "Saytlar"
+
+msgid "The domain name cannot contain any spaces or tabs."
+msgstr "Domen ismi tab`lar va bo'shliqlarsiz bo'lishi kerak"
+
+msgid "domain name"
+msgstr "domen nomi"
+
+msgid "display name"
+msgstr "ko'rsatiladigan ismi"
+
+msgid "site"
+msgstr "sayt"
+
+msgid "sites"
+msgstr "saytlar"

testbed/django__django/django/contrib/sites/locale/vi/LC_MESSAGES/django.po

@@ -0,0 +1,38 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Jannis Leidel <jannis@leidel.info>, 2011
+# Thanh Le Viet <lethanhx2k@gmail.com>, 2013
+# Tran <hongdiepkien@gmail.com>, 2011
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2015-01-17 11:07+0100\n"
+"PO-Revision-Date: 2017-09-23 18:54+0000\n"
+"Last-Translator: Tran Van <vantxm@yahoo.co.uk>\n"
+"Language-Team: Vietnamese (http://www.transifex.com/django/django/language/"
+"vi/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: vi\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+
+msgid "Sites"
+msgstr ""
+
+msgid "The domain name cannot contain any spaces or tabs."
+msgstr "Tên miền không gồm kí tự trống hoặc tab"
+
+msgid "domain name"
+msgstr "Tên miền"
+
+msgid "display name"
+msgstr "Tên hiển thị"
+
+msgid "site"
+msgstr "trang web"
+
+msgid "sites"
+msgstr "các trang web"

testbed/django__django/django/contrib/sites/locale/zh_Hans/LC_MESSAGES/django.po

@@ -0,0 +1,37 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Jannis Leidel <jannis@leidel.info>, 2011
+# Ronald White <ouyanghongyu@gmail.com>, 2014
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2015-01-17 11:07+0100\n"
+"PO-Revision-Date: 2017-09-19 16:40+0000\n"
+"Last-Translator: Jannis Leidel <jannis@leidel.info>\n"
+"Language-Team: Chinese (China) (http://www.transifex.com/django/django/"
+"language/zh_CN/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: zh_CN\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+
+msgid "Sites"
+msgstr "站点"
+
+msgid "The domain name cannot contain any spaces or tabs."
+msgstr "域名不能包含任何空格或制表符。"
+
+msgid "domain name"
+msgstr "域名"
+
+msgid "display name"
+msgstr "显示名称"
+
+msgid "site"
+msgstr "站点"
+
+msgid "sites"
+msgstr "站点"

testbed/django__django/django/contrib/sites/locale/zh_Hant/LC_MESSAGES/django.po

@@ -0,0 +1,39 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Chen Chun-Chia <ccc.larc@gmail.com>, 2015
+# Jannis Leidel <jannis@leidel.info>, 2011
+# mail6543210 <mail6543210@yahoo.com.tw>, 2013
+# Tzu-ping Chung <uranusjr@gmail.com>, 2016
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2015-01-17 11:07+0100\n"
+"PO-Revision-Date: 2017-09-19 16:40+0000\n"
+"Last-Translator: Tzu-ping Chung <uranusjr@gmail.com>\n"
+"Language-Team: Chinese (Taiwan) (http://www.transifex.com/django/django/"
+"language/zh_TW/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: zh_TW\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+
+msgid "Sites"
+msgstr "網站"
+
+msgid "The domain name cannot contain any spaces or tabs."
+msgstr "網域名稱不能包含空格或定位字元。"
+
+msgid "domain name"
+msgstr "網域名稱"
+
+msgid "display name"
+msgstr "顯示名稱"
+
+msgid "site"
+msgstr "網站"
+
+msgid "sites"
+msgstr "網站"

testbed/django__django/django/contrib/sites/management.py

@@ -0,0 +1,47 @@
+"""
+Creates the default Site object.
+"""
+
+from django.apps import apps as global_apps
+from django.conf import settings
+from django.core.management.color import no_style
+from django.db import DEFAULT_DB_ALIAS, connections, router
+
+
+def create_default_site(
+    app_config,
+    verbosity=2,
+    interactive=True,
+    using=DEFAULT_DB_ALIAS,
+    apps=global_apps,
+    **kwargs,
+):
+    try:
+        Site = apps.get_model("sites", "Site")
+    except LookupError:
+        return
+
+    if not router.allow_migrate_model(using, Site):
+        return
+
+    if not Site.objects.using(using).exists():
+        # The default settings set SITE_ID = 1, and some tests in Django's test
+        # suite rely on this value. However, if database sequences are reused
+        # (e.g. in the test suite after flush/syncdb), it isn't guaranteed that
+        # the next id will be 1, so we coerce it. See #15573 and #16353. This
+        # can also crop up outside of tests - see #15346.
+        if verbosity >= 2:
+            print("Creating example.com Site object")
+        Site(
+            pk=getattr(settings, "SITE_ID", 1), domain="example.com", name="example.com"
+        ).save(using=using)
+
+        # We set an explicit pk instead of relying on auto-incrementation,
+        # so we need to reset the database sequence. See #17415.
+        sequence_sql = connections[using].ops.sequence_reset_sql(no_style(), [Site])
+        if sequence_sql:
+            if verbosity >= 2:
+                print("Resetting sequence")
+            with connections[using].cursor() as cursor:
+                for command in sequence_sql:
+                    cursor.execute(command)

testbed/django__django/django/contrib/sites/managers.py

@@ -0,0 +1,65 @@
+from django.conf import settings
+from django.core import checks
+from django.core.exceptions import FieldDoesNotExist
+from django.db import models
+
+
+class CurrentSiteManager(models.Manager):
+    "Use this to limit objects to those associated with the current site."
+
+    use_in_migrations = True
+
+    def __init__(self, field_name=None):
+        super().__init__()
+        self.__field_name = field_name
+
+    def check(self, **kwargs):
+        errors = super().check(**kwargs)
+        errors.extend(self._check_field_name())
+        return errors
+
+    def _check_field_name(self):
+        field_name = self._get_field_name()
+        try:
+            field = self.model._meta.get_field(field_name)
+        except FieldDoesNotExist:
+            return [
+                checks.Error(
+                    "CurrentSiteManager could not find a field named '%s'."
+                    % field_name,
+                    obj=self,
+                    id="sites.E001",
+                )
+            ]
+
+        if not field.many_to_many and not isinstance(field, (models.ForeignKey)):
+            return [
+                checks.Error(
+                    "CurrentSiteManager cannot use '%s.%s' as it is not a foreign key "
+                    "or a many-to-many field."
+                    % (self.model._meta.object_name, field_name),
+                    obj=self,
+                    id="sites.E002",
+                )
+            ]
+
+        return []
+
+    def _get_field_name(self):
+        """Return self.__field_name or 'site' or 'sites'."""
+
+        if not self.__field_name:
+            try:
+                self.model._meta.get_field("site")
+            except FieldDoesNotExist:
+                self.__field_name = "sites"
+            else:
+                self.__field_name = "site"
+        return self.__field_name
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .filter(**{self._get_field_name() + "__id": settings.SITE_ID})
+        )

testbed/django__django/django/contrib/sites/middleware.py

@@ -0,0 +1,12 @@
+from django.utils.deprecation import MiddlewareMixin
+
+from .shortcuts import get_current_site
+
+
+class CurrentSiteMiddleware(MiddlewareMixin):
+    """
+    Middleware that sets `site` attribute to request object.
+    """
+
+    def process_request(self, request):
+        request.site = get_current_site(request)

testbed/django__django/django/contrib/sites/migrations/0001_initial.py

@@ -0,0 +1,43 @@
+import django.contrib.sites.models
+from django.contrib.sites.models import _simple_domain_name_validator
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name="Site",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        verbose_name="ID",
+                        serialize=False,
+                        auto_created=True,
+                        primary_key=True,
+                    ),
+                ),
+                (
+                    "domain",
+                    models.CharField(
+                        max_length=100,
+                        verbose_name="domain name",
+                        validators=[_simple_domain_name_validator],
+                    ),
+                ),
+                ("name", models.CharField(max_length=50, verbose_name="display name")),
+            ],
+            options={
+                "ordering": ["domain"],
+                "db_table": "django_site",
+                "verbose_name": "site",
+                "verbose_name_plural": "sites",
+            },
+            bases=(models.Model,),
+            managers=[
+                ("objects", django.contrib.sites.models.SiteManager()),
+            ],
+        ),
+    ]

testbed/django__django/django/contrib/sites/migrations/0002_alter_domain_unique.py

@@ -0,0 +1,21 @@
+import django.contrib.sites.models
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("sites", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="site",
+            name="domain",
+            field=models.CharField(
+                max_length=100,
+                unique=True,
+                validators=[django.contrib.sites.models._simple_domain_name_validator],
+                verbose_name="domain name",
+            ),
+        ),
+    ]

testbed/django__django/django/contrib/sites/models.py

@@ -0,0 +1,120 @@
+import string
+
+from django.core.exceptions import ImproperlyConfigured, ValidationError
+from django.db import models
+from django.db.models.signals import pre_delete, pre_save
+from django.http.request import split_domain_port
+from django.utils.translation import gettext_lazy as _
+
+SITE_CACHE = {}
+
+
+def _simple_domain_name_validator(value):
+    """
+    Validate that the given value contains no whitespaces to prevent common
+    typos.
+    """
+    checks = ((s in value) for s in string.whitespace)
+    if any(checks):
+        raise ValidationError(
+            _("The domain name cannot contain any spaces or tabs."),
+            code="invalid",
+        )
+
+
+class SiteManager(models.Manager):
+    use_in_migrations = True
+
+    def _get_site_by_id(self, site_id):
+        if site_id not in SITE_CACHE:
+            site = self.get(pk=site_id)
+            SITE_CACHE[site_id] = site
+        return SITE_CACHE[site_id]
+
+    def _get_site_by_request(self, request):
+        host = request.get_host()
+        try:
+            # First attempt to look up the site by host with or without port.
+            if host not in SITE_CACHE:
+                SITE_CACHE[host] = self.get(domain__iexact=host)
+            return SITE_CACHE[host]
+        except Site.DoesNotExist:
+            # Fallback to looking up site after stripping port from the host.
+            domain, port = split_domain_port(host)
+            if domain not in SITE_CACHE:
+                SITE_CACHE[domain] = self.get(domain__iexact=domain)
+            return SITE_CACHE[domain]
+
+    def get_current(self, request=None):
+        """
+        Return the current Site based on the SITE_ID in the project's settings.
+        If SITE_ID isn't defined, return the site with domain matching
+        request.get_host(). The ``Site`` object is cached the first time it's
+        retrieved from the database.
+        """
+        from django.conf import settings
+
+        if getattr(settings, "SITE_ID", ""):
+            site_id = settings.SITE_ID
+            return self._get_site_by_id(site_id)
+        elif request:
+            return self._get_site_by_request(request)
+
+        raise ImproperlyConfigured(
+            'You\'re using the Django "sites framework" without having '
+            "set the SITE_ID setting. Create a site in your database and "
+            "set the SITE_ID setting or pass a request to "
+            "Site.objects.get_current() to fix this error."
+        )
+
+    def clear_cache(self):
+        """Clear the ``Site`` object cache."""
+        global SITE_CACHE
+        SITE_CACHE = {}
+
+    def get_by_natural_key(self, domain):
+        return self.get(domain=domain)
+
+
+class Site(models.Model):
+    domain = models.CharField(
+        _("domain name"),
+        max_length=100,
+        validators=[_simple_domain_name_validator],
+        unique=True,
+    )
+    name = models.CharField(_("display name"), max_length=50)
+
+    objects = SiteManager()
+
+    class Meta:
+        db_table = "django_site"
+        verbose_name = _("site")
+        verbose_name_plural = _("sites")
+        ordering = ["domain"]
+
+    def __str__(self):
+        return self.domain
+
+    def natural_key(self):
+        return (self.domain,)
+
+
+def clear_site_cache(sender, **kwargs):
+    """
+    Clear the cache (if primed) each time a site is saved or deleted.
+    """
+    instance = kwargs["instance"]
+    using = kwargs["using"]
+    try:
+        del SITE_CACHE[instance.pk]
+    except KeyError:
+        pass
+    try:
+        del SITE_CACHE[Site.objects.using(using).get(pk=instance.pk).domain]
+    except (KeyError, Site.DoesNotExist):
+        pass
+
+
+pre_save.connect(clear_site_cache, sender=Site)
+pre_delete.connect(clear_site_cache, sender=Site)

testbed/django__django/django/contrib/sites/requests.py

@@ -0,0 +1,20 @@
+class RequestSite:
+    """
+    A class that shares the primary interface of Site (i.e., it has ``domain``
+    and ``name`` attributes) but gets its data from an HttpRequest object
+    rather than from a database.
+
+    The save() and delete() methods raise NotImplementedError.
+    """
+
+    def __init__(self, request):
+        self.domain = self.name = request.get_host()
+
+    def __str__(self):
+        return self.domain
+
+    def save(self, force_insert=False, force_update=False):
+        raise NotImplementedError("RequestSite cannot be saved.")
+
+    def delete(self):
+        raise NotImplementedError("RequestSite cannot be deleted.")

testbed/django__django/django/contrib/sites/shortcuts.py

@@ -0,0 +1,18 @@
+from django.apps import apps
+
+from .requests import RequestSite
+
+
+def get_current_site(request):
+    """
+    Check if contrib.sites is installed and return either the current
+    ``Site`` object or a ``RequestSite`` object based on the request.
+    """
+    # Import is inside the function because its point is to avoid importing the
+    # Site models when django.contrib.sites isn't installed.
+    if apps.is_installed("django.contrib.sites"):
+        from .models import Site
+
+        return Site.objects.get_current(request)
+    else:
+        return RequestSite(request)

testbed/django__django/django/contrib/staticfiles/apps.py

@@ -0,0 +1,13 @@
+from django.apps import AppConfig
+from django.contrib.staticfiles.checks import check_finders
+from django.core import checks
+from django.utils.translation import gettext_lazy as _
+
+
+class StaticFilesConfig(AppConfig):
+    name = "django.contrib.staticfiles"
+    verbose_name = _("Static Files")
+    ignore_patterns = ["CVS", ".*", "*~"]
+
+    def ready(self):
+        checks.register(check_finders, checks.Tags.staticfiles)

testbed/django__django/django/contrib/staticfiles/checks.py

@@ -0,0 +1,14 @@
+from django.contrib.staticfiles.finders import get_finders
+
+
+def check_finders(app_configs=None, **kwargs):
+    """Check all registered staticfiles finders."""
+    errors = []
+    for finder in get_finders():
+        try:
+            finder_errors = finder.check()
+        except NotImplementedError:
+            pass
+        else:
+            errors.extend(finder_errors)
+    return errors

testbed/django__django/django/contrib/staticfiles/finders.py

@@ -0,0 +1,326 @@
+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
+
+# To keep track on which directories the finder has searched the static files.
+searched_locations = []
+
+
+class BaseFinder:
+    """
+    A base file finder to be used for custom staticfiles finder classes.
+    """
+
+    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):
+        """
+        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.
+        """
+        raise NotImplementedError(
+            "subclasses of BaseFinder must provide a find() method"
+        )
+
+    def list(self, ignore_patterns):
+        """
+        Given an optional list of paths to ignore, return a two item iterable
+        consisting of the relative path and storage instance.
+        """
+        raise NotImplementedError(
+            "subclasses of BaseFinder must provide a list() method"
+        )
+
+
+class FileSystemFinder(BaseFinder):
+    """
+    A static files finder that uses the ``STATICFILES_DIRS`` setting
+    to locate files.
+    """
+
+    def __init__(self, app_names=None, *args, **kwargs):
+        # List of locations with static files
+        self.locations = []
+        # Maps dir paths to an appropriate storage instance
+        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):
+        """
+        Look for files in the extra locations as defined in STATICFILES_DIRS.
+        """
+        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):
+        """
+        Find a requested static file in a location and return the found
+        absolute path (or ``None`` if no match).
+        """
+        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):
+        """
+        List all files in all locations.
+        """
+        for prefix, root in self.locations:
+            # Skip nonexistent directories.
+            if os.path.isdir(root):
+                storage = self.storages[root]
+                for path in utils.get_files(storage, ignore_patterns):
+                    yield path, storage
+
+
+class AppDirectoriesFinder(BaseFinder):
+    """
+    A static files finder that looks in the directory of each app as
+    specified in the source_dir attribute.
+    """
+
+    storage_class = FileSystemStorage
+    source_dir = "static"
+
+    def __init__(self, app_names=None, *args, **kwargs):
+        # The list of apps that are handled
+        self.apps = []
+        # Mapping of app names to storage instances
+        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):
+        """
+        List all files in all app storages.
+        """
+        for storage in self.storages.values():
+            if storage.exists(""):  # check if storage location exists
+                for path in utils.get_files(storage, ignore_patterns):
+                    yield path, storage
+
+    def find(self, path, all=False):
+        """
+        Look for files in the app directories.
+        """
+        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):
+        """
+        Find a requested static file in an app's static locations.
+        """
+        storage = self.storages.get(app)
+        # Only try to find a file if the source dir actually exists.
+        if storage and storage.exists(path):
+            matched_path = storage.path(path)
+            if matched_path:
+                return matched_path
+
+
+class BaseStorageFinder(BaseFinder):
+    """
+    A base static files finder to be used to extended
+    with an own storage class.
+    """
+
+    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__
+            )
+        # Make sure we have a storage instance here.
+        if not isinstance(self.storage, (Storage, LazyObject)):
+            self.storage = self.storage()
+        super().__init__(*args, **kwargs)
+
+    def find(self, path, all=False):
+        """
+        Look for files in the default file storage, if it's local.
+        """
+        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):
+        """
+        List all files of the storage.
+        """
+        for path in utils.get_files(self.storage, ignore_patterns):
+            yield path, self.storage
+
+
+class DefaultStorageFinder(BaseStorageFinder):
+    """
+    A static files finder that uses the default storage backend.
+    """
+
+    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):
+    """
+    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.
+    """
+    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
+    # No match.
+    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):
+    """
+    Import the staticfiles finder class described by import_path, where
+    import_path is the full Python path to the class.
+    """
+    Finder = import_string(import_path)
+    if not issubclass(Finder, BaseFinder):
+        raise ImproperlyConfigured(
+            'Finder "%s" is not a subclass of "%s"' % (Finder, BaseFinder)
+        )
+    return Finder()

testbed/django__django/django/contrib/staticfiles/handlers.py

@@ -0,0 +1,115 @@
+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.removeprefix(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)
+
+    async def get_response_async(self, request):
+        response = await super().get_response_async(request)
+        response._resource_closers.append(request.close)
+        # FileResponse is not async compatible.
+        if response.streaming and not response.is_async:
+            _iterator = response.streaming_content
+
+            async def awrapper():
+                for part in await sync_to_async(list)(_iterator):
+                    yield part
+
+            response.streaming_content = awrapper()
+        return response

testbed/django__django/django/contrib/staticfiles/management/commands/collectstatic.py

@@ -0,0 +1,379 @@
+import os
+
+from django.apps import apps
+from django.contrib.staticfiles.finders import get_finders
+from django.contrib.staticfiles.storage import staticfiles_storage
+from django.core.checks import Tags
+from django.core.files.storage import FileSystemStorage
+from django.core.management.base import BaseCommand, CommandError
+from django.core.management.color import no_style
+from django.utils.functional import cached_property
+
+
+class Command(BaseCommand):
+    """
+    Copies or symlinks static files from different locations to the
+    settings.STATIC_ROOT.
+    """
+
+    help = "Collect static files in a single location."
+    requires_system_checks = [Tags.staticfiles]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.copied_files = []
+        self.symlinked_files = []
+        self.unmodified_files = []
+        self.post_processed_files = []
+        self.storage = staticfiles_storage
+        self.style = no_style()
+
+    @cached_property
+    def local(self):
+        try:
+            self.storage.path("")
+        except NotImplementedError:
+            return False
+        return True
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--noinput",
+            "--no-input",
+            action="store_false",
+            dest="interactive",
+            help="Do NOT prompt the user for input of any kind.",
+        )
+        parser.add_argument(
+            "--no-post-process",
+            action="store_false",
+            dest="post_process",
+            help="Do NOT post process collected files.",
+        )
+        parser.add_argument(
+            "-i",
+            "--ignore",
+            action="append",
+            default=[],
+            dest="ignore_patterns",
+            metavar="PATTERN",
+            help="Ignore files or directories matching this glob-style "
+            "pattern. Use multiple times to ignore more.",
+        )
+        parser.add_argument(
+            "-n",
+            "--dry-run",
+            action="store_true",
+            help="Do everything except modify the filesystem.",
+        )
+        parser.add_argument(
+            "-c",
+            "--clear",
+            action="store_true",
+            help="Clear the existing files using the storage "
+            "before trying to copy or link the original file.",
+        )
+        parser.add_argument(
+            "-l",
+            "--link",
+            action="store_true",
+            help="Create a symbolic link to each file instead of copying.",
+        )
+        parser.add_argument(
+            "--no-default-ignore",
+            action="store_false",
+            dest="use_default_ignore_patterns",
+            help=(
+                "Don't ignore the common private glob-style patterns (defaults to "
+                "'CVS', '.*' and '*~')."
+            ),
+        )
+
+    def set_options(self, **options):
+        """
+        Set instance variables based on an options dict
+        """
+        self.interactive = options["interactive"]
+        self.verbosity = options["verbosity"]
+        self.symlink = options["link"]
+        self.clear = options["clear"]
+        self.dry_run = options["dry_run"]
+        ignore_patterns = options["ignore_patterns"]
+        if options["use_default_ignore_patterns"]:
+            ignore_patterns += apps.get_app_config("staticfiles").ignore_patterns
+        self.ignore_patterns = list({os.path.normpath(p) for p in ignore_patterns})
+        self.post_process = options["post_process"]
+
+    def collect(self):
+        """
+        Perform the bulk of the work of collectstatic.
+
+        Split off from handle() to facilitate testing.
+        """
+        if self.symlink and not self.local:
+            raise CommandError("Can't symlink to a remote destination.")
+
+        if self.clear:
+            self.clear_dir("")
+
+        if self.symlink:
+            handler = self.link_file
+        else:
+            handler = self.copy_file
+
+        found_files = {}
+        for finder in get_finders():
+            for path, storage in finder.list(self.ignore_patterns):
+                # Prefix the relative path if the source storage contains it
+                if getattr(storage, "prefix", None):
+                    prefixed_path = os.path.join(storage.prefix, path)
+                else:
+                    prefixed_path = path
+
+                if prefixed_path not in found_files:
+                    found_files[prefixed_path] = (storage, path)
+                    handler(path, prefixed_path, storage)
+                else:
+                    self.log(
+                        "Found another file with the destination path '%s'. It "
+                        "will be ignored since only the first encountered file "
+                        "is collected. If this is not what you want, make sure "
+                        "every static file has a unique path." % prefixed_path,
+                        level=1,
+                    )
+
+        # Storage backends may define a post_process() method.
+        if self.post_process and hasattr(self.storage, "post_process"):
+            processor = self.storage.post_process(found_files, dry_run=self.dry_run)
+            for original_path, processed_path, processed in processor:
+                if isinstance(processed, Exception):
+                    self.stderr.write("Post-processing '%s' failed!" % original_path)
+                    # Add a blank line before the traceback, otherwise it's
+                    # too easy to miss the relevant part of the error message.
+                    self.stderr.write()
+                    raise processed
+                if processed:
+                    self.log(
+                        "Post-processed '%s' as '%s'" % (original_path, processed_path),
+                        level=2,
+                    )
+                    self.post_processed_files.append(original_path)
+                else:
+                    self.log("Skipped post-processing '%s'" % original_path)
+
+        return {
+            "modified": self.copied_files + self.symlinked_files,
+            "unmodified": self.unmodified_files,
+            "post_processed": self.post_processed_files,
+        }
+
+    def handle(self, **options):
+        self.set_options(**options)
+        message = ["\n"]
+        if self.dry_run:
+            message.append(
+                "You have activated the --dry-run option so no files will be "
+                "modified.\n\n"
+            )
+
+        message.append(
+            "You have requested to collect static files at the destination\n"
+            "location as specified in your settings"
+        )
+
+        if self.is_local_storage() and self.storage.location:
+            destination_path = self.storage.location
+            message.append(":\n\n    %s\n\n" % destination_path)
+            should_warn_user = self.storage.exists(destination_path) and any(
+                self.storage.listdir(destination_path)
+            )
+        else:
+            destination_path = None
+            message.append(".\n\n")
+            # Destination files existence not checked; play it safe and warn.
+            should_warn_user = True
+
+        if self.interactive and should_warn_user:
+            if self.clear:
+                message.append("This will DELETE ALL FILES in this location!\n")
+            else:
+                message.append("This will overwrite existing files!\n")
+
+            message.append(
+                "Are you sure you want to do this?\n\n"
+                "Type 'yes' to continue, or 'no' to cancel: "
+            )
+            if input("".join(message)) != "yes":
+                raise CommandError("Collecting static files cancelled.")
+
+        collected = self.collect()
+
+        if self.verbosity >= 1:
+            modified_count = len(collected["modified"])
+            unmodified_count = len(collected["unmodified"])
+            post_processed_count = len(collected["post_processed"])
+            return (
+                "\n%(modified_count)s %(identifier)s %(action)s"
+                "%(destination)s%(unmodified)s%(post_processed)s."
+            ) % {
+                "modified_count": modified_count,
+                "identifier": "static file" + ("" if modified_count == 1 else "s"),
+                "action": "symlinked" if self.symlink else "copied",
+                "destination": (
+                    " to '%s'" % destination_path if destination_path else ""
+                ),
+                "unmodified": (
+                    ", %s unmodified" % unmodified_count
+                    if collected["unmodified"]
+                    else ""
+                ),
+                "post_processed": (
+                    collected["post_processed"]
+                    and ", %s post-processed" % post_processed_count
+                    or ""
+                ),
+            }
+
+    def log(self, msg, level=2):
+        """
+        Small log helper
+        """
+        if self.verbosity >= level:
+            self.stdout.write(msg)
+
+    def is_local_storage(self):
+        return isinstance(self.storage, FileSystemStorage)
+
+    def clear_dir(self, path):
+        """
+        Delete the given relative path using the destination storage backend.
+        """
+        if not self.storage.exists(path):
+            return
+
+        dirs, files = self.storage.listdir(path)
+        for f in files:
+            fpath = os.path.join(path, f)
+            if self.dry_run:
+                self.log("Pretending to delete '%s'" % fpath, level=1)
+            else:
+                self.log("Deleting '%s'" % fpath, level=1)
+                try:
+                    full_path = self.storage.path(fpath)
+                except NotImplementedError:
+                    self.storage.delete(fpath)
+                else:
+                    if not os.path.exists(full_path) and os.path.lexists(full_path):
+                        # Delete broken symlinks
+                        os.unlink(full_path)
+                    else:
+                        self.storage.delete(fpath)
+        for d in dirs:
+            self.clear_dir(os.path.join(path, d))
+
+    def delete_file(self, path, prefixed_path, source_storage):
+        """
+        Check if the target file should be deleted if it already exists.
+        """
+        if self.storage.exists(prefixed_path):
+            try:
+                # When was the target file modified last time?
+                target_last_modified = self.storage.get_modified_time(prefixed_path)
+            except (OSError, NotImplementedError, AttributeError):
+                # The storage doesn't support get_modified_time() or failed
+                pass
+            else:
+                try:
+                    # When was the source file modified last time?
+                    source_last_modified = source_storage.get_modified_time(path)
+                except (OSError, NotImplementedError, AttributeError):
+                    pass
+                else:
+                    # The full path of the target file
+                    if self.local:
+                        full_path = self.storage.path(prefixed_path)
+                        # If it's --link mode and the path isn't a link (i.e.
+                        # the previous collectstatic wasn't with --link) or if
+                        # it's non-link mode and the path is a link (i.e. the
+                        # previous collectstatic was with --link), the old
+                        # links/files must be deleted so it's not safe to skip
+                        # unmodified files.
+                        can_skip_unmodified_files = not (
+                            self.symlink ^ os.path.islink(full_path)
+                        )
+                    else:
+                        # In remote storages, skipping is only based on the
+                        # modified times since symlinks aren't relevant.
+                        can_skip_unmodified_files = True
+                    # Avoid sub-second precision (see #14665, #19540)
+                    file_is_unmodified = target_last_modified.replace(
+                        microsecond=0
+                    ) >= source_last_modified.replace(microsecond=0)
+                    if file_is_unmodified and can_skip_unmodified_files:
+                        if prefixed_path not in self.unmodified_files:
+                            self.unmodified_files.append(prefixed_path)
+                        self.log("Skipping '%s' (not modified)" % path)
+                        return False
+            # Then delete the existing file if really needed
+            if self.dry_run:
+                self.log("Pretending to delete '%s'" % path)
+            else:
+                self.log("Deleting '%s'" % path)
+                self.storage.delete(prefixed_path)
+        return True
+
+    def link_file(self, path, prefixed_path, source_storage):
+        """
+        Attempt to link ``path``
+        """
+        # Skip this file if it was already copied earlier
+        if prefixed_path in self.symlinked_files:
+            return self.log("Skipping '%s' (already linked earlier)" % path)
+        # Delete the target file if needed or break
+        if not self.delete_file(path, prefixed_path, source_storage):
+            return
+        # The full path of the source file
+        source_path = source_storage.path(path)
+        # Finally link the file
+        if self.dry_run:
+            self.log("Pretending to link '%s'" % source_path, level=1)
+        else:
+            self.log("Linking '%s'" % source_path, level=2)
+            full_path = self.storage.path(prefixed_path)
+            os.makedirs(os.path.dirname(full_path), exist_ok=True)
+            try:
+                if os.path.lexists(full_path):
+                    os.unlink(full_path)
+                os.symlink(source_path, full_path)
+            except NotImplementedError:
+                import platform
+
+                raise CommandError(
+                    "Symlinking is not supported in this "
+                    "platform (%s)." % platform.platform()
+                )
+            except OSError as e:
+                raise CommandError(e)
+        if prefixed_path not in self.symlinked_files:
+            self.symlinked_files.append(prefixed_path)
+
+    def copy_file(self, path, prefixed_path, source_storage):
+        """
+        Attempt to copy ``path`` with storage
+        """
+        # Skip this file if it was already copied earlier
+        if prefixed_path in self.copied_files:
+            return self.log("Skipping '%s' (already copied earlier)" % path)
+        # Delete the target file if needed or break
+        if not self.delete_file(path, prefixed_path, source_storage):
+            return
+        # The full path of the source file
+        source_path = source_storage.path(path)
+        # Finally start copying
+        if self.dry_run:
+            self.log("Pretending to copy '%s'" % source_path, level=1)
+        else:
+            self.log("Copying '%s'" % source_path, level=2)
+            with source_storage.open(path) as source_file:
+                self.storage.save(prefixed_path, source_file)
+        self.copied_files.append(prefixed_path)

testbed/django__django/django/contrib/staticfiles/management/commands/findstatic.py

@@ -0,0 +1,48 @@
+import os
+
+from django.contrib.staticfiles import finders
+from django.core.management.base import LabelCommand
+
+
+class Command(LabelCommand):
+    help = "Finds the absolute paths for the given static file(s)."
+    label = "staticfile"
+
+    def add_arguments(self, parser):
+        super().add_arguments(parser)
+        parser.add_argument(
+            "--first",
+            action="store_false",
+            dest="all",
+            help="Only return the first match for each static file.",
+        )
+
+    def handle_label(self, path, **options):
+        verbosity = options["verbosity"]
+        result = finders.find(path, all=options["all"])
+        if verbosity >= 2:
+            searched_locations = (
+                "\nLooking in the following locations:\n  %s"
+                % "\n  ".join([str(loc) for loc in finders.searched_locations])
+            )
+        else:
+            searched_locations = ""
+        if result:
+            if not isinstance(result, (list, tuple)):
+                result = [result]
+            result = (os.path.realpath(path) for path in result)
+            if verbosity >= 1:
+                file_list = "\n  ".join(result)
+                return "Found '%s' here:\n  %s%s" % (
+                    path,
+                    file_list,
+                    searched_locations,
+                )
+            else:
+                return "\n".join(result)
+        else:
+            message = ["No matching file found for '%s'." % path]
+            if verbosity >= 2:
+                message.append(searched_locations)
+            if verbosity >= 1:
+                self.stderr.write("\n".join(message))

testbed/django__django/django/contrib/staticfiles/management/commands/runserver.py

@@ -0,0 +1,36 @@
+from django.conf import settings
+from django.contrib.staticfiles.handlers import StaticFilesHandler
+from django.core.management.commands.runserver import Command as RunserverCommand
+
+
+class Command(RunserverCommand):
+    help = (
+        "Starts a lightweight web server for development and also serves static files."
+    )
+
+    def add_arguments(self, parser):
+        super().add_arguments(parser)
+        parser.add_argument(
+            "--nostatic",
+            action="store_false",
+            dest="use_static_handler",
+            help="Tells Django to NOT automatically serve static files at STATIC_URL.",
+        )
+        parser.add_argument(
+            "--insecure",
+            action="store_true",
+            dest="insecure_serving",
+            help="Allows serving static files even if DEBUG is False.",
+        )
+
+    def get_handler(self, *args, **options):
+        """
+        Return the static files serving handler wrapping the default handler,
+        if static files should be served. Otherwise return the default handler.
+        """
+        handler = super().get_handler(*args, **options)
+        use_static_handler = options["use_static_handler"]
+        insecure_serving = options["insecure_serving"]
+        if use_static_handler and (settings.DEBUG or insecure_serving):
+            return StaticFilesHandler(handler)
+        return handler

testbed/django__django/django/contrib/staticfiles/storage.py

@@ -0,0 +1,543 @@
+import json
+import os
+import posixpath
+import re
+from hashlib import md5
+from urllib.parse import unquote, urldefrag, urlsplit, urlunsplit
+
+from django.conf import STATICFILES_STORAGE_ALIAS, settings
+from django.contrib.staticfiles.utils import check_settings, matches_patterns
+from django.core.exceptions import ImproperlyConfigured
+from django.core.files.base import ContentFile
+from django.core.files.storage import FileSystemStorage, storages
+from django.utils.functional import LazyObject
+
+
+class StaticFilesStorage(FileSystemStorage):
+    """
+    Standard file system storage for static files.
+
+    The defaults for ``location`` and ``base_url`` are
+    ``STATIC_ROOT`` and ``STATIC_URL``.
+    """
+
+    def __init__(self, location=None, base_url=None, *args, **kwargs):
+        if location is None:
+            location = settings.STATIC_ROOT
+        if base_url is None:
+            base_url = settings.STATIC_URL
+        check_settings(base_url)
+        super().__init__(location, base_url, *args, **kwargs)
+        # FileSystemStorage fallbacks to MEDIA_ROOT when location
+        # is empty, so we restore the empty value.
+        if not location:
+            self.base_location = None
+            self.location = None
+
+    def path(self, name):
+        if not self.location:
+            raise ImproperlyConfigured(
+                "You're using the staticfiles app "
+                "without having set the STATIC_ROOT "
+                "setting to a filesystem path."
+            )
+        return super().path(name)
+
+
+class HashedFilesMixin:
+    default_template = """url("%(url)s")"""
+    max_post_process_passes = 5
+    support_js_module_import_aggregation = False
+    _js_module_import_aggregation_patterns = (
+        "*.js",
+        (
+            (
+                (
+                    r"""(?P<matched>import(?s:(?P<import>[\s\{].*?))"""
+                    r"""\s*from\s*['"](?P<url>[\.\/].*?)["']\s*;)"""
+                ),
+                """import%(import)s from "%(url)s";""",
+            ),
+            (
+                (
+                    r"""(?P<matched>export(?s:(?P<exports>[\s\{].*?))"""
+                    r"""\s*from\s*["'](?P<url>[\.\/].*?)["']\s*;)"""
+                ),
+                """export%(exports)s from "%(url)s";""",
+            ),
+            (
+                r"""(?P<matched>import\s*['"](?P<url>[\.\/].*?)["']\s*;)""",
+                """import"%(url)s";""",
+            ),
+            (
+                r"""(?P<matched>import\(["'](?P<url>.*?)["']\))""",
+                """import("%(url)s")""",
+            ),
+        ),
+    )
+    patterns = (
+        (
+            "*.css",
+            (
+                r"""(?P<matched>url\(['"]{0,1}\s*(?P<url>.*?)["']{0,1}\))""",
+                (
+                    r"""(?P<matched>@import\s*["']\s*(?P<url>.*?)["'])""",
+                    """@import url("%(url)s")""",
+                ),
+                (
+                    (
+                        r"(?m)^(?P<matched>/\*#[ \t]"
+                        r"(?-i:sourceMappingURL)=(?P<url>.*)[ \t]*\*/)$"
+                    ),
+                    "/*# sourceMappingURL=%(url)s */",
+                ),
+            ),
+        ),
+        (
+            "*.js",
+            (
+                (
+                    r"(?m)^(?P<matched>//# (?-i:sourceMappingURL)=(?P<url>.*))$",
+                    "//# sourceMappingURL=%(url)s",
+                ),
+            ),
+        ),
+    )
+    keep_intermediate_files = True
+
+    def __init__(self, *args, **kwargs):
+        if self.support_js_module_import_aggregation:
+            self.patterns += (self._js_module_import_aggregation_patterns,)
+        super().__init__(*args, **kwargs)
+        self._patterns = {}
+        self.hashed_files = {}
+        for extension, patterns in self.patterns:
+            for pattern in patterns:
+                if isinstance(pattern, (tuple, list)):
+                    pattern, template = pattern
+                else:
+                    template = self.default_template
+                compiled = re.compile(pattern, re.IGNORECASE)
+                self._patterns.setdefault(extension, []).append((compiled, template))
+
+    def file_hash(self, name, content=None):
+        """
+        Return a hash of the file with the given name and optional content.
+        """
+        if content is None:
+            return None
+        hasher = md5(usedforsecurity=False)
+        for chunk in content.chunks():
+            hasher.update(chunk)
+        return hasher.hexdigest()[:12]
+
+    def hashed_name(self, name, content=None, filename=None):
+        # `filename` is the name of file to hash if `content` isn't given.
+        # `name` is the base name to construct the new hashed filename from.
+        parsed_name = urlsplit(unquote(name))
+        clean_name = parsed_name.path.strip()
+        filename = (filename and urlsplit(unquote(filename)).path.strip()) or clean_name
+        opened = content is None
+        if opened:
+            if not self.exists(filename):
+                raise ValueError(
+                    "The file '%s' could not be found with %r." % (filename, self)
+                )
+            try:
+                content = self.open(filename)
+            except OSError:
+                # Handle directory paths and fragments
+                return name
+        try:
+            file_hash = self.file_hash(clean_name, content)
+        finally:
+            if opened:
+                content.close()
+        path, filename = os.path.split(clean_name)
+        root, ext = os.path.splitext(filename)
+        file_hash = (".%s" % file_hash) if file_hash else ""
+        hashed_name = os.path.join(path, "%s%s%s" % (root, file_hash, ext))
+        unparsed_name = list(parsed_name)
+        unparsed_name[2] = hashed_name
+        # Special casing for a @font-face hack, like url(myfont.eot?#iefix")
+        # http://www.fontspring.com/blog/the-new-bulletproof-font-face-syntax
+        if "?#" in name and not unparsed_name[3]:
+            unparsed_name[2] += "?"
+        return urlunsplit(unparsed_name)
+
+    def _url(self, hashed_name_func, name, force=False, hashed_files=None):
+        """
+        Return the non-hashed URL in DEBUG mode.
+        """
+        if settings.DEBUG and not force:
+            hashed_name, fragment = name, ""
+        else:
+            clean_name, fragment = urldefrag(name)
+            if urlsplit(clean_name).path.endswith("/"):  # don't hash paths
+                hashed_name = name
+            else:
+                args = (clean_name,)
+                if hashed_files is not None:
+                    args += (hashed_files,)
+                hashed_name = hashed_name_func(*args)
+
+        final_url = super().url(hashed_name)
+
+        # Special casing for a @font-face hack, like url(myfont.eot?#iefix")
+        # http://www.fontspring.com/blog/the-new-bulletproof-font-face-syntax
+        query_fragment = "?#" in name  # [sic!]
+        if fragment or query_fragment:
+            urlparts = list(urlsplit(final_url))
+            if fragment and not urlparts[4]:
+                urlparts[4] = fragment
+            if query_fragment and not urlparts[3]:
+                urlparts[2] += "?"
+            final_url = urlunsplit(urlparts)
+
+        return unquote(final_url)
+
+    def url(self, name, force=False):
+        """
+        Return the non-hashed URL in DEBUG mode.
+        """
+        return self._url(self.stored_name, name, force)
+
+    def url_converter(self, name, hashed_files, template=None):
+        """
+        Return the custom URL converter for the given file name.
+        """
+        if template is None:
+            template = self.default_template
+
+        def converter(matchobj):
+            """
+            Convert the matched URL to a normalized and hashed URL.
+
+            This requires figuring out which files the matched URL resolves
+            to and calling the url() method of the storage.
+            """
+            matches = matchobj.groupdict()
+            matched = matches["matched"]
+            url = matches["url"]
+
+            # Ignore absolute/protocol-relative and data-uri URLs.
+            if re.match(r"^[a-z]+:", url):
+                return matched
+
+            # Ignore absolute URLs that don't point to a static file (dynamic
+            # CSS / JS?). Note that STATIC_URL cannot be empty.
+            if url.startswith("/") and not url.startswith(settings.STATIC_URL):
+                return matched
+
+            # Strip off the fragment so a path-like fragment won't interfere.
+            url_path, fragment = urldefrag(url)
+
+            # Ignore URLs without a path
+            if not url_path:
+                return matched
+
+            if url_path.startswith("/"):
+                # Otherwise the condition above would have returned prematurely.
+                assert url_path.startswith(settings.STATIC_URL)
+                target_name = url_path.removeprefix(settings.STATIC_URL)
+            else:
+                # We're using the posixpath module to mix paths and URLs conveniently.
+                source_name = name if os.sep == "/" else name.replace(os.sep, "/")
+                target_name = posixpath.join(posixpath.dirname(source_name), url_path)
+
+            # Determine the hashed name of the target file with the storage backend.
+            hashed_url = self._url(
+                self._stored_name,
+                unquote(target_name),
+                force=True,
+                hashed_files=hashed_files,
+            )
+
+            transformed_url = "/".join(
+                url_path.split("/")[:-1] + hashed_url.split("/")[-1:]
+            )
+
+            # Restore the fragment that was stripped off earlier.
+            if fragment:
+                transformed_url += ("?#" if "?#" in url else "#") + fragment
+
+            # Return the hashed version to the file
+            matches["url"] = unquote(transformed_url)
+            return template % matches
+
+        return converter
+
+    def post_process(self, paths, dry_run=False, **options):
+        """
+        Post process the given dictionary of files (called from collectstatic).
+
+        Processing is actually two separate operations:
+
+        1. renaming files to include a hash of their content for cache-busting,
+           and copying those files to the target storage.
+        2. adjusting files which contain references to other files so they
+           refer to the cache-busting filenames.
+
+        If either of these are performed on a file, then that file is considered
+        post-processed.
+        """
+        # don't even dare to process the files if we're in dry run mode
+        if dry_run:
+            return
+
+        # where to store the new paths
+        hashed_files = {}
+
+        # build a list of adjustable files
+        adjustable_paths = [
+            path for path in paths if matches_patterns(path, self._patterns)
+        ]
+
+        # Adjustable files to yield at end, keyed by the original path.
+        processed_adjustable_paths = {}
+
+        # Do a single pass first. Post-process all files once, yielding not
+        # adjustable files and exceptions, and collecting adjustable files.
+        for name, hashed_name, processed, _ in self._post_process(
+            paths, adjustable_paths, hashed_files
+        ):
+            if name not in adjustable_paths or isinstance(processed, Exception):
+                yield name, hashed_name, processed
+            else:
+                processed_adjustable_paths[name] = (name, hashed_name, processed)
+
+        paths = {path: paths[path] for path in adjustable_paths}
+        substitutions = False
+
+        for i in range(self.max_post_process_passes):
+            substitutions = False
+            for name, hashed_name, processed, subst in self._post_process(
+                paths, adjustable_paths, hashed_files
+            ):
+                # Overwrite since hashed_name may be newer.
+                processed_adjustable_paths[name] = (name, hashed_name, processed)
+                substitutions = substitutions or subst
+
+            if not substitutions:
+                break
+
+        if substitutions:
+            yield "All", None, RuntimeError("Max post-process passes exceeded.")
+
+        # Store the processed paths
+        self.hashed_files.update(hashed_files)
+
+        # Yield adjustable files with final, hashed name.
+        yield from processed_adjustable_paths.values()
+
+    def _post_process(self, paths, adjustable_paths, hashed_files):
+        # Sort the files by directory level
+        def path_level(name):
+            return len(name.split(os.sep))
+
+        for name in sorted(paths, key=path_level, reverse=True):
+            substitutions = True
+            # use the original, local file, not the copied-but-unprocessed
+            # file, which might be somewhere far away, like S3
+            storage, path = paths[name]
+            with storage.open(path) as original_file:
+                cleaned_name = self.clean_name(name)
+                hash_key = self.hash_key(cleaned_name)
+
+                # generate the hash with the original content, even for
+                # adjustable files.
+                if hash_key not in hashed_files:
+                    hashed_name = self.hashed_name(name, original_file)
+                else:
+                    hashed_name = hashed_files[hash_key]
+
+                # then get the original's file content..
+                if hasattr(original_file, "seek"):
+                    original_file.seek(0)
+
+                hashed_file_exists = self.exists(hashed_name)
+                processed = False
+
+                # ..to apply each replacement pattern to the content
+                if name in adjustable_paths:
+                    old_hashed_name = hashed_name
+                    try:
+                        content = original_file.read().decode("utf-8")
+                    except UnicodeDecodeError as exc:
+                        yield name, None, exc, False
+                    for extension, patterns in self._patterns.items():
+                        if matches_patterns(path, (extension,)):
+                            for pattern, template in patterns:
+                                converter = self.url_converter(
+                                    name, hashed_files, template
+                                )
+                                try:
+                                    content = pattern.sub(converter, content)
+                                except ValueError as exc:
+                                    yield name, None, exc, False
+                    if hashed_file_exists:
+                        self.delete(hashed_name)
+                    # then save the processed result
+                    content_file = ContentFile(content.encode())
+                    if self.keep_intermediate_files:
+                        # Save intermediate file for reference
+                        self._save(hashed_name, content_file)
+                    hashed_name = self.hashed_name(name, content_file)
+
+                    if self.exists(hashed_name):
+                        self.delete(hashed_name)
+
+                    saved_name = self._save(hashed_name, content_file)
+                    hashed_name = self.clean_name(saved_name)
+                    # If the file hash stayed the same, this file didn't change
+                    if old_hashed_name == hashed_name:
+                        substitutions = False
+                    processed = True
+
+                if not processed:
+                    # or handle the case in which neither processing nor
+                    # a change to the original file happened
+                    if not hashed_file_exists:
+                        processed = True
+                        saved_name = self._save(hashed_name, original_file)
+                        hashed_name = self.clean_name(saved_name)
+
+                # and then set the cache accordingly
+                hashed_files[hash_key] = hashed_name
+
+                yield name, hashed_name, processed, substitutions
+
+    def clean_name(self, name):
+        return name.replace("\\", "/")
+
+    def hash_key(self, name):
+        return name
+
+    def _stored_name(self, name, hashed_files):
+        # Normalize the path to avoid multiple names for the same file like
+        # ../foo/bar.css and ../foo/../foo/bar.css which normalize to the same
+        # path.
+        name = posixpath.normpath(name)
+        cleaned_name = self.clean_name(name)
+        hash_key = self.hash_key(cleaned_name)
+        cache_name = hashed_files.get(hash_key)
+        if cache_name is None:
+            cache_name = self.clean_name(self.hashed_name(name))
+        return cache_name
+
+    def stored_name(self, name):
+        cleaned_name = self.clean_name(name)
+        hash_key = self.hash_key(cleaned_name)
+        cache_name = self.hashed_files.get(hash_key)
+        if cache_name:
+            return cache_name
+        # No cached name found, recalculate it from the files.
+        intermediate_name = name
+        for i in range(self.max_post_process_passes + 1):
+            cache_name = self.clean_name(
+                self.hashed_name(name, content=None, filename=intermediate_name)
+            )
+            if intermediate_name == cache_name:
+                # Store the hashed name if there was a miss.
+                self.hashed_files[hash_key] = cache_name
+                return cache_name
+            else:
+                # Move on to the next intermediate file.
+                intermediate_name = cache_name
+        # If the cache name can't be determined after the max number of passes,
+        # the intermediate files on disk may be corrupt; avoid an infinite loop.
+        raise ValueError("The name '%s' could not be hashed with %r." % (name, self))
+
+
+class ManifestFilesMixin(HashedFilesMixin):
+    manifest_version = "1.1"  # the manifest format standard
+    manifest_name = "staticfiles.json"
+    manifest_strict = True
+    keep_intermediate_files = False
+
+    def __init__(self, *args, manifest_storage=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        if manifest_storage is None:
+            manifest_storage = self
+        self.manifest_storage = manifest_storage
+        self.hashed_files, self.manifest_hash = self.load_manifest()
+
+    def read_manifest(self):
+        try:
+            with self.manifest_storage.open(self.manifest_name) as manifest:
+                return manifest.read().decode()
+        except FileNotFoundError:
+            return None
+
+    def load_manifest(self):
+        content = self.read_manifest()
+        if content is None:
+            return {}, ""
+        try:
+            stored = json.loads(content)
+        except json.JSONDecodeError:
+            pass
+        else:
+            version = stored.get("version")
+            if version in ("1.0", "1.1"):
+                return stored.get("paths", {}), stored.get("hash", "")
+        raise ValueError(
+            "Couldn't load manifest '%s' (version %s)"
+            % (self.manifest_name, self.manifest_version)
+        )
+
+    def post_process(self, *args, **kwargs):
+        self.hashed_files = {}
+        yield from super().post_process(*args, **kwargs)
+        if not kwargs.get("dry_run"):
+            self.save_manifest()
+
+    def save_manifest(self):
+        self.manifest_hash = self.file_hash(
+            None, ContentFile(json.dumps(sorted(self.hashed_files.items())).encode())
+        )
+        payload = {
+            "paths": self.hashed_files,
+            "version": self.manifest_version,
+            "hash": self.manifest_hash,
+        }
+        if self.manifest_storage.exists(self.manifest_name):
+            self.manifest_storage.delete(self.manifest_name)
+        contents = json.dumps(payload).encode()
+        self.manifest_storage._save(self.manifest_name, ContentFile(contents))
+
+    def stored_name(self, name):
+        parsed_name = urlsplit(unquote(name))
+        clean_name = parsed_name.path.strip()
+        hash_key = self.hash_key(clean_name)
+        cache_name = self.hashed_files.get(hash_key)
+        if cache_name is None:
+            if self.manifest_strict:
+                raise ValueError(
+                    "Missing staticfiles manifest entry for '%s'" % clean_name
+                )
+            cache_name = self.clean_name(self.hashed_name(name))
+        unparsed_name = list(parsed_name)
+        unparsed_name[2] = cache_name
+        # Special casing for a @font-face hack, like url(myfont.eot?#iefix")
+        # http://www.fontspring.com/blog/the-new-bulletproof-font-face-syntax
+        if "?#" in name and not unparsed_name[3]:
+            unparsed_name[2] += "?"
+        return urlunsplit(unparsed_name)
+
+
+class ManifestStaticFilesStorage(ManifestFilesMixin, StaticFilesStorage):
+    """
+    A static file system storage backend which also saves
+    hashed copies of the files it saves.
+    """
+
+    pass
+
+
+class ConfiguredStorage(LazyObject):
+    def _setup(self):
+        self._wrapped = storages[STATICFILES_STORAGE_ALIAS]
+
+
+staticfiles_storage = ConfiguredStorage()

testbed/django__django/django/contrib/staticfiles/testing.py

@@ -0,0 +1,13 @@
+from django.contrib.staticfiles.handlers import StaticFilesHandler
+from django.test import LiveServerTestCase
+
+
+class StaticLiveServerTestCase(LiveServerTestCase):
+    """
+    Extend django.test.LiveServerTestCase to transparently overlay at test
+    execution-time the assets provided by the staticfiles app finders. This
+    means you don't need to run collectstatic before or as a part of your tests
+    setup.
+    """
+
+    static_handler = StaticFilesHandler

testbed/django__django/django/contrib/staticfiles/urls.py

@@ -0,0 +1,19 @@
+from django.conf import settings
+from django.conf.urls.static import static
+from django.contrib.staticfiles.views import serve
+
+urlpatterns = []
+
+
+def staticfiles_urlpatterns(prefix=None):
+    """
+    Helper function to return a URL pattern for serving static files.
+    """
+    if prefix is None:
+        prefix = settings.STATIC_URL
+    return static(prefix, view=serve)
+
+
+# Only append if urlpatterns are empty
+if settings.DEBUG and not urlpatterns:
+    urlpatterns += staticfiles_urlpatterns()

testbed/django__django/django/contrib/staticfiles/utils.py

@@ -0,0 +1,71 @@
+import fnmatch
+import os
+
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+
+
+def matches_patterns(path, patterns):
+    """
+    Return True or False depending on whether the ``path`` should be
+    ignored (if it matches any pattern in ``ignore_patterns``).
+    """
+    return any(fnmatch.fnmatchcase(path, pattern) for pattern in patterns)
+
+
+def get_files(storage, ignore_patterns=None, location=""):
+    """
+    Recursively walk the storage directories yielding the paths
+    of all files that should be copied.
+    """
+    if ignore_patterns is None:
+        ignore_patterns = []
+    directories, files = storage.listdir(location)
+    for fn in files:
+        # Match only the basename.
+        if matches_patterns(fn, ignore_patterns):
+            continue
+        if location:
+            fn = os.path.join(location, fn)
+            # Match the full file path.
+            if matches_patterns(fn, ignore_patterns):
+                continue
+        yield fn
+    for dir in directories:
+        if matches_patterns(dir, ignore_patterns):
+            continue
+        if location:
+            dir = os.path.join(location, dir)
+        yield from get_files(storage, ignore_patterns, dir)
+
+
+def check_settings(base_url=None):
+    """
+    Check if the staticfiles settings have sane values.
+    """
+    if base_url is None:
+        base_url = settings.STATIC_URL
+    if not base_url:
+        raise ImproperlyConfigured(
+            "You're using the staticfiles app "
+            "without having set the required STATIC_URL setting."
+        )
+    if settings.MEDIA_URL == base_url:
+        raise ImproperlyConfigured(
+            "The MEDIA_URL and STATIC_URL settings must have different values"
+        )
+    if (
+        settings.DEBUG
+        and settings.MEDIA_URL
+        and settings.STATIC_URL
+        and settings.MEDIA_URL.startswith(settings.STATIC_URL)
+    ):
+        raise ImproperlyConfigured(
+            "runserver can't serve media if MEDIA_URL is within STATIC_URL."
+        )
+    if (settings.MEDIA_ROOT and settings.STATIC_ROOT) and (
+        settings.MEDIA_ROOT == settings.STATIC_ROOT
+    ):
+        raise ImproperlyConfigured(
+            "The MEDIA_ROOT and STATIC_ROOT settings must have different values"
+        )

testbed/django__django/django/contrib/staticfiles/views.py

@@ -0,0 +1,39 @@
+"""
+Views and functions for serving static files. These are only to be used during
+development, and SHOULD NOT be used in a production setting.
+
+"""
+import os
+import posixpath
+
+from django.conf import settings
+from django.contrib.staticfiles import finders
+from django.http import Http404
+from django.views import static
+
+
+def serve(request, path, insecure=False, **kwargs):
+    """
+    Serve static files below a given point in the directory structure or
+    from locations inferred from the staticfiles finders.
+
+    To use, put a URL pattern such as::
+
+        from django.contrib.staticfiles import views
+
+        path('<path:path>', views.serve)
+
+    in your URLconf.
+
+    It uses the django.views.static.serve() view to serve the found files.
+    """
+    if not settings.DEBUG and not insecure:
+        raise Http404
+    normalized_path = posixpath.normpath(path).lstrip("/")
+    absolute_path = finders.find(normalized_path)
+    if not absolute_path:
+        if path.endswith("/") or path == "":
+            raise Http404("Directory indexes are not allowed here.")
+        raise Http404("'%s' could not be found" % path)
+    document_root, path = os.path.split(absolute_path)
+    return static.serve(request, path, document_root=document_root, **kwargs)

testbed/django__django/django/contrib/syndication/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+from django.utils.translation import gettext_lazy as _
+
+
+class SyndicationConfig(AppConfig):
+    name = "django.contrib.syndication"
+    verbose_name = _("Syndication")

testbed/django__django/django/contrib/syndication/views.py

@@ -0,0 +1,234 @@
+from inspect import getattr_static, unwrap
+
+from django.contrib.sites.shortcuts import get_current_site
+from django.core.exceptions import ImproperlyConfigured, ObjectDoesNotExist
+from django.http import Http404, HttpResponse
+from django.template import TemplateDoesNotExist, loader
+from django.utils import feedgenerator
+from django.utils.encoding import iri_to_uri
+from django.utils.html import escape
+from django.utils.http import http_date
+from django.utils.timezone import get_default_timezone, is_naive, make_aware
+from django.utils.translation import get_language
+
+
+def add_domain(domain, url, secure=False):
+    protocol = "https" if secure else "http"
+    if url.startswith("//"):
+        # Support network-path reference (see #16753) - RSS requires a protocol
+        url = "%s:%s" % (protocol, url)
+    elif not url.startswith(("http://", "https://", "mailto:")):
+        url = iri_to_uri("%s://%s%s" % (protocol, domain, url))
+    return url
+
+
+class FeedDoesNotExist(ObjectDoesNotExist):
+    pass
+
+
+class Feed:
+    feed_type = feedgenerator.DefaultFeed
+    title_template = None
+    description_template = None
+    language = None
+
+    def __call__(self, request, *args, **kwargs):
+        try:
+            obj = self.get_object(request, *args, **kwargs)
+        except ObjectDoesNotExist:
+            raise Http404("Feed object does not exist.")
+        feedgen = self.get_feed(obj, request)
+        response = HttpResponse(content_type=feedgen.content_type)
+        if hasattr(self, "item_pubdate") or hasattr(self, "item_updateddate"):
+            # if item_pubdate or item_updateddate is defined for the feed, set
+            # header so as ConditionalGetMiddleware is able to send 304 NOT MODIFIED
+            response.headers["Last-Modified"] = http_date(
+                feedgen.latest_post_date().timestamp()
+            )
+        feedgen.write(response, "utf-8")
+        return response
+
+    def item_title(self, item):
+        # Titles should be double escaped by default (see #6533)
+        return escape(str(item))
+
+    def item_description(self, item):
+        return str(item)
+
+    def item_link(self, item):
+        try:
+            return item.get_absolute_url()
+        except AttributeError:
+            raise ImproperlyConfigured(
+                "Give your %s class a get_absolute_url() method, or define an "
+                "item_link() method in your Feed class." % item.__class__.__name__
+            )
+
+    def item_enclosures(self, item):
+        enc_url = self._get_dynamic_attr("item_enclosure_url", item)
+        if enc_url:
+            enc = feedgenerator.Enclosure(
+                url=str(enc_url),
+                length=str(self._get_dynamic_attr("item_enclosure_length", item)),
+                mime_type=str(self._get_dynamic_attr("item_enclosure_mime_type", item)),
+            )
+            return [enc]
+        return []
+
+    def _get_dynamic_attr(self, attname, obj, default=None):
+        try:
+            attr = getattr(self, attname)
+        except AttributeError:
+            return default
+        if callable(attr):
+            # Check co_argcount rather than try/excepting the function and
+            # catching the TypeError, because something inside the function
+            # may raise the TypeError. This technique is more accurate.
+            func = unwrap(attr)
+            try:
+                code = func.__code__
+            except AttributeError:
+                func = unwrap(attr.__call__)
+                code = func.__code__
+            # If function doesn't have arguments and it is not a static method,
+            # it was decorated without using @functools.wraps.
+            if not code.co_argcount and not isinstance(
+                getattr_static(self, func.__name__, None), staticmethod
+            ):
+                raise ImproperlyConfigured(
+                    f"Feed method {attname!r} decorated by {func.__name__!r} needs to "
+                    f"use @functools.wraps."
+                )
+            if code.co_argcount == 2:  # one argument is 'self'
+                return attr(obj)
+            else:
+                return attr()
+        return attr
+
+    def feed_extra_kwargs(self, obj):
+        """
+        Return an extra keyword arguments dictionary that is used when
+        initializing the feed generator.
+        """
+        return {}
+
+    def item_extra_kwargs(self, item):
+        """
+        Return an extra keyword arguments dictionary that is used with
+        the `add_item` call of the feed generator.
+        """
+        return {}
+
+    def get_object(self, request, *args, **kwargs):
+        return None
+
+    def get_context_data(self, **kwargs):
+        """
+        Return a dictionary to use as extra context if either
+        ``self.description_template`` or ``self.item_template`` are used.
+
+        Default implementation preserves the old behavior
+        of using {'obj': item, 'site': current_site} as the context.
+        """
+        return {"obj": kwargs.get("item"), "site": kwargs.get("site")}
+
+    def get_feed(self, obj, request):
+        """
+        Return a feedgenerator.DefaultFeed object, fully populated, for
+        this feed. Raise FeedDoesNotExist for invalid parameters.
+        """
+        current_site = get_current_site(request)
+
+        link = self._get_dynamic_attr("link", obj)
+        link = add_domain(current_site.domain, link, request.is_secure())
+
+        feed = self.feed_type(
+            title=self._get_dynamic_attr("title", obj),
+            subtitle=self._get_dynamic_attr("subtitle", obj),
+            link=link,
+            description=self._get_dynamic_attr("description", obj),
+            language=self.language or get_language(),
+            feed_url=add_domain(
+                current_site.domain,
+                self._get_dynamic_attr("feed_url", obj) or request.path,
+                request.is_secure(),
+            ),
+            author_name=self._get_dynamic_attr("author_name", obj),
+            author_link=self._get_dynamic_attr("author_link", obj),
+            author_email=self._get_dynamic_attr("author_email", obj),
+            categories=self._get_dynamic_attr("categories", obj),
+            feed_copyright=self._get_dynamic_attr("feed_copyright", obj),
+            feed_guid=self._get_dynamic_attr("feed_guid", obj),
+            ttl=self._get_dynamic_attr("ttl", obj),
+            **self.feed_extra_kwargs(obj),
+        )
+
+        title_tmp = None
+        if self.title_template is not None:
+            try:
+                title_tmp = loader.get_template(self.title_template)
+            except TemplateDoesNotExist:
+                pass
+
+        description_tmp = None
+        if self.description_template is not None:
+            try:
+                description_tmp = loader.get_template(self.description_template)
+            except TemplateDoesNotExist:
+                pass
+
+        for item in self._get_dynamic_attr("items", obj):
+            context = self.get_context_data(
+                item=item, site=current_site, obj=obj, request=request
+            )
+            if title_tmp is not None:
+                title = title_tmp.render(context, request)
+            else:
+                title = self._get_dynamic_attr("item_title", item)
+            if description_tmp is not None:
+                description = description_tmp.render(context, request)
+            else:
+                description = self._get_dynamic_attr("item_description", item)
+            link = add_domain(
+                current_site.domain,
+                self._get_dynamic_attr("item_link", item),
+                request.is_secure(),
+            )
+            enclosures = self._get_dynamic_attr("item_enclosures", item)
+            author_name = self._get_dynamic_attr("item_author_name", item)
+            if author_name is not None:
+                author_email = self._get_dynamic_attr("item_author_email", item)
+                author_link = self._get_dynamic_attr("item_author_link", item)
+            else:
+                author_email = author_link = None
+
+            tz = get_default_timezone()
+
+            pubdate = self._get_dynamic_attr("item_pubdate", item)
+            if pubdate and is_naive(pubdate):
+                pubdate = make_aware(pubdate, tz)
+
+            updateddate = self._get_dynamic_attr("item_updateddate", item)
+            if updateddate and is_naive(updateddate):
+                updateddate = make_aware(updateddate, tz)
+
+            feed.add_item(
+                title=title,
+                link=link,
+                description=description,
+                unique_id=self._get_dynamic_attr("item_guid", item, link),
+                unique_id_is_permalink=self._get_dynamic_attr(
+                    "item_guid_is_permalink", item
+                ),
+                enclosures=enclosures,
+                pubdate=pubdate,
+                updateddate=updateddate,
+                author_name=author_name,
+                author_email=author_email,
+                author_link=author_link,
+                comments=self._get_dynamic_attr("item_comments", item),
+                categories=self._get_dynamic_attr("item_categories", item),
+                item_copyright=self._get_dynamic_attr("item_copyright", item),
+                **self.item_extra_kwargs(item),
+            )
+        return feed