Appen ”statiska filerLink to this heading#

samla statisktLink to this heading#

django-admin collectstaticLink to this definition#

Samlar de statiska filerna i STATIC_ROOT.

Duplicerade filnamn löses som standard på ett liknande sätt som mallupplösning fungerar: den fil som först hittas på en av de angivna platserna kommer att användas. Om du är förvirrad kan kommandot findstatic hjälpa dig att visa vilka filer som hittas.

Vid efterföljande körningar av collectstatic (om STATIC_ROOT inte är tom) kopieras filer endast om de har en ändrad tidsstämpel som är större än tidsstämpeln för filen i STATIC_ROOT. Om du tar bort ett program från INSTALLED_APPS är det därför en god idé att använda alternativet collectstatic --clear för att ta bort inaktuella statiska filer.

Filer söks med hjälp av enabled finders. Standardinställningen är att leta på alla platser som definieras i STATICFILES_DIRS och i katalogen 'static' för appar som anges i INSTALLED_APPS.

Hanteringskommandot collectstatic anropar metoden post_process() för lagringsbackend staticfiles från STORAGES efter varje körning och skickar en lista över sökvägar som har hittats av hanteringskommandot. Den tar också emot alla kommandoradsalternativ för collectstatic. Detta används av ManifestStaticFilesStorage som standard.

Som standard får insamlade filer behörigheter från FILE_UPLOAD_PERMISSIONS och insamlade kataloger får behörigheter från FILE_UPLOAD_DIRECTORY_PERMISSIONS. Om du vill ha olika behörigheter för dessa filer och/eller kataloger kan du underklassa någon av static files storage classes och ange parametrarna file_permissions_mode respektive directory_permissions_mode. Till exempel:

from django.contrib.staticfiles import storage


class MyStaticFilesStorage(storage.StaticFilesStorage):
    def __init__(self, *args, **kwargs):
        kwargs["file_permissions_mode"] = 0o640
        kwargs["directory_permissions_mode"] = 0o760
        super().__init__(*args, **kwargs)

Ställ sedan in lagringsbackend för staticfiles i STORAGES till 'path.to.MyStaticFilesStorage'.

Några vanligt förekommande alternativ är:

--noinput, --no-inputLink to this definition#

Be INTE användaren om någon form av inmatning.

--ignore PATTERN, -i PATTERNLink to this definition#

Ignorera filer, kataloger eller sökvägar som matchar detta glob-liknande mönster. Använd flera gånger för att ignorera fler. När du anger en sökväg ska du alltid använda snedstreck, även i Windows.

--dry-run, -nLink to this definition#

Gör allt utom att modifiera filsystemet.

--clear, -cLink to this definition#

Rensa de befintliga filerna innan du försöker kopiera eller länka originalfilen.

--link, -lLink to this definition#

Skapa en symbolisk länk till varje fil i stället för att kopiera.

--no-post-processLink to this definition#

Anropa inte post_process()-metoden för den konfigurerade staticfiles-lagringsbackend från STORAGES.

--no-default-ignoreLink to this definition#

Ignorera inte de vanliga privata glob-stilmönstren 'CVS', '.*' och '*~'.

En fullständig lista över alternativ finns i kommandots egen hjälpfunktion genom att köra:

$ python manage.py collectstatic --help

...\> py manage.py collectstatic --help

from django.contrib.staticfiles.apps import StaticFilesConfig


class MyStaticFilesConfig(StaticFilesConfig):
    ignore_patterns = [...]  # your custom ignore list

findstaticLink to this heading#

django-admin findstatic staticfile [staticfile ...]Link to this definition#

Söker efter en eller flera relativa sökvägar med de aktiverade sökarna.

Till exempel:

$ python manage.py findstatic css/base.css admin/js/core.js
Found 'css/base.css' here:
  /home/special.polls.com/core/static/css/base.css
  /home/polls.com/core/static/css/base.css
Found 'admin/js/core.js' here:
  /home/polls.com/src/django/contrib/admin/media/js/core.js

...\> py manage.py findstatic css\base.css admin\js\core.js
Found 'css/base.css' here:
  /home/special.polls.com/core/static/css/base.css
  /home/polls.com/core/static/css/base.css
Found 'admin/js/core.js' here:
  /home/polls.com/src/django/contrib/admin/media/js/core.js

findstatic --firstLink to this definition#

Som standard hittas alla matchande platser. Om du bara vill returnera den första matchningen för varje relativ sökväg använder du alternativet --first:

$ python manage.py findstatic css/base.css --first
Found 'css/base.css' here:
  /home/special.polls.com/core/static/css/base.css

...\> py manage.py findstatic css\base.css --first
Found 'css/base.css' here:
  /home/special.polls.com/core/static/css/base.css

Detta är ett hjälpmedel för felsökning; det visar exakt vilken statisk fil som kommer att samlas in för en viss sökväg.

Genom att ställa in flaggan --verbosity till 0 kan du undertrycka den extra utmatningen och bara få sökvägsnamnen:

$ python manage.py findstatic css/base.css --verbosity 0
/home/special.polls.com/core/static/css/base.css
/home/polls.com/core/static/css/base.css

...\> py manage.py findstatic css\base.css --verbosity 0
/home/special.polls.com/core/static/css/base.css
/home/polls.com/core/static/css/base.css

Om du däremot sätter flaggan --verbosity till 2 kan du få fram alla kataloger som genomsöktes:

$ python manage.py findstatic css/base.css --verbosity 2
Found 'css/base.css' here:
  /home/special.polls.com/core/static/css/base.css
  /home/polls.com/core/static/css/base.css
Looking in the following locations:
  /home/special.polls.com/core/static
  /home/polls.com/core/static
  /some/other/path/static

...\> py manage.py findstatic css\base.css --verbosity 2
Found 'css/base.css' here:
  /home/special.polls.com/core/static/css/base.css
  /home/polls.com/core/static/css/base.css
Looking in the following locations:
  /home/special.polls.com/core/static
  /home/polls.com/core/static
  /some/other/path/static

runserverLink to this heading#

django-admin runserver [addrport]

Åsidosätter kärnkommandot runserver om appen staticfiles är installed och lägger till automatisk servering av statiska filer. Filservering körs inte genom MIDDLEWARE.

Kommandot lägger till dessa alternativ:

--nostaticLink to this definition#

Använd alternativet --nostatic för att inaktivera servering av statiska filer med appen staticfiles helt och hållet. Det här alternativet är endast tillgängligt om appen staticfiles finns i projektets inställning INSTALLED_APPS.

Exempel på användning:

$ django-admin runserver --nostatic

...\> django-admin runserver --nostatic

--insecureLink to this definition#

Använd alternativet --insecure för att tvinga fram servering av statiska filer med appen staticfiles även om inställningen DEBUG` är False. Genom att använda detta godkänner du det faktum att det är grovt ineffektivt och förmodligen osäkert. Detta är endast avsett för lokal utveckling, bör aldrig användas i produktion och är endast tillgängligt om staticfiles-appen finns i ditt projekts INSTALLED_APPS-inställning.

--insecure fungerar inte med ManifestStaticFilesStorage.

Exempel på användning:

$ django-admin runserver --insecure

...\> django-admin runserver --insecure

StaticFilesStorageLink to this heading#

class storage.StaticFilesStorageLink to this definition#

En underklass av lagringsbackend FileSystemStorage som använder inställningen STATIC_ROOT som basplats för filsystemet och inställningen STATIC_URL som bas-URL.

storage.StaticFilesStorage.post_process(paths, **options)Link to this definition#

Om den här metoden är definierad på en lagringsplats anropas den av kommandot collectstatic efter varje körning och får de lokala lagringsplatserna och sökvägarna till de filer som hittats som en ordbok, samt kommandoradsalternativen. Den ger tupler med tre värden: original_path, processed_path, processed. Sökvägsvärdena är strängar och processed är en boolean som anger om värdet har efterbearbetats eller inte, eller ett undantag om efterbearbetningen misslyckades.

Klassen:~django.contrib.staticfiles.storage.ManifestStaticFilesStorage använder detta bakom kulisserna för att ersätta sökvägarna med deras hashade motsvarigheter och uppdatera cacheminnet på lämpligt sätt.

ManifestStaticFilesStorageLink to this heading#

class storage.ManifestStaticFilesStorageLink to this definition#

En underklass av StaticFilesStorage lagringsbackend som lagrar filnamnen som den hanterar genom att lägga till MD5-hashen av filens innehåll till filnamnet. Till exempel: skulle filen css/styles.css också sparas som css/styles.55e7cbb9ba48.css.

Syftet med denna lagring är att fortsätta servera de gamla filerna om vissa sidor fortfarande hänvisar till dessa filer, t.ex. för att de är cachade av dig eller en proxyserver från tredje part. Dessutom är det mycket användbart om du vill tillämpa far future Expires headers på de distribuerade filerna för att påskynda laddningstiden för efterföljande sidbesök.

Lagringsbackenden ersätter automatiskt sökvägarna som finns i de sparade filer som matchar andra sparade filer med sökvägen till den cachade kopian (med metoden post_process()). De reguljära uttryck som används för att hitta dessa sökvägar (django.contrib.staticfiles.storage.HashedFilesMixin.patterns) täcker:

• Regeln @import och uttalandet url() i Cascading Style Sheets.

• Source map-kommentarer i CSS- och JavaScript-filer.

Subclass ManifestStaticFilesStorage och sätt attributet upport_js_module_import_aggregation till True, om du vill använda de experimentella reguljära uttrycken för att täcka:

• modules import i JavaScript.

• Aggregatet modules aggregation i JavaScript.

Till exempel: filen 'css/styles.css' med detta innehåll:

@import url("../admin/css/base.css");

…skulle ersättas genom att anropa url()-metoden för lagringsbackend ManifestStaticFilesStorage, vilket i slutändan sparar en 'css/styles.55e7cbb9ba48.css'-fil med följande innehåll:

@import url("../admin/css/base.27e20196a850.css");

Du kan ändra platsen för manifestfilen genom att använda en anpassad underklass till ManifestStaticFilesStorage som anger argumentet manifest_storage. Till exempel:

from django.conf import settings
from django.contrib.staticfiles.storage import (
    ManifestStaticFilesStorage,
    StaticFilesStorage,
)


class MyManifestStaticFilesStorage(ManifestStaticFilesStorage):
    def __init__(self, *args, **kwargs):
        manifest_storage = StaticFilesStorage(location=settings.BASE_DIR)
        super().__init__(*args, manifest_storage=manifest_storage, **kwargs)

storage.ManifestStaticFilesStorage.manifest_hashLink to this definition#

Det här attributet ger en enda hash som ändras när en fil i manifestet ändras. Detta kan vara användbart för att kommunicera till SPA:er att tillgångarna på servern har ändrats (på grund av en ny distribution).

storage.ManifestStaticFilesStorage.max_post_process_passesLink to this definition#

Eftersom statiska filer kan referera till andra statiska filer som behöver få sina sökvägar ersatta, kan det behövas flera omgångar för att ersätta sökvägar tills filhasharna konvergerar. För att förhindra en oändlig loop på grund av att hasharna inte konvergerar (t.ex. om 'foo.css'' refererar till ``'bar.css'' som refererar till ``'foo.css'') finns det ett maximalt antal genomgångar innan efterbehandlingen avbryts. I fall med ett stort antal referenser kan ett högre antal passeringar behövas. Öka det maximala antalet passeringar genom att underklassa ``ManifestStaticFilesStorage och ställa in attributet max_post_process_passes. Standardvärdet är 5.

För att aktivera ManifestStaticFilesStorage måste du se till att följande krav är uppfyllda:

• lagringsbackend för staticfiles i STORAGES inställningen är inställd på 'django.contrib.staticfiles.storage.ManifestStaticFilesStorage'

• inställningen DEBUG är satt till False

• du har samlat in alla dina statiska filer med hjälp av hanteringskommandot collectstatic

Eftersom skapandet av MD5-hashen kan vara en prestandabörda för din webbplats under körning, kommer staticfiles automatiskt att lagra mappningen med hashade namn för alla bearbetade filer i en fil som heter staticfiles.json. Detta sker en gång när du kör hanteringskommandot collectstatic.

storage.ManifestStaticFilesStorage.manifest_strictLink to this definition#

Om en fil inte hittas i manifestet staticfiles.json vid körning, uppstår ett ValueError. Detta beteende kan inaktiveras genom att underklassa ManifestStaticFilesStorage och ställa in attributet manifest_strict till False - icke-existerande sökvägar kommer att förbli oförändrade.

På grund av kravet på att köra collectstatic, bör denna lagring vanligtvis inte användas när du kör tester eftersom collectstatic inte körs som en del av den normala testinställningen. Under testning, se till att staticfiles lagringsbackend i STORAGES-inställningen är inställd på något annat som 'django.contrib.staticfiles.storage.StaticFilesStorage' (standard).

storage.ManifestStaticFilesStorage.file_hash(name, content=None)Link to this definition#

Den metod som används när man skapar det hashade namnet på en fil. Måste returnera en hash för det angivna filnamnet och innehållet. Som standard beräknas en MD5-hash från innehållets chunks som nämnts ovan. Du får gärna åsidosätta den här metoden för att använda din egen hashalgoritm.

ManifestFilesMixinLink to this heading#

class storage.ManifestFilesMixinLink to this definition#

Använd denna mixin med en anpassad lagring för att lägga till MD5-hashen för filens innehåll till filnamnet på samma sätt som ManifestStaticFilesStorage gör.

Vy för utveckling av statiska filerLink to this heading#

Verktygen för statiska filer är främst utformade för att hjälpa till med att få statiska filer framgångsrikt distribuerade i produktion. Detta innebär vanligtvis en separat, dedikerad statisk filserver, vilket är en hel del overhead att röra med när man utvecklar lokalt. Således levereras appen staticfiles med en snabb och smutsig hjälpvy som du kan använda för att servera filer lokalt under utveckling.

views.serve(request, path)Link to this definition#

Denna vyfunktion serverar statiska filer under utveckling.

Den här vyn aktiveras automatiskt av runserver (med inställningen DEBUG inställd på True). Om du vill använda vyn med en annan lokal utvecklingsserver lägger du till följande stycke i slutet av konfigurationen för den primära URL:en:

from django.conf import settings
from django.contrib.staticfiles import views
from django.urls import re_path

if settings.DEBUG:
    urlpatterns += [
        re_path(r"^static/(?P<path>.*)$", views.serve),
    ]

Observera att början av mönstret (r'^static/') ska vara din STATIC_URL-inställning.

Eftersom det här är lite krångligt finns det också en hjälpfunktion som gör det åt dig:

urls.staticfiles_urlpatterns()Link to this definition#

Detta returnerar rätt URL-mönster för servering av statiska filer till din redan definierade mönsterlista. Använd det så här:

from django.contrib.staticfiles.urls import staticfiles_urlpatterns

# ... the rest of your URLconf here ...

urlpatterns += staticfiles_urlpatterns()

Detta kommer att inspektera din STATIC_URL-inställning och koppla upp vyn för att servera statiska filer i enlighet därmed. Glöm inte att ställa in STATICFILES_DIRS på rätt sätt för att låta django.contrib.staticfiles veta var de ska leta efter filer utöver filer i appkataloger.

Specialiserat testfall för att stödja ”live-testningLink to this heading#

class testing.StaticLiveServerTestCaseLink to this definition#

Denna unittest TestCase-underklass utökar django.test.LiveServerTestCase.

Precis som sin förälder kan du använda den för att skriva tester som innebär att du kör koden under test och konsumerar den med testverktyg via HTTP (t.ex. Selenium, PhantomJS, etc.), varför det behövs att de statiska tillgångarna också publiceras.

Men med tanke på att den använder django.contrib.staticfiles.views.serve()-vyn som beskrivs ovan, kan den på ett transparent sätt lägga över de tillgångar som tillhandahålls av staticfiles-sökarna vid testkörningstiden. Detta innebär att du inte behöver köra collectstatic före eller som en del av din testkonfiguration.